Project

General

Profile

Feature #2943 » MinovaXtype.js

Tri Rizqiaty, 08/06/2024 02:04 PM

 
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
				typeselect:'undefined',
881
                //modal: true,
882
                listeners: {					
883
                    'beforeshow': function (g) {
884
						if(tableName == 'PDSEMP0002') //add by Tri nwh 20230202 untuk appraisalid PMS
885
						{ 
886
						}else if(tableName == 'PDSWFCUSTITEMID'){
887
							var activeform =''
888
							if(Ext.ComponentQuery.query('[name=addwbs]')[0]!= undefined){
889
								activeform =Ext.ComponentQuery.query('[name=addwbs]')[0];
890
							}
891
							if(Ext.ComponentQuery.query('[name=addwbsbelow]')[0]!= undefined){
892
								activeform =Ext.ComponentQuery.query('[name=addwbsbelow]')[0];
893
							}
894
							if(Ext.ComponentQuery.query('[name=editwbs]')[0]!= undefined){
895
								activeform =Ext.ComponentQuery.query('[name=editwbs]')[0];
896
							}
897
							
898
							var itemid = activeform.getForm().findField('ItemType').getValue();
899
							if(itemid=='0'){
900
								this.typeselect='0';
901
							}
902
							else if(itemid=='1'){
903
								this.typeselect='1';
904
							}
905
							else if(itemid=='2'){
906
								this.typeselect='2';
907
							}else{}
908
						}else
909
						{
910
							pnl.mask('Loading...');
911
							setTimeout(function () {
912
								pnl.unmask();
913
							}, 100);
914
						}
915
                    }
916
                },
917
                items: [{
918
                    xtype: 'minovaform',
919
                    bodyBorder: false,
920
                    MaxHeigth: '100',
921
                    cls: 'borderLookup',
922
                    border: false,
923
                    MaxHeigth: '30',
924
                    scroll: true,
925
                    isLookup: true,
926
                    name: "formLookupFilter",
927
                    tableName: this.tableName,
928
					tableselection:undefined,
929
                    buttons: [{
930
                        text: 'Search',
931
                        //iconCls : 'fa-edit',
932
                        //style : 'font-family: FontAwesome',
933
                        handler: function () {
934

    
935
                            var store = Ext.data.StoreManager.lookup('lookupStore');
936
                            var form = Ext.ComponentQuery.query('[name=formLookupFilter]')[0].getForm();
937
                            grid = Ext.ComponentQuery.query('[name=gridLookup]')[0];
938
                            var values_ = form.getValues();
939
                            var fields_ = form.getFields().items;
940
                            var param_ = '';
941
                            for (var i = 0; i < fields_.length; i++) {
942
                                var val_ = form.getFields().items[i].getValue();
943
                                var xtype_ = form.getFields().items[i].xtype;
944
                                var oprator_ = '[like]';
945
                                if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
946
                                    oprator_ = '[Equal]';
947
                                }
948
                                if (xtype_ == 'datefield') {
949
                                    if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
950
                                        oprator_ = '[LessThanEqual]';
951
                                    } else {
952
                                        oprator_ = '[GreaterThanEqual]';
953
                                    }
954
                                }
955
                                if (val_ != 'undefined' && val_ != "" && val_ != null) {
956
                                    param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
957
                                }
958
                            }
959

    
960
                            if (SearchFunction_ != undefined && SearchFunction_ != "") {
961
                                eval(SearchFunction_);
962
                            } else {
963
								if(grid.tableName=='PDSWFCUSTITEMID'){
964
									
965
									var columns = Ext.ComponentQuery.query('[name=gridLookup]')[0].getView().headerCt.getGridColumns();
966
									var typeselect = Ext.ComponentQuery.query('[name=lookupMain]')[0].typeselect;
967
									var mytablename='';
968
									if(typeselect=='0'){
969
										mytablename='PMDMAT0001';
970
										Ext.each(columns, function (col) {           
971
											if ( col.text== "Code") {
972
												col.text="Material ID";
973
											}  
974
											if ( col.text== "Desc") {
975
												col.text="Description";
976
											} 		
977
											if ( col.dataIndex== "Code") {
978
												col.dataIndex="MaterialID";
979
											}  
980
											if ( col.dataIndex== "Desc") {
981
												col.dataIndex="Description";
982
											} 											
983
										});										
984
									}
985
									if(typeselect=='1'){
986
										mytablename='PMDSRV0001';
987
										Ext.each(columns, function (col) {           
988
											if ( col.text== "Code") {
989
												col.text="Service ID";
990
											}  
991
											if ( col.text== "Desc") {
992
												col.text="Description";
993
											} 
994
											if ( col.dataIndex== "Code") {
995
												col.dataIndex="ServiceID";
996
											}  
997
											if ( col.dataIndex== "Desc") {
998
												col.dataIndex="Description";
999
											} 													
1000
										});											
1001
									}
1002
									if (typeselect=='2'){
1003
										mytablename='PMDAST0001';
1004
										Ext.each(columns, function (col) {           
1005
											if ( col.text== "Code") {
1006
												col.text="Asset Code";
1007
											}  
1008
											if ( col.text== "Asset Name") {
1009
												col.text="Description";
1010
											} 
1011
											if ( col.dataIndex== "Code") {
1012
												col.dataIndex="AssetCode";
1013
											}  
1014
											if ( col.dataIndex== "Desc") {
1015
												col.dataIndex="AssetName";
1016
											} 											
1017
										});											
1018
									}									
1019
									
1020
									store.proxy.extraParams = {
1021
										tableName: mytablename,
1022
										param: param_,
1023
										menuId: MinovaUtil.GetMenuID()
1024
									};											
1025
								}else{									
1026
									store.proxy.extraParams = {
1027
										tableName: grid.tableName,
1028
										param: param_,
1029
										menuId: MinovaUtil.GetMenuID()
1030
									};									
1031
								}
1032

    
1033
                            }
1034
                            store.removeAll();
1035
                            store.reload();
1036
                            store.loadPage(1);
1037
                        }
1038

    
1039
                    }
1040
                    ],
1041
                }, {
1042
                    xtype: 'minovagrid2',
1043
                    isLookup: true,
1044
                    autoLoad: false,
1045
                    minHeight: 240,
1046
                    height: 340,
1047
                    tableName: this.tableName,
1048
                    param: '',
1049
                    //name: 'gridForm' + this.tableName,
1050
                    name: 'gridLookup',
1051
                    hidebutton: 0,
1052
                    pagesize: 25,
1053
                    storename: 'lookupStore',
1054
                    fieldGrid: fieldGrid_,
1055
                    listeners: {
1056
                        itemdblclick: function (g) {
1057
                            var LookupFunction = LookupFunction_;
1058

    
1059
                            var me = this;
1060
                            var selection = this.getView().getSelectionModel().getSelection()[0];
1061
                            var pnlMain = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0];
1062
                            var name_ = 'form[name=' + formtarget_ + ']';
1063
                            if (pnlMain) {
1064
                                name_ = 'form[name=' + formtarget_ + pnlMain.nameTable + ']';
1065
                            }
1066

    
1067
                            var formM = Ext.ComponentQuery.query(name_)[0];
1068
                            var form_ = null;
1069
                            if (!formM) {
1070
                                form_ = Ext.ComponentQuery.query('[name=MinovaGridFormEdit]')[0].getForm();
1071
                            } else {
1072
                                form_ = formM.getForm();
1073
                            }
1074
                            var mainLookup = Ext.ComponentQuery.query('[name=lookupMain]')[0];
1075
                            var targetField = mainLookup.fieldTarget;
1076
                            if (mainLookup.isGrid) {
1077
                                var b = Ext.ComponentQuery.query('[fieldGrid=' + me.fieldGrid + ']')[0];
1078
                                if (b) {
1079
                                    b.setValue(eval('selection.data.' + me.fieldGrid));
1080
                                }
1081
                                if (targetField) {
1082
                                    targetField = targetField.split('$')
1083
                                    var dt = targetField[0].split(',');
1084
                                    var fieldValue = targetField[1].split(',');
1085
                                    if (fieldValue.length > 0) {
1086
                                        for (i in dt) {
1087
                                            field_ = dt[i];
1088
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
1089
                                        }
1090
                                    } else {
1091
                                        for (i in dt) {
1092
                                            field_ = dt[i];
1093
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
1094
                                        }
1095
                                    }
1096

    
1097
                                }
1098
                            } else { // untuk form
1099
                                if (targetField) {
1100
                                    var dt = targetField.split(',');
1101
                                    var fieldValue = mainLookup.fieldValue.split(',');
1102
                                    if (fieldValue.length > 0) {
1103
                                        for (i in dt) {
1104
                                            field_ = dt[i];
1105
                                            Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
1106
                                        }
1107
                                    } else {
1108
                                        for (i in dt) {
1109
                                            field_ = dt[i];
1110
                                            Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
1111
                                        }
1112
                                    }
1113
                                } else {
1114
					
1115
                                    form_.setValues(selection.data);
1116
									if(me.tableName=='PDSWFCUSTITEMID'){
1117
										var activeform =''
1118
										if(Ext.ComponentQuery.query('[name=addwbs]')[0]!= undefined){
1119
											activeform =Ext.ComponentQuery.query('[name=addwbs]')[0];
1120
										}
1121
										if(Ext.ComponentQuery.query('[name=addwbsbelow]')[0]!= undefined){
1122
											activeform =Ext.ComponentQuery.query('[name=addwbsbelow]')[0];
1123
										}
1124
										if(Ext.ComponentQuery.query('[name=editwbs]')[0]!= undefined){
1125
											activeform =Ext.ComponentQuery.query('[name=editwbs]')[0];
1126
										}									
1127
										var itemid = activeform.getForm().findField('ItemType').getValue();	
1128
										
1129
										if(itemid=='0'){
1130
											form_.findField('DocItemID').setValue(selection.data.MaterialID);
1131
										}
1132
										else if(itemid=='1'){
1133
											form_.findField('DocItemID').setValue(selection.data.ServiceID);
1134
										}
1135
										else if(itemid=='2'){
1136
											form_.findField('DocItemID').setValue(selection.data.AssetCode);
1137
										}else{}	
1138
									}
1139
                                }
1140
                            }
1141
                            eval(LookupFunction);
1142
                            mainLookup.destroy();
1143
                        },
1144
                        beforeedit: function (grid) {
1145
                            return false;
1146
                        }
1147
                    },
1148
                    dockedItems: [{
1149
                        xtype: 'pagingtoolbar',
1150
                        store: 'lookupStore',
1151
                        dock: 'bottom',
1152
                        pageSize: 25,
1153
                        displayInfo: true
1154
                    }
1155
                    ]
1156

    
1157
                }, ]
1158
            }).show();
1159
        }
1160
        //Ext.create('Ext.window.Window', {
1161
        //    title: 'Lookup - ' + this.fieldLabel,
1162
        //    height: 530,
1163
        //    width: 500,
1164
        //    fieldTarget: fieldTarget_,
1165
        //    fieldValue: fieldValue_,
1166
        //    isGrid: isGrid_,
1167
        //    name: 'lookupMain',
1168
        //    //modal: true,
1169
        //    listeners: {
1170
        //        'beforeshow': function (g) {
1171
        //            pnl.mask('Loading...');
1172
        //            setTimeout(function () {
1173
        //                pnl.unmask();
1174
        //            }, 100);
1175
        //        }
1176
        //    },
1177
        //    items: [{
1178
        //        xtype: 'minovaform',
1179
        //        bodyBorder: false,
1180
        //        MaxHeigth: '100',
1181
        //        cls: 'borderLookup',
1182
        //        border: false,
1183
        //        MaxHeigth: '30',
1184
        //        scroll: true,
1185
        //        isLookup: true,
1186
        //        name: "formLookupFilter",
1187
        //        tableName: this.tableName,
1188
        //        buttons: [{
1189
        //            text: 'Search',
1190
        //            //iconCls : 'fa-edit',
1191
        //            //style : 'font-family: FontAwesome',
1192
        //            handler: function () {
1193
        //                var store = Ext.data.StoreManager.lookup('lookupStore');
1194
        //                var form = Ext.ComponentQuery.query('[name=formLookupFilter]')[0].getForm();
1195
        //                grid = Ext.ComponentQuery.query('[name=gridLookup]')[0];
1196
        //                var values_ = form.getValues();
1197
        //                var fields_ = form.getFields().items;
1198
        //                var param_ = '';
1199
        //                for (var i = 0; i < fields_.length; i++) {
1200
        //                    var val_ = form.getFields().items[i].getValue();
1201
        //                    var xtype_ = form.getFields().items[i].xtype;
1202
        //                    var oprator_ = '[like]';
1203
        //                    if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
1204
        //                        oprator_ = '[Equal]';
1205
        //                    }
1206
        //                    if (xtype_ == 'datefield') {
1207
        //                        if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
1208
        //                            oprator_ = '[LessThanEqual]';
1209
        //                        } else {
1210
        //                            oprator_ = '[GreaterThanEqual]';
1211
        //                        }
1212
        //                    }
1213
        //                    if (val_ != 'undefined' && val_ != "" && val_ != null) {
1214
        //                        param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
1215
        //                    }
1216
        //                }
1217
        //                store.proxy.extraParams = {
1218
        //                    tableName: grid.tableName,
1219
        //                    param: param_
1220
        //                };
1221
        //                store.removeAll();
1222
        //                store.reload();
1223
        //                store.loadPage(1);
1224
        //            }
1225

    
1226
        //        }
1227
        //        ],
1228
        //    }, {
1229
        //        xtype: 'minovagrid1',
1230
        //        isLookup: true,
1231
        //        autoLoad: false,
1232
        //        minHeight: 280,
1233
        //        height: 380,
1234
        //        tableName: this.tableName,
1235
        //        param: '',
1236
        //        //name: 'gridForm' + this.tableName,
1237
        //        name: 'gridLookup',
1238
        //        hidebutton: 0,
1239
        //        pagesize: 25,
1240
        //        storename: 'lookupStore',
1241
        //        listeners: {
1242
        //            itemdblclick: function (g) {
1243
        //                var me = this;
1244
        //                var selection = this.getView().getSelectionModel().getSelection()[0];
1245
        //                var name_ = 'form[name=' + formtarget_ + ']';
1246
        //                var form_ = Ext.ComponentQuery.query(name_)[0].getForm();
1247
        //                var mainLookup = Ext.ComponentQuery.query('[name=lookupMain]')[0];
1248
        //                var targetField = mainLookup.fieldTarget;
1249
        //                if (mainLookup.isGrid) {
1250
        //                    if (targetField) {
1251
        //                        targetField = targetField.split('$')
1252
        //                        var dt = targetField[0].split(',');
1253
        //                        var fieldValue = targetField[1].split(',');
1254
        //                        if (fieldValue.length > 0) {
1255
        //                            for (i in dt) {
1256
        //                                field_ = dt[i];
1257
        //                                Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
1258
        //                            }
1259
        //                        } else {
1260
        //                            for (i in dt) {
1261
        //                                field_ = dt[i];
1262
        //                                Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
1263
        //                            }
1264
        //                        }
1265

    
1266

    
1267
        //                    }
1268
        //                }
1269
        //                else {// untuk form
1270
        //                    if (targetField) {
1271
        //                        var dt = targetField.split(',');
1272
        //                        var fieldValue = mainLookup.fieldValue.split(',');
1273
        //                        if (fieldValue.length > 0) {
1274
        //                            for (i in dt) {
1275
        //                                field_ = dt[i];
1276
        //                                Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
1277
        //                            }
1278
        //                        } else {
1279
        //                            for (i in dt) {
1280
        //                                field_ = dt[i];
1281
        //                                Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
1282
        //                            }
1283
        //                        }
1284
        //                    }
1285
        //                    else {
1286
        //                        form_.setValues(selection.data);
1287
        //                    }
1288
        //                }
1289

    
1290
        //                mainLookup.destroy();
1291
        //            },
1292
        //            beforeedit: function (grid) {
1293
        //                return false;
1294
        //            }
1295
        //        },
1296
        //        dockedItems: [{
1297
        //            xtype: 'pagingtoolbar',
1298
        //            store: 'lookupStore',
1299
        //            dock: 'bottom',
1300
        //            pageSize: 25,
1301
        //            displayInfo: true
1302
        //        }
1303
        //        ]
1304

    
1305
        //    }, ]
1306
        //}).show();
1307

    
1308
    },
1309
});
1310
Ext.define('MinovaUtil.MinovaES.MinovaComboDisplay', {
1311
    extend: 'Ext.form.field.Display',
1312
    alias: ['widget.minovacombodisplay'],
1313
    initComponent: function () {
1314
        this.callParent(arguments);
1315
    },
1316

    
1317
    defaultRenderer: function (value) {
1318
        if (typeof(this.store) !== 'object') {
1319
            this.store = Ext.data.StoreManager.lookup(this.store);
1320
        }
1321
        var idx = this.store.findExact(this.valueField, value);
1322
        if (this.store.getAt(idx)) {
1323
            var result = this.store.getAt(idx).get(this.displayField);
1324
            value = result ? result : value;
1325
        }
1326
        this.setRawValue(value);
1327

    
1328
    }
1329
});
1330
Ext.define('MinovaUtil.MinovaES.DisplayDate', {
1331
    extend: 'Ext.form.field.Display',
1332
    alias: ['widget.minovadisplaydate'],
1333
    undefinedText: '&#160;',
1334
    setValue: function (v) {
1335
        var value = v;
1336
        if (value === undefined) {
1337
            return this.undefinedText;
1338
        }
1339
        if (value === null) {
1340
            return this.setRawValue(null);
1341
        }
1342
        var d = value.substring(6, 8);
1343
        var m = value.substring(4, 6);
1344
        var y = value.substring(0, 4);
1345

    
1346
        var hasil = d + '/' + m + '/' + y;
1347
        //this.setRawValue(hasil);
1348
        this.setValue(hasil);
1349
    },
1350
    getRawValue: function () {
1351
        return this.getValue();
1352
    },
1353
    getValue: function () {
1354
        var value = this.rawValue;
1355
        var hasil = null;
1356
        if (value != undefined) {
1357
            var d = value.substring(0, 2);
1358
            var m = value.substring(3, 5);
1359
            var y = value.substring(6, 10);
1360

    
1361
            hasil = y + m + d;
1362
        }
1363
        return hasil;
1364
    }
1365
});
1366
Ext.define('MinovaUtil.MinovaES.DisplaySysDateTime', {
1367
    extend: 'Ext.form.field.Display',
1368
    alias: ['widget.minovadisplaysysdatetime'],
1369
    undefinedText: '&#160;',
1370
    //hamid
1371
    listeners: {
1372
        change: function (f) {
1373
            var field = f.getValue()
1374
            var value = field;
1375
            if (value === "" || value === undefined) {
1376
                return this.setRawValue("");
1377
            } else {
1378
                var d = value.substring(6, 8);
1379
                var m = value.substring(4, 6);
1380
                var y = value.substring(0, 4);
1381
                var h = value.substring(8, 10);
1382
                var mt = value.substring(10, 12);
1383
                var s = value.substring(12, 14);
1384
                var hasil = d + '/' + m + '/' + y + '  ' + '  ' + h + ':' + mt + ':' + s;
1385

    
1386
            }
1387

    
1388
            f.setRawValue(hasil)
1389
        },
1390
    },
1391
    //end
1392

    
1393
});
1394
Ext.define('MinovaUtil.MinovaES.MinovaButton', {
1395
    extend: 'Ext.button.Button',
1396
    alias: ['widget.minovabutton', 'widget.MinovaButton'],
1397
    nextid: undefined,
1398
    parid: undefined,
1399
    page: undefined,
1400
    start: undefined,
1401
    limit: 1,
1402
    setStart: function (value) {
1403
        var me = this;
1404
        me.start = value;
1405
        return me;
1406
    },
1407
    getStart: function () {
1408
        return this.start;
1409
    },
1410
    setNextid: function (value) {
1411
        var me = this;
1412
        me.nextid = value;
1413
        return me;
1414
    },
1415
    getNextid: function () {
1416
        return this.nextid;
1417
    },
1418
    setParid: function (value) {
1419
        var me = this;
1420
        me.parid = value;
1421
        return me;
1422
    },
1423
    getParid: function () {
1424
        return this.parid;
1425
    },
1426
    anchor: '50%',
1427
    initComponent: function () {
1428
        var me = this;
1429
        Ext.applyIf(me, {});
1430
        me.callParent(arguments);
1431
    }
1432
});
1433
Ext.define('MinovaUtil.MinovaES.MinovaComboBox', {
1434
    extend: 'Ext.form.field.ComboBox',
1435
    alias: ['widget.minovacombobox', 'widget.minovacombo'],
1436
    tableName: undefined,
1437
    param: undefined,
1438
	anyMatch: true,
1439
    anchor: '50%',
1440
    queryMode: 'local',
1441
    forceSelection: true, // cek data
1442
    initComponent: function () {
1443
        var me = this;
1444
        Ext.applyIf(me, {
1445

    
1446
            store: Ext.create('Ext.data.Store', {
1447
                storeId: 'store' + me.name,
1448
                autoLoad: true,
1449
                proxy: {
1450
                    method: 'POST',
1451
                    type: 'ajax',
1452
                    url: '/UserControl/GetStoreAuth',
1453
                    extraParams: {
1454
                        tableName: me.tableName,
1455
                        param: me.param,
1456
                        menuId: MinovaUtil.GetMenuID()
1457
                    },
1458
                    reader: {
1459
                        type: 'json',
1460
                        root: 'data'
1461
                    }
1462
                }
1463
            })
1464
        });
1465
        me.callParent(arguments);
1466
    }
1467
});
1468

    
1469
Ext.define('MinovaUtil.MinovaES.MinovaComboBoxTpl', {
1470
    extend: 'Ext.form.field.ComboBox',
1471
    alias: ['widget.minovacomboboxtpl', 'widget.minovacombotpl'],
1472
    tableName: undefined,
1473
    param: undefined,
1474
    dis1: undefined,
1475
    dis2: undefined,
1476
    anchor: '50%',
1477
    queryMode: 'local',
1478
    forceSelection: true,
1479
    tpl: Ext.create('Ext.XTemplate',
1480
		'<tpl for=".">',
1481
		'<div class="x-boundlist-item">' + this.dis1 + '</div>',
1482
		'</tpl>'),
1483
    displayTpl: Ext.create('Ext.XTemplate',
1484
		'<tpl for=".">',
1485
		+this.dis1,
1486
		'</tpl>'),
1487
    initComponent: function () {
1488
        var me = this;
1489
        Ext.applyIf(me, {
1490
            store: Ext.create('Ext.data.Store', {
1491
                storeId: 'store' + me.name,
1492
                autoLoad: true,
1493
                proxy: {
1494
                    method: 'POST',
1495
                    type: 'ajax',
1496
                    url: '/UserControl/GetStore',
1497
                    extraParams: {
1498
                        tableName: me.tableName,
1499
                        param: me.param
1500
                    },
1501
                    reader: {
1502
                        type: 'json',
1503
                        root: 'data'
1504
                    }
1505
                }
1506
            })
1507
        });
1508
        me.callParent(arguments);
1509
    }
1510
});
1511
Ext.define('MinovaUtil.MinovaES.MinovaMultiComboBox', {
1512
    extend: 'Ext.form.field.ComboBox',
1513
    alias: ['widget.minovamulticombobox', 'widget.minovamulticombo'],
1514
    tableName: undefined,
1515
    param: undefined,
1516
    anchor: '50%',
1517
    queryMode: 'local',
1518
    forceSelection: true, // cek data
1519
    multiSelect: true,
1520
    getValue: function () {
1521
        var hasil = null;
1522
        var val = this.value;
1523
        if (val != undefined) {
1524
            hasil = val.toString();
1525
        }
1526
        return hasil;
1527
    },
1528
    initComponent: function () {
1529
        var me = this;
1530
        Ext.applyIf(me, {
1531
            store: Ext.create('Ext.data.Store', {
1532
                storeId: 'store' + me.name,
1533
                autoLoad: true,
1534
                proxy: {
1535
                    method: 'POST',
1536
                    type: 'ajax',
1537
                    url: '/UserControl/GetStore',
1538
                    extraParams: {
1539
                        tableName: me.tableName,
1540
                        param: me.param
1541
                    },
1542
                    reader: {
1543
                        type: 'json',
1544
                        root: 'data'
1545
                    }
1546
                }
1547
            })
1548
        });
1549
        me.callParent(arguments);
1550
    }
1551
});
1552
Ext.define('Ext.ux.MinovaLookupGrid1', {
1553
    extend: 'Ext.form.field.Trigger',
1554
    alias: 'widget.minovalookupgrid1',
1555
    tableName: undefined,
1556
    param: undefined,
1557
    formtarget_: this.formtarget,
1558
    anchor: '50%',
1559
    pagesize: undefined,
1560
    initComponent: function () {
1561
        var target = this.formtarget;
1562
        this.callParent();
1563
    },
1564
    onTriggerClick: function () {
1565
        var count_lookup = Ext.ComponentQuery.query('[name=mainLookup]').length;
1566
        if (count_lookup == 1) {
1567
            Ext.ComponentQuery.query('[name=mainLookup]')[0].show();
1568
        } else {
1569
            var target_ = this.formtarget;
1570
            var fieldtarget = this.name;
1571
            var pagesize_ = this.pagesize;
1572
            if (pagesize_ == undefined) {
1573
                pagesize_ = 25;
1574
            }
1575
            var mainLookup = Ext.create('Ext.window.Window', {
1576
                name: 'mainLookup',
1577
                width: 500,
1578
                heigth: 300,
1579
                maxHeigth: 300,
1580
                minWidth: 400,
1581
                scroll: true,
1582
                modal: true,
1583
                title: 'Lookup - ' + this.fieldLabel,
1584
                items: [{
1585
                    xtype: 'form',
1586
                    collapsible: false,
1587
                    items: [{
1588
                        xtype: 'form',
1589
                        //width: '90%',
1590
                        name: 'formFilter',
1591
                        layout: 'column',
1592
                        dockedItems: [{
1593
                            xtype: 'toolbar',
1594
                            dock: 'bottom',
1595
                            items: [{
1596
                                xtype: 'tbfill'
1597
                            }, {
1598
                                text: 'Search',
1599
                                scope: this,
1600
                                handler: function () {
1601
                                    var store = Ext.data.StoreManager.lookup('lookupStore');
1602
                                    var form = Ext.ComponentQuery.query('[name=formFilter]')[0].getForm();
1603
                                    var values_ = form.getValues();
1604
                                    var fields_ = form.getFields().items;
1605
                                    var param_ = '';
1606
                                    for (var i = 0; i < fields_.length; i++) {
1607
                                        var val_ = form.getFields().items[i].getValue();
1608
                                        var xtype_ = form.getFields().items[i].xtype;
1609
                                        var oprator_ = '[like]';
1610
                                        if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
1611
                                            oprator_ = '[Equal]';
1612
                                        }
1613
                                        if (xtype_ == 'datefield') {
1614
                                            if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
1615
                                                oprator_ = '[LessThanEqual]';
1616
                                            } else {
1617
                                                oprator_ = '[GreaterThanEqual]';
1618
                                            }
1619
                                        }
1620
                                        if (val_ != 'undefined' && val_ != "") {
1621
                                            param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
1622
                                        }
1623
                                    }
1624
                                    store.proxy.extraParams = {
1625
                                        tableName: this.tableName,
1626
                                        param: param_
1627
                                    };
1628
                                    store.removeAll();
1629
                                    store.reload();
1630
                                    store.loadPage(1);
1631
                                }
1632
                            }, ]
1633
                        }
1634
                        ],
1635
                        defaults: {
1636
                            xtype: 'container',
1637
                            defaultType: 'textfield',
1638
                            style: 'width: 50%'
1639
                        },
1640
                        items: [{
1641
                            xtype: 'minovaform',
1642
                            bodyBorder: false,
1643
                            cls: 'borderLookup',
1644
                            border: false,
1645
                            MaxHeigth: '30',
1646
                            scroll: true,
1647
                            isLookup: 1,
1648
                            name: "formLookupFilter",
1649
                            tableName: this.tableName,
1650
                        }
1651
                        ],
1652
                    }
1653
                    ]
1654
                }, {
1655
                    xtype: 'form',
1656
                    name: 'formResult',
1657
                    title: 'Result',
1658
                    collapsible: true,
1659
                    items: [{
1660
                        xtype: "minovagrid",
1661
                        name: "lookupgrid",
1662
                        tableName: this.tableName,
1663
                        param: '',
1664
                        pagesize: pagesize_,
1665
                        storename: 'lookupStore',
1666
                        isLookup: 1,
1667
                        border: false,
1668
                        minHeight: 300,
1669
                        maxHeight: 500,
1670
                        height: 100,
1671
                        columnLines: true,
1672
                        scrollable: true,
1673
                        listeners: {
1674
                            itemdblclick: function (formtarget_) {
1675
                                var me = this;
1676
                                var selection = this.getView().getSelectionModel().getSelection()[0];
1677
                                if (target_ == null || target_ == undefined) {
1678
                                    var formtarget_ = '[name=' + fieldtarget + ']';
1679
                                    var form_ = Ext.ComponentQuery.query(formtarget_)[0];
1680
                                } else {
1681
                                    var formtarget_ = 'form[name=' + target_ + ']';
1682
                                    var form_ = Ext.ComponentQuery.query(formtarget_)[0].getForm();
1683
                                    form_.setValues(selection.data)
1684
                                }
1685
                                mainLookup.hide();
1686
                            },
1687
                            beforeedit: function (grid) {
1688
                                return false;
1689
                            }
1690
                        },
1691
                        dockedItems: [{
1692
                            xtype: 'pagingtoolbar',
1693
                            store: 'lookupStore',
1694
                            dock: 'bottom',
1695
                            pageSize: pagesize_,
1696
                            displayInfo: true
1697
                        }
1698
                        ],
1699
                    }
1700
                    ]
1701
                }
1702
                ]
1703
            }).show();
1704
        }
1705
    },
1706
});
1707
Ext.define('Ext.ux.MinovaLookupTree', {
1708
    extend: 'Ext.form.field.Trigger',
1709
    alias: 'widget.minovalookuptree',
1710
    tableName: undefined,
1711
    param: undefined,
1712
    onTriggerClick: function () {}
1713

    
1714
});
1715
Ext.define('Ext.ux.MinovaLookupFile', {
1716
    extend: 'Ext.form.field.Trigger',
1717
    alias: 'widget.minovalookupfile',
1718
    tableName: undefined,
1719
    param: undefined,
1720
    onTriggerClick: function () {}
1721

    
1722
});
1723

    
1724
Ext.define('MinovaUtil.MinovaES.MinovaGrid1', {
1725
    extend: 'Ext.grid.Panel',
1726
    requires: ['Ext.grid.RowNumberer'],
1727
    alias: 'widget.minovagrid1',
1728
    //alias: ['widget.minovagrid1', 'widget.minovagrid'],
1729
    //alias: ['widget.minovagrid1', 'widget.minovagrid'],
1730
    alternateClassName: 'Ext.grid.MinovaGrid',
1731
    //controller:'orm-manage2-controller',
1732
    tableName: undefined,
1733
    isLookup: undefined,
1734
    param: undefined,
1735
    pagesize: undefined,
1736
    storename: undefined,
1737
    layoutType: undefined,
1738
    enableLocking: true,
1739
    autoLoad: undefined,
1740
    multiSelect: undefined,
1741
    getTableName: function () {
1742
        return this.tableName;
1743
    },
1744

    
1745
    initComponent: function () {
1746
        var me = this;
1747
        var cols_ = [];
1748
        var fieldeditor = {};
1749
        var hasil = null;
1750
        var autoLoad = true;
1751
        var LangID = localStorage.LangId;
1752
        var fielGrid = 'rec.GridView == 1';
1753
        var locking = true;
1754
        var checkSelection = '';
1755
        var widthLock = 250;
1756
        if (me.multiSelect) {
1757
            locking = false;
1758
            checkSelection = 'checkboxmodel';
1759
            widthLock = 40;
1760
        }
1761
        //var _url = 'GetAllField';
1762
        if (me.autoLoad == false) {
1763
            autoLoad = false;
1764
        }
1765
        parameter = null;
1766
        if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
1767
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'";
1768
            fielGrid = 'rec.LookupGrid == 1';
1769
            locking = false;
1770

    
1771
        } else {
1772
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
1773
            //autoLoad = false;
1774
            //_url = 'GetAllFieldGridLookUp';
1775
        };
1776

    
1777
        //Ext.Ajax.request({
1778
        //	async : false,
1779
        //	method : 'POST',
1780
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
1781
        //	success : function (response) {
1782
        //		var results = Ext.decode(response.responseText);
1783
        //		hasil = results.data;
1784
        //	}
1785
        //});
1786
        //hamid03102016
1787

    
1788
        Ext.Ajax.request({
1789
            async: false,
1790
            method: 'POST',
1791
            url: '/UserControl/GetStore',
1792
            params: {
1793
                tableName: 'PDSBS0007',
1794
                param: parameter
1795
            },
1796
            success: function (response) {
1797
                var results = Ext.decode(response.responseText);
1798
                hasil = results.data;
1799
            }
1800
        });
1801
        //end
1802

    
1803
        if (hasil.length > 0) {
1804

    
1805
            Ext.each(hasil, function (rec) {
1806
                var null_ = null;
1807
                if (rec.IsPrimaryKey == true) {
1808
                    null_ = false;
1809
                }
1810
                if (rec.IsRequired == true) {
1811
                    null_ = false;
1812
                } else {
1813
                    null_ = true;
1814
                }
1815
				var ReadOnly_ = false;
1816
				if (rec.ReadOnly == '1') {
1817
					ReadOnly_ = true;
1818
				}
1819
                if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
1820
                    if (rec.LookupGrid == 1) {
1821
                        switch (rec.FormatRef) {
1822
                            case "file":
1823
                                cols_.push({
1824
                                    xtype: 'minovapicturecolumn',
1825
                                    text: rec.HeaderTitle,
1826
                                    dataIndex: rec.FieldName,
1827
                                    width: 100,
1828
                                    //filter: {
1829
                                    //    type: 'image',
1830
                                    //    itemDefaults: {
1831
                                    //        emptyText: 'Search for...'
1832
                                    //    }
1833
                                    //}
1834
                                });
1835
                                break
1836
                            case "date":
1837
                                cols_.push({
1838
                                    xtype: 'minovadatecolumn',
1839
                                    text: rec.HeaderTitle,
1840
                                    dataIndex: rec.FieldName,
1841
                                    width: 100,
1842
                                    filter: {
1843
                                        type: 'date',
1844
                                        itemDefaults: {
1845
                                            emptyText: 'Search for...'
1846
                                        }
1847
                                    }
1848
                                });
1849
                                break
1850
                            case "amount":
1851
                                cols_.push({
1852
                                    xtype: 'minovacurrancycolumn',
1853
                                    text: rec.HeaderTitle,
1854
                                    dataIndex: rec.FieldName,
1855
                                    align: 'right',
1856
                                    width: 300,
1857
                                    filter: {
1858
                                        type: 'number',
1859
                                        itemDefaults: {
1860
                                            emptyText: 'Search for...'
1861
                                        }
1862
                                    }
1863
                                });
1864
                                break
1865
                            case "amountencrypt":
1866
                                cols_.push({
1867
                                    xtype: 'minovaamountcolumn',
1868
                                    text: rec.HeaderTitle,
1869
                                    dataIndex: rec.FieldName,
1870
                                    align: 'right',
1871
                                    width: 300,
1872
                                    filter: {
1873
                                        type: 'string',
1874
                                        itemDefaults: {
1875
                                            emptyText: 'Search for...'
1876
                                        }
1877
                                    }
1878
                                });
1879
                                break
1880
                            case "datetime":
1881
                                cols_.push({
1882
                                    xtype: 'minovadatetimecolumn',
1883
                                    text: rec.HeaderTitle,
1884
                                    dataIndex: rec.FieldName,
1885
                                    width: 140,
1886
                                    filter: {
1887
                                        type: 'string',
1888
                                        itemDefaults: {
1889
                                            emptyText: 'Search for...'
1890
                                        }
1891
                                    }
1892
                                });
1893
                                break
1894
                            default:
1895
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
1896
                                    cols_.push({
1897
                                        text: rec.HeaderTitle,
1898
                                        dataIndex: rec.FieldName,
1899
                                        width: 100,
1900
                                        filter: {
1901
                                            type: 'string',
1902
                                            itemDefaults: {
1903
                                                emptyText: 'Search for...'
1904
                                            }
1905
                                        }
1906
                                    });
1907
                                } else if (rec.SearchType == '2') {
1908
                                    cols_.push({
1909
                                        xtype: 'minovalookupcolumn',
1910
                                        text: rec.HeaderTitle,
1911
                                        tableName: rec.TableRef,
1912
                                        dataIndex: rec.FieldName,
1913
                                        filter: {
1914
                                            itemDefaults: {
1915
                                                emptyText: 'Search for...'
1916
                                            }
1917
                                        }
1918
                                    });
1919
                                } else if (rec.TableRef != "" && rec.SearchType != '2') {
1920
                                    if (rec.TableRef != null) {
1921
                                        var valueField = null;
1922
                                        var displayValue = null;
1923
                                        Ext.Ajax.request({
1924
                                            async: false,
1925
                                            method: 'POST',
1926
                                            url: '/UserControl/GetStore',
1927
                                            params: {
1928
                                                tableName: 'SDATATABLEFIELD',
1929
                                                param: 'TableName[equal]' + rec.TableRef
1930
                                            },
1931
                                            success: function (response) {
1932
                                                var results = Ext.decode(response.responseText);
1933
                                                data_ = results.data;
1934
                                                if (data_ != undefined) {
1935
                                                    valueField_ = $.grep(data_, function (r) {
1936
                                                        return r.ValueField == '1'
1937
                                                    });
1938
                                                    valueField = valueField_[0].FieldName
1939
                                                    displayValue_ = $.grep(data_, function (r) {
1940
                                                        return r.DisplayValue == '1'
1941
                                                    });
1942
                                                    displayValue = displayValue_[0].FieldName
1943
                                                }
1944
                                            }
1945
                                        });
1946
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
1947
                                        var count_ = 0;
1948
                                        if (store_) {
1949
                                            count_ = store_.count();
1950
                                        }
1951
                                        if (count_ == 0) {
1952
                                            Ext.create('Ext.data.Store', {
1953
                                                storeId: 'store_' + rec.FieldName,
1954
                                                //autoLoad: true,
1955
                                                proxy: {
1956
                                                    method: 'POST',
1957
                                                    type: 'ajax',
1958
                                                    url: '/UserControl/GetStore',
1959
                                                    extraParams: {
1960
                                                        tableName: rec.TableRef,
1961
                                                        param: rec.ParamCombo
1962
                                                    },
1963
                                                    reader: {
1964
                                                        type: 'json',
1965
                                                        root: 'data',
1966
                                                        totalProperty: 'data[0].TotalCount'
1967
                                                    }
1968
                                                }
1969
                                            })
1970
                                        }
1971
                                        cols_.push({
1972
                                            xtype: 'minovacombocolumn',
1973
                                            text: rec.HeaderTitle,
1974
                                            dataIndex: rec.FieldName,
1975
                                            valueField: valueField,
1976
                                            displayField: displayValue,
1977
                                            store: 'store_' + rec.FieldName,
1978
                                            filter: {
1979
                                                type: 'list',
1980
                                                itemDefaults: {
1981
                                                    emptyText: 'Search for...'
1982
                                                }
1983
                                            }
1984
                                        });
1985
                                    }
1986

    
1987
                                } else {
1988
                                    cols_.push({
1989
                                        text: rec.HeaderTitle,
1990
                                        dataIndex: rec.FieldName,
1991
                                        filter: {
1992
                                            itemDefaults: {
1993
                                                emptyText: 'Search for...'
1994
                                            }
1995
                                        }
1996
                                    });
1997
                                }
1998
                                break
1999
                        }
2000
                    } else {
2001
                        cols_.push({
2002
                            text: rec.HeaderTitle,
2003
                            dataIndex: rec.FieldName,
2004
                            hidden: true,
2005
                            filter: {
2006
                                itemDefaults: {
2007
                                    emptyText: 'Search for...'
2008
                                }
2009
                            }
2010
                        });
2011
                    }
2012

    
2013
                } else {
2014
                    if (rec.GridView == 1) {
2015
                        switch (rec.FormatRef) {
2016
                            case "Chart":
2017
                                    cols_.push({
2018
										text: rec.HeaderTitle,
2019
										dataIndex: rec.FieldName,
2020
										renderer: function (value, metadata, record) {
2021
											var sumscore = Ext.StoreMgr.lookup(metadata.record.store.storeId).sum('Score');      
2022
											var tmpValue = parseInt(record.data.Score)/parseInt(sumscore);
2023
											var tmpText = record.data.Score;
2024
											var progressRenderer = (function (pValue, pText) {
2025
												var b = new Ext.ProgressBar(
2026
													{
2027
														width: sumscore,
2028
													});
2029
												return function(pValue, pText) {
2030
													b.updateProgress(pValue, pText, true);
2031
													return Ext.DomHelper.markup(b.getRenderTree());
2032
												};
2033
											})(tmpValue, tmpText);
2034
											return progressRenderer(tmpValue, tmpText);
2035
										}
2036
          
2037
											// var color='';
2038
											
2039
											// if(parseInt(record.data.Score) <=10){
2040
												// color ='#f50202';
2041
											// }
2042
											// if(parseInt(record.data.Score) >10 && parseInt(record.data.Score) <=20){
2043
												// color ='#d4b90d';
2044
											// }											
2045
											// if(parseInt(record.data.Score) >20 && parseInt(record.data.Score) <=30){
2046
												// color ='#85bf19';
2047
											// }
2048
											// if(parseInt(record.data.Score) >30 && parseInt(record.data.Score) <=40){
2049
												// color ='#1ba11b';
2050
											// }
2051
											// if(parseInt(record.data.Score) >40 && parseInt(record.data.Score) <=50){
2052
												// color ='#13d15f';
2053
											// }
2054
											// if(parseInt(record.data.Score) >50 && parseInt(record.data.Score) <=60){
2055
												// color ='#13ed96';
2056
											// }
2057
											// if(parseInt(record.data.Score) >60 && parseInt(record.data.Score) <=70){
2058
												// color ='#0e8fc2';
2059
											// }
2060
											// if(parseInt(record.data.Score) >70 && parseInt(record.data.Score) <=80){
2061
												// color ='#0e3ec2';
2062
											// }
2063
											// if(parseInt(record.data.Score) >80 && parseInt(record.data.Score) <=90){
2064
												// color ='#590ec2';
2065
											// }
2066
											// if(parseInt(record.data.Score) >90 && parseInt(record.data.Score) <=100){
2067
												// color ='#a10ec2';
2068
											// }											
2069
                                        // metadata.tdStyle = 'font-family: FontAwesome;background-color: '+color+';width:'+ record.data.Score +'px !important;'
2070
										// }
2071
                                    });
2072
                                break							
2073
                            case "action":
2074
                                cols_.push({
2075
                                    text: rec.HeaderTitle,
2076
                                    width: 100,
2077
                                    xtype: 'actioncolumn',
2078
                                    tooltip: 'View Data',
2079
                                    name: rec.FieldName,
2080
                                    itemId: me.tableName + rec.FieldName,
2081
                                    align: 'center',
2082
                                    iconCls: 'fa-edit',
2083
                                    renderer: function (value, metadata, record) {
2084
                                        metadata.tdStyle = 'font-family: FontAwesome'
2085
                                    },
2086
                                    handler: function (grid, rowIndex, colIndex, actionItem, event, record, row) {
2087

    
2088
                                        this.fireEvent(me.tableName + rec.FieldName + "onActionClick", record);
2089
                                    }
2090
                                });
2091
                                break
2092
                            case "file":
2093
                                cols_.push({
2094
                                    xtype: 'minovapicturecolumn',
2095
                                    text: rec.HeaderTitle,
2096
                                    dataIndex: rec.FieldName,
2097
                                    width: 100,
2098
                                    //filter: {
2099
                                    //    type: '',
2100
                                    //    itemDefaults: {
2101
                                    //        emptyText: 'Search for...'
2102
                                    //    }
2103
                                    //}
2104
                                });
2105
                                break
2106
                            case "date":
2107
                                cols_.push({
2108
                                    xtype: 'minovadatecolumn',
2109
                                    text: rec.HeaderTitle,
2110
                                    dataIndex: rec.FieldName,
2111
                                    width: 100,
2112
                                    filter: {
2113
                                        type: 'date',
2114
                                        itemDefaults: {
2115
                                            emptyText: 'Search for...'
2116
                                        }
2117
                                    }
2118
                                });
2119
                                break
2120
                            case "amountencrypt":
2121
                                cols_.push({
2122
                                    xtype: 'minovaamountcolumn',
2123
                                    text: rec.HeaderTitle,
2124
                                    dataIndex: rec.FieldName,
2125
                                    align: 'right',
2126
                                    width: 300,
2127
                                    filter: {
2128
                                        type: 'string',
2129
                                        itemDefaults: {
2130
                                            emptyText: 'Search for...'
2131
                                        }
2132
                                    }
2133
                                });
2134
                                break
2135
                            case "amount":
2136
                                cols_.push({
2137
                                    xtype: 'minovacurrancycolumn',
2138
                                    text: rec.HeaderTitle,
2139
                                    dataIndex: rec.FieldName,
2140
                                    align: 'right',
2141
                                    width: 300,
2142
                                    filter: {
2143
                                        type: 'number',
2144
                                        itemDefaults: {
2145
                                            emptyText: 'Search for...'
2146
                                        }
2147
                                    }
2148
                                });
2149
                                break
2150
                            case "datetime":
2151
                                cols_.push({
2152
                                    xtype: 'minovadatetimecolumn',
2153
                                    text: rec.HeaderTitle,
2154
                                    dataIndex: rec.FieldName,
2155
                                    width: 140,
2156
                                    filter: {
2157
                                        type: 'string',
2158
                                        itemDefaults: {
2159
                                            emptyText: 'Search for...'
2160
                                        }
2161
                                    }
2162
                                });
2163
                                break
2164
                            default:
2165
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
2166
                                    cols_.push({
2167
                                        text: rec.HeaderTitle,
2168
                                        dataIndex: rec.FieldName,
2169
                                        width: 100,
2170
                                        filter: {
2171
                                            type: 'string',
2172
                                            itemDefaults: {
2173
                                                emptyText: 'Search for...'
2174
                                            }
2175
                                        }
2176
                                    });
2177
                                } else if (rec.TableRef != "") {
2178
                                    if (rec.TableRef != null) {
2179
                                        var valueField = null;
2180
                                        var displayValue = null;
2181
                                        Ext.Ajax.request({
2182
                                            async: false,
2183
                                            method: 'POST',
2184
                                            url: '/UserControl/GetStore',
2185
                                            params: {
2186
                                                tableName: 'SDATATABLEFIELD',
2187
                                                param: 'TableName[equal]' + rec.TableRef
2188
                                            },
2189
                                            success: function (response) {
2190
                                                var results = Ext.decode(response.responseText);
2191
                                                data_ = results.data;
2192
                                                //if (data_ != undefined) {
2193
                                                if (data_.length > 0) {
2194
                                                    valueField_ = $.grep(data_, function (r) {
2195
                                                        return r.ValueField == '1'
2196
                                                    });
2197
                                                    valueField = valueField_[0].FieldName
2198
                                                    displayValue_ = $.grep(data_, function (r) {
2199
                                                        return r.DisplayValue == '1'
2200
                                                    });
2201
                                                    displayValue = displayValue_[0].FieldName
2202
                                                } else {
2203
                                                    MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
2204
                                                }
2205
                                            }
2206
                                        });
2207
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
2208
                                        var count_ = 0;
2209
                                        if (store_) {
2210
                                            count_ = store_.count();
2211
                                        }
2212
                                        if (count_ == 0) {
2213
                                            Ext.create('Ext.data.Store', {
2214
                                                storeId: 'store_' + rec.FieldName,
2215
                                                autoLoad: false,
2216
                                                proxy: {
2217
                                                    method: 'POST',
2218
                                                    type: 'ajax',
2219
                                                    url: '/UserControl/GetStore',
2220
                                                    extraParams: {
2221
                                                        tableName: rec.TableRef,
2222
                                                        param: rec.ParamCombo
2223
                                                    },
2224
                                                    reader: {
2225
                                                        type: 'json',
2226
                                                        root: 'data',
2227
                                                        totalProperty: 'data[0].TotalCount'
2228
                                                    }
2229
                                                }
2230
                                            })
2231
                                        }
2232
                                        cols_.push({
2233
                                            xtype: 'minovacombocolumn',
2234
                                            text: rec.HeaderTitle,
2235
                                            dataIndex: rec.FieldName,
2236
                                            valueField: valueField,
2237
                                            displayField: displayValue,
2238
                                            store: 'store_' + rec.FieldName,
2239
                                            filter: {
2240
                                                type: 'list',
2241
                                                itemDefaults: {
2242
                                                    emptyText: 'Search for...'
2243
                                                }
2244
                                            }
2245
                                        });
2246
                                    }
2247

    
2248
                                } else if (rec.FixedValue != "") {
2249
                                    cols_.push({
2250
                                        xtype: 'minovacombocolumnfixvalue',
2251
                                        text: rec.HeaderTitle,
2252
                                        dataIndex: rec.FieldName,
2253
                                        fixedValue: rec.FixedValue,
2254
                                        filter: {
2255
                                            type: 'list',
2256
                                            itemDefaults: {
2257
                                                emptyText: 'Search for...'
2258
                                            }
2259
                                        }
2260
                                    });
2261
                                } else {
2262
                                    cols_.push({
2263
                                        text: rec.HeaderTitle,
2264
										readOnly: ReadOnly_,
2265
                                        dataIndex: rec.FieldName,
2266
                                        filter: {
2267
                                            itemDefaults: {
2268
                                                emptyText: 'Search for...'
2269
                                            }
2270
                                        }
2271
                                    });
2272
                                }
2273
                                break
2274
                        }
2275
                    } else {
2276
                        cols_.push({
2277
                            text: rec.HeaderTitle,
2278
                            dataIndex: rec.FieldName,
2279
                            hidden: true,
2280
                            filter: {
2281
                                itemDefaults: {
2282
                                    emptyText: 'Search for...'
2283
                                }
2284
                            }
2285
                        });
2286
                    }
2287

    
2288
                }
2289
            });
2290
        };
2291
        var param_ = me.param;
2292
        if (param_ == undefined) {
2293
            param_ = ''
2294
        }
2295
        var jsStoreGrid = new Ext.data.Store({
2296
            storeId: me.storename,
2297
            autoLoad: autoLoad,
2298
            pageSize: me.pagesize,
2299
            proxy: {
2300
                method: 'POST',
2301
                type: 'ajax',
2302
                url: '/UserControl/GetStorePagingAuth',
2303
                extraParams: {
2304
                    tableName: me.tableName,
2305
                    param: param_,
2306
                    menuId: MinovaUtil.GetMenuID()
2307
                },
2308
                reader: {
2309
                    type: 'json',
2310
                    root: 'data',
2311
                    totalProperty: 'totalRecords'
2312
                }
2313
            },
2314
        });
2315
        Ext.applyIf(me, {
2316
            autoScroll: true,
2317
            enableLocking: locking,
2318
            lockedGridConfig: {
2319
                header: false,
2320
                collapsible: true,
2321
                width: widthLock,
2322
                forceFit: locking,
2323
                listeners: {
2324
                    render: function (grid) {
2325
                        var pagingToolbar = grid.child('pagingtoolbar');
2326
                        if (pagingToolbar) {
2327
                            grid.remove(pagingToolbar, true);
2328
                        }
2329
                    }
2330
                }
2331
            },
2332
            listeners: {
2333
                viewready: function () {
2334
                    if (autoLoad == true) {
2335
                        this.getStore().loadPage(1);
2336
                    }
2337
                },
2338
                beforeedit: function () {
2339
                    return false;
2340
                },
2341
            },
2342
            lockedViewConfig: {
2343
                scroll: 'horizontal'
2344
            },
2345
            viewConfig: {
2346
                emptyText: 'No Data Display',
2347
                deferEmptyText: false,
2348
                //Add Nana For Autosize Column Mode
2349
                listeners: {
2350
                    refresh: function (dataview) {
2351
                        Ext.each(dataview.panel.columns, function (column) {
2352
                            //if (column.autoSizeColumn == false)
2353
                            //	column.autoSizeColumn = true;
2354
                            column.autoSize();
2355
                            //dataview.store.reload();
2356
                        })
2357
                    },
2358
                    afterrender: function (dataview) {
2359
                        Ext.defer(function () {
2360
                            dataview.store.reload();
2361
                        }, 2000, this);
2362
                        //dataview.store.reload();
2363
                    }
2364
                },
2365
                render: function (comp) {
2366
                    comp.getStore().reload();					
2367
                }
2368
            },
2369
            //for chekbox
2370
            selModel: {
2371
                //type: 'cellmodel'
2372
            },
2373
            selType: checkSelection,
2374
            columns: cols_,
2375

    
2376
            store: jsStoreGrid,
2377

    
2378
            plugins: [{
2379
                ptype: 'gridfilters'
2380
            }
2381
            ],
2382

    
2383
        });
2384
        me.callParent(arguments);
2385
    }
2386

    
2387
});
2388

    
2389
Ext.define('MinovaUtil.MinovaES.MinovaGrid2', {
2390
    extend: 'Ext.grid.Panel',
2391
    requires: ['Ext.grid.RowNumberer'],
2392
    alias: 'widget.minovagrid2',
2393
    //alias: ['widget.minovagrid2', 'widget.minovagrid'],
2394
    //alias: ['widget.minovagrid2', 'widget.minovagrid'],
2395
    alternateClassName: 'Ext.grid.MinovaGrid',
2396
    //controller:'orm-manage2-controller',
2397
    tableName: undefined,
2398
    isLookup: undefined,
2399
    param: undefined,
2400
    pagesize: undefined,
2401
    storename: undefined,
2402
    layoutType: undefined,
2403
    enableLocking: true,
2404
    autoLoad: undefined,
2405
    multiSelect: undefined,
2406
    getTableName: function () {
2407
        return this.tableName;
2408
    },
2409

    
2410
    initComponent: function () {
2411
        var me = this;
2412
        var cols_ = [];
2413
        var fieldeditor = {};
2414
        var hasil = null;
2415
        var autoLoad = true;
2416
        var LangID = localStorage.LangId;
2417
        var fielGrid = 'rec.GridView == 1';
2418
        var locking = true;
2419
        var checkSelection = '';
2420
        var widthLock = 250;
2421
        if (me.multiSelect) {
2422
            locking = false;
2423
            checkSelection = 'checkboxmodel';
2424
            widthLock = 40;
2425
        }
2426
        //var _url = 'GetAllField';
2427
        if (me.autoLoad == false) {
2428
            autoLoad = false;
2429
        }
2430
        parameter = null;
2431
        if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
2432
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'";
2433
            fielGrid = 'rec.LookupGrid == 1';
2434
            locking = false;
2435

    
2436
        } else {
2437
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
2438
            //autoLoad = false;
2439
            //_url = 'GetAllFieldGridLookUp';
2440
        };
2441

    
2442
        //Ext.Ajax.request({
2443
        //	async : false,
2444
        //	method : 'POST',
2445
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
2446
        //	success : function (response) {
2447
        //		var results = Ext.decode(response.responseText);
2448
        //		hasil = results.data;
2449
        //	}
2450
        //});
2451
        //hamid03102016
2452

    
2453
        Ext.Ajax.request({
2454
            async: false,
2455
            method: 'POST',
2456
            url: '/UserControl/GetStore',
2457
            params: {
2458
                tableName: 'PDSBS0007',
2459
                param: parameter
2460
            },
2461
            success: function (response) {
2462
                var results = Ext.decode(response.responseText);
2463
                hasil = results.data;
2464
            }
2465
        });
2466
        //end
2467

    
2468
        if (hasil.length > 0) {
2469

    
2470
            Ext.each(hasil, function (rec) {
2471
                var null_ = null;
2472
                if (rec.IsPrimaryKey == true) {
2473
                    null_ = false;
2474
                }
2475
                if (rec.IsRequired == true) {
2476
                    null_ = false;
2477
                } else {
2478
                    null_ = true;
2479
                }
2480

    
2481
                if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
2482
                    if (rec.LookupGrid == 1) {
2483
                        switch (rec.FormatRef) {
2484
                            case "file":
2485
                                cols_.push({
2486
                                    xtype: 'minovapicturecolumn',
2487
                                    text: rec.HeaderTitle,
2488
                                    dataIndex: rec.FieldName,
2489
                                    width: 100,
2490
                                    //filter: {
2491
                                    //    type: 'image',
2492
                                    //    itemDefaults: {
2493
                                    //        emptyText: 'Search for...'
2494
                                    //    }
2495
                                    //}
2496
                                });
2497
                                break
2498
                            case "date":
2499
                                cols_.push({
2500
                                    xtype: 'minovadatecolumn',
2501
                                    text: rec.HeaderTitle,
2502
                                    dataIndex: rec.FieldName,
2503
                                    width: 100,
2504
                                    filter: {
2505
                                        type: 'date',
2506
                                        itemDefaults: {
2507
                                            emptyText: 'Search for...'
2508
                                        }
2509
                                    }
2510
                                });
2511
                                break
2512
                            case "amount":
2513
                                cols_.push({
2514
                                    xtype: 'minovacurrancycolumn',
2515
                                    text: rec.HeaderTitle,
2516
                                    dataIndex: rec.FieldName,
2517
                                    align: 'right',
2518
                                    width: 300,
2519
                                    filter: {
2520
                                        type: 'number',
2521
                                        itemDefaults: {
2522
                                            emptyText: 'Search for...'
2523
                                        }
2524
                                    }
2525
                                });
2526
                                break
2527
                            case "amountencrypt":
2528
                                cols_.push({
2529
                                    xtype: 'minovaamountcolumn',
2530
                                    text: rec.HeaderTitle,
2531
                                    dataIndex: rec.FieldName,
2532
                                    align: 'right',
2533
                                    width: 300,
2534
                                    filter: {
2535
                                        type: 'string',
2536
                                        itemDefaults: {
2537
                                            emptyText: 'Search for...'
2538
                                        }
2539
                                    }
2540
                                });
2541
                                break
2542
                            case "datetime":
2543
                                cols_.push({
2544
                                    xtype: 'minovadatetimecolumn',
2545
                                    text: rec.HeaderTitle,
2546
                                    dataIndex: rec.FieldName,
2547
                                    width: 140,
2548
                                    filter: {
2549
                                        type: 'string',
2550
                                        itemDefaults: {
2551
                                            emptyText: 'Search for...'
2552
                                        }
2553
                                    }
2554
                                });
2555
                                break
2556
                            default:
2557
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
2558
                                    cols_.push({
2559
                                        text: rec.HeaderTitle,
2560
                                        dataIndex: rec.FieldName,
2561
                                        width: 100,
2562
                                        filter: {
2563
                                            type: 'string',
2564
                                            itemDefaults: {
2565
                                                emptyText: 'Search for...'
2566
                                            }
2567
                                        }
2568
                                    });
2569
                                } else if (rec.SearchType == '2') {
2570
                                    cols_.push({
2571
                                        xtype: 'minovalookupcolumn',
2572
                                        text: rec.HeaderTitle,
2573
                                        tableName: rec.TableRef,
2574
                                        dataIndex: rec.FieldName,
2575
                                        filter: {
2576
                                            itemDefaults: {
2577
                                                emptyText: 'Search for...'
2578
                                            }
2579
                                        }
2580
                                    });
2581
                                } else if (rec.TableRef != "" && rec.SearchType != '2') {
2582
                                    if (rec.TableRef != null) {
2583
                                        var valueField = null;
2584
                                        var displayValue = null;
2585
                                        Ext.Ajax.request({
2586
                                            async: false,
2587
                                            method: 'POST',
2588
                                            url: '/UserControl/GetStore',
2589
                                            params: {
2590
                                                tableName: 'SDATATABLEFIELD',
2591
                                                param: 'TableName[equal]' + rec.TableRef
2592
                                            },
2593
                                            success: function (response) {
2594
                                                var results = Ext.decode(response.responseText);
2595
                                                data_ = results.data;
2596
                                                if (data_ != undefined) {
2597
                                                    valueField_ = $.grep(data_, function (r) {
2598
                                                        return r.ValueField == '1'
2599
                                                    });
2600
                                                    valueField = valueField_[0].FieldName
2601
                                                    displayValue_ = $.grep(data_, function (r) {
2602
                                                        return r.DisplayValue == '1'
2603
                                                    });
2604
                                                    displayValue = displayValue_[0].FieldName
2605
                                                }
2606
                                            }
2607
                                        });
2608
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
2609
                                        var count_ = 0;
2610
                                        if (store_) {
2611
                                            count_ = store_.count();
2612
                                        }
2613
                                        if (count_ == 0) {
2614
                                            Ext.create('Ext.data.Store', {
2615
                                                storeId: 'store_' + rec.FieldName,
2616
                                                //autoLoad: true,
2617
                                                proxy: {
2618
                                                    method: 'POST',
2619
                                                    type: 'ajax',
2620
                                                    url: '/UserControl/GetStore',
2621
                                                    extraParams: {
2622
                                                        tableName: rec.TableRef,
2623
                                                        param: rec.ParamCombo
2624
                                                    },
2625
                                                    reader: {
2626
                                                        type: 'json',
2627
                                                        root: 'data',
2628
                                                        totalProperty: 'data[0].TotalCount'
2629
                                                    }
2630
                                                }
2631
                                            })
2632
                                        }
2633
                                        cols_.push({
2634
                                            xtype: 'minovacombocolumn',
2635
                                            text: rec.HeaderTitle,
2636
                                            dataIndex: rec.FieldName,
2637
                                            valueField: valueField,
2638
                                            displayField: displayValue,
2639
                                            store: 'store_' + rec.FieldName,
2640
                                            filter: {
2641
                                                type: 'list',
2642
                                                itemDefaults: {
2643
                                                    emptyText: 'Search for...'
2644
                                                }
2645
                                            }
2646
                                        });
2647
                                    }
2648

    
2649
                                } else {
2650
                                    cols_.push({
2651
                                        text: rec.HeaderTitle,
2652
                                        dataIndex: rec.FieldName,
2653
                                        filter: {
2654
                                            itemDefaults: {
2655
                                                emptyText: 'Search for...'
2656
                                            }
2657
                                        }
2658
                                    });
2659
                                }
2660
                                break
2661
                        }
2662
                    } else {
2663
                        cols_.push({
2664
                            text: rec.HeaderTitle,
2665
                            dataIndex: rec.FieldName,
2666
                            hidden: true,
2667
                            filter: {
2668
                                itemDefaults: {
2669
                                    emptyText: 'Search for...'
2670
                                }
2671
                            }
2672
                        });
2673
                    }
2674

    
2675
                } else {
2676
                    if (rec.GridView == 1) {
2677
                        switch (rec.FormatRef) {
2678
                            case "action":
2679
                                cols_.push({
2680
                                    text: rec.HeaderTitle,
2681
                                    width: 100,
2682
                                    xtype: 'actioncolumn',
2683
                                    tooltip: 'View Data',
2684
                                    name: rec.FieldName,
2685
                                    itemId: me.tableName + rec.FieldName,
2686
                                    align: 'center',
2687
                                    iconCls: 'fa-edit',
2688
                                    renderer: function (value, metadata, record) {
2689
                                        metadata.tdStyle = 'font-family: FontAwesome'
2690
                                    },
2691
                                    handler: function (grid, rowIndex, colIndex, actionItem, event, record, row) {
2692

    
2693
                                        this.fireEvent(me.tableName + rec.FieldName + "onActionClick", record);
2694
                                    }
2695
                                });
2696
                                break
2697
                            case "file":
2698
                                cols_.push({
2699
                                    xtype: 'minovapicturecolumn',
2700
                                    text: rec.HeaderTitle,
2701
                                    dataIndex: rec.FieldName,
2702
                                    width: 100,
2703
                                    //filter: {
2704
                                    //    type: '',
2705
                                    //    itemDefaults: {
2706
                                    //        emptyText: 'Search for...'
2707
                                    //    }
2708
                                    //}
2709
                                });
2710
                                break
2711
                            case "date":
2712
                                cols_.push({
2713
                                    xtype: 'minovadatecolumn',
2714
                                    text: rec.HeaderTitle,
2715
                                    dataIndex: rec.FieldName,
2716
                                    width: 100,
2717
                                    filter: {
2718
                                        type: 'date',
2719
                                        itemDefaults: {
2720
                                            emptyText: 'Search for...'
2721
                                        }
2722
                                    }
2723
                                });
2724
                                break
2725
                            case "amountencrypt":
2726
                                cols_.push({
2727
                                    xtype: 'minovaamountcolumn',
2728
                                    text: rec.HeaderTitle,
2729
                                    dataIndex: rec.FieldName,
2730
                                    align: 'right',
2731
                                    width: 300,
2732
                                    filter: {
2733
                                        type: 'string',
2734
                                        itemDefaults: {
2735
                                            emptyText: 'Search for...'
2736
                                        }
2737
                                    }
2738
                                });
2739
                                break
2740
                            case "amount":
2741
                                cols_.push({
2742
                                    xtype: 'minovacurrancycolumn',
2743
                                    text: rec.HeaderTitle,
2744
                                    dataIndex: rec.FieldName,
2745
                                    align: 'right',
2746
                                    width: 300,
2747
                                    filter: {
2748
                                        type: 'number',
2749
                                        itemDefaults: {
2750
                                            emptyText: 'Search for...'
2751
                                        }
2752
                                    }
2753
                                });
2754
                                break
2755
                            case "datetime":
2756
                                cols_.push({
2757
                                    xtype: 'minovadatetimecolumn',
2758
                                    text: rec.HeaderTitle,
2759
                                    dataIndex: rec.FieldName,
2760
                                    width: 140,
2761
                                    filter: {
2762
                                        type: 'string',
2763
                                        itemDefaults: {
2764
                                            emptyText: 'Search for...'
2765
                                        }
2766
                                    }
2767
                                });
2768
                                break
2769
                            default:
2770
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
2771
                                    cols_.push({
2772
                                        text: rec.HeaderTitle,
2773
                                        dataIndex: rec.FieldName,
2774
                                        width: 100,
2775
                                        filter: {
2776
                                            type: 'string',
2777
                                            itemDefaults: {
2778
                                                emptyText: 'Search for...'
2779
                                            }
2780
                                        }
2781
                                    });
2782
                                } else if (rec.TableRef != "") {
2783
                                    if (rec.TableRef != null) {
2784
                                        var valueField = null;
2785
                                        var displayValue = null;
2786
                                        Ext.Ajax.request({
2787
                                            async: false,
2788
                                            method: 'POST',
2789
                                            url: '/UserControl/GetStore',
2790
                                            params: {
2791
                                                tableName: 'SDATATABLEFIELD',
2792
                                                param: 'TableName[equal]' + rec.TableRef
2793
                                            },
2794
                                            success: function (response) {
2795
                                                var results = Ext.decode(response.responseText);
2796
                                                data_ = results.data;
2797
                                                //if (data_ != undefined) {
2798
                                                if (data_.length > 0) {
2799
                                                    valueField_ = $.grep(data_, function (r) {
2800
                                                        return r.ValueField == '1'
2801
                                                    });
2802
                                                    valueField = valueField_[0].FieldName
2803
                                                    displayValue_ = $.grep(data_, function (r) {
2804
                                                        return r.DisplayValue == '1'
2805
                                                    });
2806
                                                    displayValue = displayValue_[0].FieldName
2807
                                                } else {
2808
                                                    MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
2809
                                                }
2810
                                            }
2811
                                        });
2812
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
2813
                                        var count_ = 0;
2814
                                        if (store_) {
2815
                                            count_ = store_.count();
2816
                                        }
2817
                                        if (count_ == 0) {
2818
                                            Ext.create('Ext.data.Store', {
2819
                                                storeId: 'store_' + rec.FieldName,
2820
                                                autoLoad: false,
2821
                                                proxy: {
2822
                                                    method: 'POST',
2823
                                                    type: 'ajax',
2824
                                                    url: '/UserControl/GetStore',
2825
                                                    extraParams: {
2826
                                                        tableName: rec.TableRef,
2827
                                                        param: rec.ParamCombo
2828
                                                    },
2829
                                                    reader: {
2830
                                                        type: 'json',
2831
                                                        root: 'data',
2832
                                                        totalProperty: 'data[0].TotalCount'
2833
                                                    }
2834
                                                }
2835
                                            })
2836
                                        }
2837
                                        cols_.push({
2838
                                            xtype: 'minovacombocolumn',
2839
                                            text: rec.HeaderTitle,
2840
                                            dataIndex: rec.FieldName,
2841
                                            valueField: valueField,
2842
                                            displayField: displayValue,
2843
                                            store: 'store_' + rec.FieldName,
2844
                                            filter: {
2845
                                                type: 'list',
2846
                                                itemDefaults: {
2847
                                                    emptyText: 'Search for...'
2848
                                                }
2849
                                            }
2850
                                        });
2851
                                    }
2852

    
2853
                                } else if (rec.FixedValue != "") {
2854
                                    cols_.push({
2855
                                        xtype: 'minovacombocolumnfixvalue',
2856
                                        text: rec.HeaderTitle,
2857
                                        dataIndex: rec.FieldName,
2858
                                        fixedValue: rec.FixedValue,
2859
                                        filter: {
2860
                                            type: 'list',
2861
                                            itemDefaults: {
2862
                                                emptyText: 'Search for...'
2863
                                            }
2864
                                        }
2865
                                    });
2866
                                } else {
2867
                                    cols_.push({
2868
                                        text: rec.HeaderTitle,
2869
                                        dataIndex: rec.FieldName,
2870
                                        filter: {
2871
                                            itemDefaults: {
2872
                                                emptyText: 'Search for...'
2873
                                            }
2874
                                        }
2875
                                    });
2876
                                }
2877
                                break
2878
                        }
2879
                    } else {
2880
                        cols_.push({
2881
                            text: rec.HeaderTitle,
2882
                            dataIndex: rec.FieldName,
2883
                            hidden: true,
2884
                            filter: {
2885
                                itemDefaults: {
2886
                                    emptyText: 'Search for...'
2887
                                }
2888
                            }
2889
                        });
2890
                    }
2891

    
2892
                }
2893
            });
2894
        };
2895
        var param_ = me.param;
2896
        if (param_ == undefined) {
2897
            param_ = ''
2898
        }
2899
        var jsStoreGrid = new Ext.data.Store({
2900
            storeId: me.storename,
2901
            autoLoad: autoLoad,
2902
            pageSize: me.pagesize,
2903
            proxy: {
2904
                method: 'POST',
2905
                type: 'ajax',
2906
                url: '/UserControl/GetStorePagingAuth',
2907
                extraParams: {
2908
                    tableName: me.tableName,
2909
                    param: param_,
2910
                    menuId: MinovaUtil.GetMenuID()
2911
                },
2912
                reader: {
2913
                    type: 'json',
2914
                    root: 'data',
2915
                    totalProperty: 'totalRecords'
2916
                }
2917
            },
2918
        });
2919
        Ext.applyIf(me, {
2920
            autoScroll: true,
2921
            enableLocking: locking,
2922
            lockedGridConfig: {
2923
                header: false,
2924
                collapsible: true,
2925
                width: widthLock,
2926
                forceFit: locking,
2927
                listeners: {
2928
                    render: function (grid) {
2929
                        var pagingToolbar = grid.child('pagingtoolbar');
2930
                        if (pagingToolbar) {
2931
                            grid.remove(pagingToolbar, true);
2932
                        }
2933
                    }
2934
                }
2935
            },
2936
            listeners: {
2937
                viewready: function () {
2938
                    if (autoLoad == true) {
2939
                        this.getStore().loadPage(1);
2940
                    }
2941
                },
2942
                beforeedit: function () {
2943
                    return false;
2944
                },
2945
            },
2946
            lockedViewConfig: {
2947
                scroll: 'horizontal'
2948
            },
2949
            viewConfig: {
2950
                emptyText: 'No Data Display',
2951
                deferEmptyText: false,
2952
                //Add Nana For Autosize Column Mode
2953
                listeners: {
2954
                    refresh: function (dataview) {
2955
                        Ext.each(dataview.panel.columns, function (column) {
2956
                            //if (column.autoSizeColumn == false)
2957
                            //	column.autoSizeColumn = true;
2958
                            column.autoSize();
2959
                            //dataview.store.reload();
2960
                        })
2961
                    }
2962
                },
2963
                render: function (comp) {
2964
                    comp.getStore().reload();					
2965
                }
2966
            },
2967
            //for chekbox
2968
            selModel: {
2969
                //type: 'cellmodel'
2970
            },
2971
            selType: checkSelection,
2972
            columns: cols_,
2973

    
2974
            store: jsStoreGrid,
2975

    
2976
            plugins: [{
2977
                ptype: 'gridfilters'
2978
            }
2979
            ],
2980

    
2981
        });
2982
        me.callParent(arguments);
2983
    }
2984

    
2985
});
2986
Ext.define('MinovaUtil.MinovaES.MinovaGrid', {
2987
    extend: 'Ext.grid.Panel',
2988
    requires: ['Ext.grid.RowNumberer'],
2989
    alias: 'widget.minovagrid',
2990
    //alternateClassName : 'Ext.grid.MinovaGrid',
2991
    tableName: undefined,
2992
    isLookup: undefined,
2993
    param: undefined,
2994
    pagesize: undefined,
2995
    storename: undefined,
2996
    layoutType: undefined,
2997
    enableLocking: true,
2998

    
2999
    tbar: [{
3000
        xtype: 'button',
3001
        text: 'Action',
3002
        name: 'actionBtn',
3003
        //scale: 'medium',
3004
        menu: [{
3005
            text: 'Add',
3006
            name: 'Add_',
3007
            action: 'CRUDaddNewRecord',
3008
            style: 'font-family: FontAwesome',
3009
            iconCls: 'fa-plus-circle',
3010
            handler: function () {
3011
                var layout = null;
3012
                var tolbar = this.up();
3013
                var name = '';
3014
                var tableName = tolbar.up().up().up().tableName;
3015
                var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0];
3016
                var titleMain = mpnl.getTitle();
3017
                var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
3018
                if (pnl) {
3019
                    layout = pnl.getLayoutType();
3020
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
3021
                    pnl.setLastTitle(titleMain);
3022
                    mpnl.setTitle('Add ' + titleMain);
3023
                } else {
3024
                    pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
3025
                    layout = pnl.getLayoutType();
3026
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
3027
                    pnl.setLastTitle(titleMain);
3028
                    mpnl.setTitle('Add ' + titleMain);
3029
                }
3030
                if (layout == 'L003') {
3031
                    var _grid = "MinovaGridFormGrid" + tableName;
3032
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
3033
                    var _formEdit = "MinovaGridFormEdit" + tableName;
3034
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
3035
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
3036
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
3037
                    g.setHidden(true);
3038
                    formDisplay.setHidden(true);
3039
                    formEdit.reset();
3040
                    formEdit.setActionSubmit(0)
3041
                    formEdit.setSubmitProc(true)
3042
                    formEdit.setHidden(false);
3043
                    var heigh = pnl.getLastheightform();
3044
                    var pDetail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
3045
                    if (pDetail) {
3046
                        // pDetail.setHeight(heigh + 100);
3047
                    } else {
3048
                        pDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
3049
                        var mainPnl_ = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
3050
                        var mainPnl = mainPnl_.getHeight();
3051
                        //pDetail.setHeight(mainPnl + 100);
3052

    
3053
                    }
3054

    
3055
                    var emp = formEdit.getForm().findField("EmployeeID");
3056
                    if (emp) {
3057
                        emp.setValue(getParam("EmployeeID"))
3058
                        emp.setHidden(true);
3059
                    }
3060

    
3061
                } else {
3062
                    var _grid = "MinovaGridFormGrid" + tableName;
3063
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
3064
                    var _formEdit = "MinovaGridFormEdit" + tableName;
3065
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
3066
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
3067
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
3068
                    formEdit.setActionSubmit(0)
3069
                    formDisplay.setHidden(true);
3070
                    formDisplay.setTitle("Add");
3071

    
3072
                    formEdit.setTitle("Add - " + titleMain);
3073
                    formEdit.reset();
3074
                    formEdit.setSubmitProc(true)
3075
                    formEdit.setHidden(false);
3076
                    var emp = formEdit.getForm().findField("EmployeeID");
3077
                    if (emp) {
3078
                        emp.setValue(Ext.ComponentQuery.query('[name=EmployeeID]')[0].getValue())
3079
                        emp.setHidden(true);
3080
                    }
3081

    
3082
                }
3083
            }
3084
        }, {
3085
            text: 'Copy',
3086
            name: 'Copy_',
3087
            iconCls: 'fa-copy',
3088
            style: 'font-family: FontAwesome',
3089
            handler: function () {
3090
                var layout = null;
3091
                var tolbar = this.up();
3092
                var name = '';
3093
                var tableName = tolbar.up().up().up().tableName;
3094
                var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0];
3095
                var titleMain = mpnl.getTitle();
3096
                var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
3097

    
3098
                if (pnl) {
3099
                    layout = pnl.getLayoutType();
3100
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
3101
                    pnl.setLastTitle(titleMain);
3102
                    mpnl.setTitle('Copy ' + titleMain);
3103
                } else {
3104
                    pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
3105
                    layout = pnl.getLayoutType();
3106
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
3107
                    pnl.setLastTitle(titleMain);
3108
                    mpnl.setTitle('Copy ' + titleMain);
3109
                }
3110
                if (layout == 'L003') {
3111
                    var _grid = "MinovaGridFormGrid" + tableName;
3112
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
3113
                    var _formEdit = "MinovaGridFormEdit" + tableName;
3114
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
3115
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
3116
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
3117
                    g.setHidden(true);
3118
                    formDisplay.setHidden(true);
3119
                    formEdit.reset();
3120
                    formEdit.setActionSubmit(0)
3121
                    formEdit.setSubmitProc(true)
3122
                    formEdit.setHidden(false);
3123
                    var heigh = pnl.getLastheightform();
3124
                    var pDetail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
3125
                    if (pDetail) {
3126
                        //pDetail.setHeight(heigh + 100);
3127
                    } else {
3128
                        pDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
3129
                        var mainPnl_ = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
3130
                        var mainPnl = mainPnl_.getHeight();
3131
                        //pDetail.setHeight(mainPnl + 100);
3132

    
3133
                    }
3134
                    Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
3135

    
3136
                    var emp = formEdit.getForm().findField("EmployeeID");
3137
                    if (emp) {
3138
                        emp.setValue(getParam("EmployeeID"))
3139
                        emp.setHidden(true);
3140
                    }
3141
                    var selection = tolbar.up().up().up().getView().getSelectionModel().getSelection()[0];
3142
                    if (selection) {
3143
                        formDisplay.getForm().setValues(selection.data);
3144
                        formEdit.getForm().setValues(selection.data);
3145
                    }
3146

    
3147
                } else {
3148
                    var _grid = "MinovaGridFormGrid" + tableName;
3149
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
3150
                    var _formEdit = "MinovaGridFormEdit" + tableName;
3151
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
3152
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
3153
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
3154
                    formEdit.setActionSubmit(0)
3155
                    formDisplay.setHidden(true);
3156
                    formDisplay.setTitle("Add");
3157

    
3158
                    formEdit.setTitle("Copy - " + titleMain);
3159
                    formEdit.reset();
3160
                    formEdit.setSubmitProc(true)
3161
                    formEdit.setHidden(false);
3162
                    var emp = formEdit.getForm().findField("EmployeeID");
3163
                    if (emp) {
3164
                        emp.setValue(Ext.ComponentQuery.query('[name=EmployeeID]')[0].getValue())
3165
                        emp.setHidden(true);
3166
                    }
3167
                    var selection = tolbar.up().up().up().getView().getSelectionModel().getSelection()[0];
3168
                    if (selection) {
3169
                        formDisplay.getForm().setValues(selection.data);
3170
                        formEdit.getForm().setValues(selection.data);
3171
                        formEdit.setSubmitProc(true);
3172
                        formEdit.setActionSubmit(0);
3173
                    }
3174

    
3175
                }
3176
            }
3177
        }, {
3178
            text: 'Edit',
3179
            name: 'Edit_',
3180
            iconCls: 'fa-edit',
3181
            style: 'font-family: FontAwesome',
3182
            handler: function () {
3183
                var layout = null;
3184
                var tolbar = this.up();
3185
                var name = '';
3186
                var tableName = tolbar.up().up().up().tableName;
3187

    
3188
                var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
3189
                if (pnl) {
3190
                    layout = pnl.getLayoutType();
3191
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
3192

    
3193
                } else {
3194
                    pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
3195
                    layout = pnl.getLayoutType();
3196
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
3197
                }
3198

    
3199
                if (layout == 'L003') {
3200
                    var _grid = "MinovaGridFormGrid" + tableName;
3201
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
3202
                    var _formEdit = "MinovaGridFormEdit" + tableName;
3203
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
3204
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
3205
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
3206

    
3207
                    var selection = tolbar.up().up().up().getView().getSelectionModel().getSelection()[0];
3208
                    if (selection) {
3209
                        formDisplay.getForm().setValues(selection.data);
3210
                        formEdit.getForm().setValues(selection.data);
3211
                        formDisplay.setHidden(true);
3212
                        formEdit.setSubmitProc(true);
3213
                        formEdit.setActionSubmit(1);
3214
                        formEdit.setHidden(false);
3215
                        formEdit.setHidden(false);
3216
                        g.setHidden(true);
3217
                        var heigh = pnl.getLastheightform();
3218
                        var pDetail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
3219
                        if (pDetail) {
3220
                            pDetail.setHeight(heigh + 100);
3221
                        } else {
3222
                            pDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
3223
                            var mainPnl_ = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
3224
                            var mainPnl = mainPnl_.getHeight();
3225
                            //pDetail.setHeight(mainPnl + 100);
3226

    
3227
                        }
3228

    
3229
                        var p = Ext.ComponentQuery.query('[name=DetailMD]')[0];
3230
                        if (p) {
3231
                            var lastTitile = p.getTitle();
3232
                            pnl.setLastTitle(lastTitile);
3233
                            p.setTitle('Edit - ' + lastTitile)
3234

    
3235
                        }
3236
                    }
3237
                } else {
3238
                    var _grid = "MinovaGridFormGrid" + tableName;
3239
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
3240
                    var _formEdit = "MinovaGridFormEdit" + tableName;
3241
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
3242
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
3243
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
3244

    
3245
                    var selection = tolbar.up().up().up().getView().getSelectionModel().getSelection()[0];
3246
                    if (selection) {
3247
                        formDisplay.getForm().setValues(selection.data);
3248
                        formEdit.getForm().setValues(selection.data);
3249
                        formDisplay.setTitle("Edit");
3250
                        formEdit.setTitle("Edit");
3251
                        if (layout == 'L003') {
3252
                            g.setHidden(true);
3253
                        }
3254

    
3255
                        formDisplay.setHidden(true);
3256
                        formEdit.setActionSubmit(1)
3257
                        formEdit.setSubmitProc(true)
3258
                        formEdit.setHidden(false);
3259

    
3260
                        var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0]
3261
                        var lastTitile = mpnl.getTitle();
3262
                        formEdit.setTitle('Edit - ' + lastTitile);
3263
                        //mpnl.setTitle('Edit ' + lastTitile);
3264
                    }
3265
                }
3266
            }
3267
        }, {
3268
            text: 'Delete',
3269
            name: 'Delete_',
3270
            iconCls: 'fa-trash-o',
3271
            style: 'font-family: FontAwesome',
3272
        }
3273
        ]
3274
    }, {
3275
        xtype: 'tbfill'
3276
    }, {
3277
        text: 'Clear Filters',
3278
        tooltip: 'Clear all filters',
3279
        name: 'clearbtn',
3280
        handler: function () {
3281
            var tolbar = this.up()
3282
            var grid_ = tolbar.up()
3283
            grid_.filters.clearFilters()
3284
        }
3285
    }, ],
3286

    
3287
    getTableName: function () {
3288
        return this.tableName;
3289
    },
3290

    
3291
    initComponent: function () {
3292
        var me = this;
3293
        var cols_ = [];
3294
        var fieldeditor = {};
3295
        var hasil = null;
3296
        var autoLoad = true;
3297
        var LangID = MinovaUtil.GetLangID();
3298
        //var _url = 'GetAllField';
3299

    
3300
        //if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
3301
        //	autoLoad = false;
3302
        //    _url = 'GetAllFieldGridLookUp';
3303

    
3304
        //};
3305
        //Ext.Ajax.request({
3306
        //	async : false,
3307
        //	method : 'POST',
3308
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
3309
        //	success : function (response) {
3310
        //		var results = Ext.decode(response.responseText);
3311
        //		hasil = results.data;
3312
        //	}
3313
        //});
3314
        //hamid03102016
3315
        //if (me.isLookup == 1 || isLookup == true || isLookup == 'Y') {
3316
        parameter = null;
3317
        if (me.isLookup == true || isLookup == 1 || isLookup == 'Y') {
3318
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'"
3319
        } else {
3320
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
3321
        }
3322
        Ext.Ajax.request({
3323
            async: false,
3324
            method: 'POST',
3325
            url: '/UserControl/GetStore',
3326
            params: {
3327
                tableName: 'PDSBS0007',
3328
                param: parameter
3329
            },
3330
            success: function (response) {
3331
                var results = Ext.decode(response.responseText);
3332
                hasil = results.data;
3333
            }
3334
        });
3335
        //end
3336
        if (hasil.length > 0) {
3337
            Ext.each(hasil, function (rec) {
3338
                var null_ = null;
3339
                if (rec.IsPrimaryKey == true) {
3340
                    null_ = false;
3341
                }
3342
                if (rec.IsRequired == true) {
3343
                    null_ = false;
3344
                } else {
3345
                    null_ = true;
3346
                }
3347
                if (rec.GridView == 1) {
3348
                    switch (rec.FormatRef) {
3349
                        case "date":
3350
                            cols_.push({
3351
                                xtype: 'minovadatecolumn',
3352
                                text: rec.HeaderTitle,
3353
                                dataIndex: rec.FieldName,
3354
                                width: 100,
3355
                                filter: {
3356
                                    type: 'date',
3357
                                    itemDefaults: {
3358
                                        emptyText: 'Search for...'
3359
                                    }
3360
                                }
3361
                            });
3362
                            break
3363
                        case "amountencrypt":
3364
                            cols_.push({
3365
                                xtype: 'minovaamountcolumn',
3366
                                text: rec.HeaderTitle,
3367
                                dataIndex: rec.FieldName,
3368
                                align: 'right',
3369
                                width: 100,
3370
                                filter: {
3371
                                    type: 'string',
3372
                                    itemDefaults: {
3373
                                        emptyText: 'Search for...'
3374
                                    }
3375
                                }
3376
                            });
3377
                            break
3378
                        case "amount":
3379
                            cols_.push({
3380
                                xtype: 'minovacurrancycolumn',
3381
                                text: rec.HeaderTitle,
3382
                                dataIndex: rec.FieldName,
3383
                                align: 'right',
3384
                                width: 100,
3385
                                filter: {
3386
                                    type: 'number',
3387
                                    itemDefaults: {
3388
                                        emptyText: 'Search for...'
3389
                                    }
3390
                                }
3391
                            });
3392
                            break
3393
                        case "datetime":
3394
                            cols_.push({
3395
                                xtype: 'minovadatetimecolumn',
3396
                                text: rec.HeaderTitle,
3397
                                dataIndex: rec.FieldName,
3398
                                width: 140,
3399
                                filter: {
3400
                                    type: 'string',
3401
                                    itemDefaults: {
3402
                                        emptyText: 'Search for...'
3403
                                    }
3404
                                }
3405
                            });
3406
                            break
3407
                        default:
3408
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
3409
                                cols_.push({
3410
                                    text: rec.HeaderTitle,
3411
                                    dataIndex: rec.FieldName,
3412
                                    width: 100,
3413
                                    filter: {
3414
                                        type: 'string',
3415
                                        itemDefaults: {
3416
                                            emptyText: 'Search for...'
3417
                                        }
3418
                                    }
3419
                                });
3420
                            } else if (rec.SearchType == '2') {
3421
                                cols_.push({
3422
                                    xtype: 'minovalookupcolumn',
3423
                                    text: rec.HeaderTitle,
3424
                                    tableName: rec.TableRef,
3425
                                    dataIndex: rec.FieldName,
3426
                                    filter: {
3427
                                        itemDefaults: {
3428
                                            emptyText: 'Search for...'
3429
                                        }
3430
                                    }
3431
                                });
3432
                            } else if (rec.TableRef != "") {
3433
                                if (rec.TableRef != null) {
3434
                                    var valueField = null;
3435
                                    Ext.Ajax.request({
3436
                                        async: false,
3437
                                        method: 'POST',
3438
                                        url: '/UserControl/GetStore',
3439
                                        params: {
3440
                                            tableName: 'SDATATABLEFIELD',
3441
                                            param: 'ValueField[equal]1,TableName[equal]' + rec.TableRef
3442
                                        },
3443
                                        success: function (response) {
3444
                                            var results = Ext.decode(response.responseText);
3445
                                            data_ = results.data[0];
3446
                                            if (data_ != undefined) {
3447
                                                valueField = data_.FieldName;
3448
                                            }
3449
                                        }
3450
                                    });
3451

    
3452
                                    displayValue = null;
3453
                                    Ext.Ajax.request({
3454
                                        async: false,
3455
                                        method: 'POST',
3456
                                        url: '/UserControl/GetStore',
3457
                                        params: {
3458
                                            tableName: 'SDATATABLEFIELD',
3459
                                            param: 'DisplayValue[equal]1,TableName[equal]' + rec.TableRef
3460
                                        },
3461
                                        success: function (response) {
3462
                                            var results = Ext.decode(response.responseText);
3463
                                            data_ = results.data[0];
3464
                                            if (data_ != undefined) {
3465
                                                displayValue = data_.FieldName;
3466
                                                //console.log(data_)
3467
                                            }
3468
                                        }
3469
                                    });
3470
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
3471
                                    var count_ = 0;
3472
                                    if (store_) {
3473
                                        count_ = store_.count();
3474
                                    }
3475
                                    if (count_ == 0) {
3476
                                        Ext.create('Ext.data.Store', {
3477
                                            storeId: 'store_' + rec.FieldName,
3478
                                            autoLoad: true,
3479
                                            proxy: {
3480
                                                method: 'POST',
3481
                                                type: 'ajax',
3482
                                                url: '/UserControl/GetStore',
3483
                                                extraParams: {
3484
                                                    tableName: rec.TableRef,
3485
                                                    param: rec.ParamCombo
3486
                                                },
3487
                                                reader: {
3488
                                                    type: 'json',
3489
                                                    root: 'data',
3490
                                                    totalProperty: 'data[0].TotalCount'
3491
                                                }
3492
                                            }
3493
                                        })
3494
                                    }
3495
                                    cols_.push({
3496
                                        xtype: 'minovacombocolumn',
3497
                                        text: rec.HeaderTitle,
3498
                                        dataIndex: rec.FieldName,
3499
                                        valueField: valueField,
3500
                                        displayField: displayValue,
3501
                                        store: 'store_' + rec.FieldName,
3502
                                        filter: {
3503
                                            type: 'list',
3504
                                            itemDefaults: {
3505
                                                emptyText: 'Search for...'
3506
                                            }
3507
                                        }
3508
                                    });
3509
                                }
3510

    
3511
                            } else {
3512
                                cols_.push({
3513
                                    text: rec.HeaderTitle,
3514
                                    dataIndex: rec.FieldName,
3515
                                    filter: {
3516
                                        itemDefaults: {
3517
                                            emptyText: 'Search for...'
3518
                                        }
3519
                                    }
3520
                                });
3521
                            }
3522
                            break
3523
                    }
3524
                } else {
3525
                    cols_.push({
3526
                        text: rec.HeaderTitle,
3527
                        dataIndex: rec.FieldName,
3528
                        hidden: true,
3529
                        filter: {
3530
                            itemDefaults: {
3531
                                emptyText: 'Search for...'
3532
                            }
3533
                        }
3534
                    });
3535
                }
3536
            });
3537
        };
3538
        var param_ = me.param;
3539
        if (param_ == undefined) {
3540
            param_ = ''
3541
        }
3542
        var jsStoreGrid = new Ext.data.Store({
3543
            storeId: me.storename,
3544
            autoLoad: autoLoad,
3545
            pageSize: me.pagesize,
3546
            proxy: {
3547
                method: 'POST',
3548
                type: 'ajax',
3549
                url: '/UserControl/GetStorePaging',
3550
                extraParams: {
3551
                    tableName: me.tableName,
3552
                    param: param_
3553
                },
3554
                reader: {
3555
                    type: 'json',
3556
                    root: 'data',
3557
                    totalProperty: 'totalRecords'
3558
                }
3559
            }
3560
        });
3561
        Ext.applyIf(me, {
3562
            autoScroll: true,
3563
            enableLocking: true,
3564
            lockedGridConfig: {
3565
                header: false,
3566
                collapsible: true,
3567
                width: 250,
3568
                forceFit: true,
3569
                listeners: {
3570
                    render: function (grid) {
3571
                        var pagingToolbar = grid.child('pagingtoolbar');
3572
                        if (pagingToolbar) {
3573
                            grid.remove(pagingToolbar, true);
3574
                        }
3575
                    }
3576
                }
3577
            },
3578
            listeners: {
3579
                viewready: function () {
3580
                    if (autoLoad == true) {
3581
                        this.getStore().loadPage(1);
3582
                    }
3583

    
3584
                },
3585
                beforeedit: function () {
3586
                    return false;
3587
                }
3588
            },
3589
            lockedViewConfig: {
3590
                scroll: 'horizontal'
3591
            },
3592
            viewConfig: {
3593
                emptyText: 'No Data Display',
3594
                deferEmptyText: false,
3595
                //add Nana for Autosize Column Mode
3596
                listeners: {
3597
                    refresh: function (dataview) {
3598
                        Ext.each(dataview.panel.columns, function (column) {
3599
                            if (column.autoSizeColumn == false)
3600
                                column.autoSizeColumn = true;
3601
                            column.autoSize();
3602
                        })
3603
                    }
3604
                }
3605
            },
3606
            columns: cols_,
3607

    
3608
            store: jsStoreGrid,
3609

    
3610
            plugins: [{
3611
                ptype: 'gridfilters'
3612
            }, {
3613
                ptype: 'rowediting',
3614
                clicksToEdit: 2,
3615
                listeners: {
3616
                    edit: function (editor, context, eOpts) {}
3617
                }
3618
            }, ]
3619
        });
3620
        me.callParent(arguments);
3621
    }
3622

    
3623
});
3624
/*MinovaGrid Report Generator*/
3625
Ext.define('MinovaUtil.MinovaES.MinovaRptGeneratorGrid', {
3626
    extend: 'Ext.grid.Panel',
3627
    requires: ['Ext.grid.RowNumberer', 'Ext.grid.feature.Grouping'],
3628
    alias: 'widget.minovareportgeneratorgrid',
3629
    storeOutput: undefined,
3630
    storeName: undefined,
3631
    filter: undefined,
3632
    tableName: undefined,
3633
    pagesize: undefined,
3634
    autoLoad: undefined,
3635
    initComponent: function () {
3636
        var me = this;
3637
        var store = me.storeOutput;
3638
        var cols = [];
3639
        var groupField = '';
3640
        var autoLoad = true;
3641
        if (me.autoLoad == false) {
3642
            autoLoad = false;
3643
        }
3644
        if (store.length > 0) {
3645
            Ext.each(store, function (rec) {
3646
                var isHide = false;
3647
                if (rec.IsGrouping == "YES") {
3648
                    groupField = rec.FieldName;
3649
                    isHide = true;
3650
                }
3651
                var format = rec.FormatRef;
3652
                if (format != null && format != undefined)
3653
                    format = format.toLowerCase();
3654
                switch (format) {
3655
                    case "file":
3656
                        cols.push({
3657
                            xtype: 'minovapicturecolumn',
3658
                            text: rec.HeaderTitle,
3659
                            dataIndex: rec.FieldName,
3660
                            hidden: isHide,
3661
                            width: 100
3662
                        });
3663
                        break
3664
                    case "date":
3665
                        cols.push({
3666
                            xtype: 'minovadatecolumn',
3667
                            text: rec.HeaderTitle,
3668
                            dataIndex: rec.FieldName,
3669
                            hidden: isHide,
3670
                            width: 100
3671
                        });
3672
                        break
3673
                    case "amount":
3674
                        cols.push({
3675
                            xtype: 'minovacurrancycolumn',
3676
                            text: rec.HeaderTitle,
3677
                            align: 'right',
3678
                            dataIndex: rec.FieldName,
3679
                            width: 150,
3680
                            hidden: isHide,
3681
                            summaryType: rec.Aggregator,
3682
                            summaryRenderer: function (value) {
3683
                                return Ext.util.Format.number(value, '0,000.00');
3684
                            }
3685
                        });
3686
                        break
3687
                    case "amountencrypt":
3688
                        cols.push({
3689
                            xtype: 'minovaamountcolumn',
3690
                            align: 'right',
3691
                            text: rec.HeaderTitle,
3692
                            dataIndex: rec.FieldName,
3693
                            width: 150,
3694
                            hidden: isHide,
3695
                            summaryType: rec.Aggregator,
3696
                            summaryRenderer: function (value) {
3697
                                if (rec.Aggregator == "sum") {
3698
                                    var str = Ext.StoreManager.lookup("store" + me.tableName);
3699
                                    var records = str.data.items;
3700
                                    var total = 0,
3701
                                    len = records.length;
3702
                                    if (len > 0) {
3703
                                        for (var i = 0; i < len; ++i) {
3704
                                            var nilai = records[i].get(rec.FieldName);
3705
                                            Ext.Ajax.request({
3706
                                                async: false,
3707
                                                method: 'POST',
3708
                                                url: '/Devt/DecryptData',
3709
                                                params: {
3710
                                                    dt: nilai
3711
                                                },
3712
                                                success: function (response) {
3713
                                                    var results = Ext.decode(response.responseText);
3714
                                                    nilai = results.data;
3715
                                                    total += parseFloat(nilai);
3716
                                                }
3717
                                            });
3718
                                        }
3719
                                        Ext.util.Format.thousandSeparator = ".";
3720
                                        return Ext.util.Format.number(total, '0,000');
3721
                                    }
3722
                                    return 0;
3723
                                } else if (rec.Aggregator == "average") {
3724
                                    var str = Ext.StoreManager.lookup("store" + me.tableName);
3725
                                    var records = str.data.items;
3726
                                    var len = records.length,
3727
                                    sum = 0;
3728
                                    if (len > 0) {
3729
                                        for (var i = 0; i < len; ++i) {
3730
                                            var nilai = records[i].get(rec.FieldName);
3731
                                            Ext.Ajax.request({
3732
                                                async: false,
3733
                                                method: 'POST',
3734
                                                url: '/Devt/DecryptData',
3735
                                                params: {
3736
                                                    dt: nilai
3737
                                                },
3738
                                                success: function (response) {
3739
                                                    var results = Ext.decode(response.responseText);
3740
                                                    nilai = results.data;
3741
                                                    sum += parseFloat(nilai);
3742
                                                }
3743
                                            });
3744
                                        }
3745
                                        var rs = sum / len;
3746
                                        Ext.util.Format.thousandSeparator = ".";
3747
                                        return Ext.util.Format.number(rs, '0,000');
3748
                                    }
3749
                                    return 0;
3750
                                } else {
3751
                                    return value;
3752
                                }
3753
                            }
3754
                        });
3755
                        break
3756
                    case "datetime":
3757
                        cols.push({
3758
                            xtype: 'minovadatetimecolumn',
3759
                            text: rec.HeaderTitle,
3760
                            dataIndex: rec.FieldName,
3761
                            width: 150,
3762
                            hidden: isHide
3763
                        });
3764
                        break
3765
                    default:
3766
                        if (rec.TableRef != "" && rec.TableRef != null) {
3767
                            var valueField = null;
3768
                            var displayValue = null;
3769
                            Ext.Ajax.request({
3770
                                async: false,
3771
                                method: 'POST',
3772
                                url: '/UserControl/GetStore',
3773
                                params: {
3774
                                    tableName: 'SDATATABLEFIELD',
3775
                                    param: 'TableName[equal]' + rec.TableRef
3776
                                },
3777
                                success: function (response) {
3778
                                    var results = Ext.decode(response.responseText);
3779
                                    data_ = results.data;
3780
                                    if (data_.length > 0) {
3781
                                        valueField_ = $.grep(data_, function (r) {
3782
                                            return r.ValueField == '1'
3783
                                        });
3784
                                        valueField = valueField_[0].FieldName
3785
                                        displayValue_ = $.grep(data_, function (r) {
3786
                                            return r.DisplayValue == '1'
3787
                                        });
3788
                                        displayValue = displayValue_[0].FieldName
3789
                                    } else {
3790
                                        MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
3791
                                    }
3792
                                }
3793
                            });
3794
                            var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
3795
                            var count_ = 0;
3796
                            if (store_) {
3797
                                count_ = store_.count();
3798
                            }
3799
                            if (count_ == 0) {
3800
                                Ext.create('Ext.data.Store', {
3801
                                    storeId: 'store_' + rec.FieldName,
3802
                                    autoLoad: false,
3803
                                    proxy: {
3804
                                        method: 'POST',
3805
                                        type: 'ajax',
3806
                                        url: '/UserControl/GetStore',
3807
                                        extraParams: {
3808
                                            tableName: rec.TableRef,
3809
                                            param: ""
3810
                                        },
3811
                                        reader: {
3812
                                            type: 'json',
3813
                                            root: 'data',
3814
                                            totalProperty: 'data[0].TotalCount'
3815
                                        }
3816
                                    }
3817
                                })
3818
                            }
3819
                            Ext.StoreMgr.lookup('store_' + rec.FieldName).load();
3820
                            var stror = Ext.StoreMgr.lookup('store_' + rec.FieldName);
3821
                            cols.push({
3822
                                xtype: 'minovacombocolumn',
3823
                                text: rec.HeaderTitle,
3824
                                dataIndex: rec.FieldName,
3825
                                valueField: valueField,
3826
                                displayField: displayValue,
3827
                                store: 'store_' + rec.FieldName,
3828
                                width: 200,
3829
                                hidden: isHide,
3830
                                renderer: function (val) {
3831
                                    var stor = stror;
3832
                                    if (stor.getCount() === 0) {}
3833
                                    var index = stor.find(valueField, val);
3834
                                    if (index != -1) {
3835
                                        var rec = stor.getAt(index);
3836
                                        return val + ' - ' + rec.get(displayValue);
3837
                                    } else {
3838
                                        return val;
3839
                                    }
3840
                                }
3841
                            });
3842
                        } else if (rec.FixedValue != "" && rec.FixedValue != null) {
3843
                            cols.push({
3844
                                xtype: 'minovacombocolumnfixvalue',
3845
                                text: rec.HeaderTitle,
3846
                                dataIndex: rec.FieldName,
3847
                                fixedValue: rec.FixedValue,
3848
                                width: 100,
3849
                                hidden: isHide
3850
                            });
3851
                        } else {
3852
                            if (rec.DataType == "0") {
3853
                                cols.push({
3854
                                    text: rec.HeaderTitle,
3855
                                    dataIndex: rec.FieldName,
3856
                                    width: 150,
3857
                                    hidden: isHide
3858
                                });
3859
                            } else {
3860
                                cols.push({
3861
                                    text: rec.HeaderTitle,
3862
                                    dataIndex: rec.FieldName,
3863
                                    width: 150,
3864
                                    hidden: isHide,
3865
                                    summaryType: rec.Aggregator,
3866
                                });
3867
                            }
3868
                        }
3869
                        break
3870
                }
3871
            });
3872
            var featuretype = "summary";
3873
            if (groupField != "") {
3874
                featuretype = "groupingsummary";
3875
            }
3876
            var param = me.filter;
3877
            if (param == undefined) {
3878
                param = ''
3879
            }
3880
            var jsStoreGrid = new Ext.data.Store({
3881
                storeId: me.storeName,
3882
                autoLoad: autoLoad,
3883
                pageSize: me.pagesize,
3884
                proxy: {
3885
                    method: 'POST',
3886
                    type: 'ajax',
3887
                    url: '/UserControl/GetStorePagingAuth',
3888
                    extraParams: {
3889
                        tableName: me.tableName,
3890
                        param: param,
3891
                        menuId: MinovaUtil.GetMenuID()
3892
                    },
3893
                    reader: {
3894
                        type: 'json',
3895
                        root: 'data',
3896
                        totalProperty: 'totalRecords'
3897
                    }
3898
                },
3899
                groupField: groupField
3900
            });
3901
            Ext.applyIf(me, {
3902
                autoScroll: true,
3903
                enableLocking: false,
3904
                lockedGridConfig: {
3905
                    header: false,
3906
                    collapsible: true,
3907
                    width: 250,
3908
                    forceFit: false,
3909
                    listeners: {
3910
                        render: function (grid) {
3911
                            var pagingToolbar = grid.child('pagingtoolbar');
3912
                            if (pagingToolbar) {
3913
                                grid.remove(pagingToolbar, true);
3914
                            }
3915
                        }
3916
                    }
3917
                },
3918
                listeners: {
3919
                    viewready: function () {
3920
                        if (autoLoad == true) {
3921
                            this.getStore().loadPage(1);
3922
                        }
3923
                    },
3924
                    beforeedit: function () {
3925
                        return false;
3926
                    }
3927
                },
3928
                lockedViewConfig: {
3929
                    scroll: 'horizontal'
3930
                },
3931
                viewConfig: {
3932
                    emptyText: 'No Data Display',
3933
                    deferEmptyText: false
3934
                },
3935
                selModel: {},
3936
                columns: cols,
3937
                store: jsStoreGrid,
3938
                features: [{
3939
                    ftype: 'groupingsummary'
3940
                }
3941
                ],
3942
                plugins: [{
3943
                    ptype: 'gridfilters'
3944
                }
3945
                ]
3946
            });
3947
        }
3948
        me.callParent(arguments);
3949
    }
3950
});
3951
/*MinovaGrouping Grid*/
3952
Ext.define('MinovaUtil.MinovaES.MinovaGroupingGrid', {
3953
    extend: 'Ext.grid.Panel',
3954
    requires: ['Ext.grid.RowNumberer', 'Ext.grid.feature.Grouping'],
3955
    alias: 'widget.minovagroupinggrid',
3956
    tableName: undefined,
3957
    isLookup: undefined,
3958
    param: undefined,
3959
    pagesize: undefined,
3960
    storeName: undefined,
3961
    layoutType: undefined,
3962
    enableLocking: true,
3963
    autoLoad: undefined,
3964
    multiSelect: undefined,
3965
    getTableName: function () {
3966
        return this.tableName;
3967
    },
3968
    initComponent: function () {
3969
        var me = this;
3970
        var cols_ = [];
3971
        var fieldeditor = {};
3972
        var hasil = null;
3973
        var autoLoad = true;
3974
        var LangID = localStorage.LangId;
3975
        var fielGrid = 'rec.GridView == 1';
3976
        var locking = true;
3977
        var checkSelection = '';
3978
        var widthLock = 250;
3979
        var GroupField = '';
3980
        if (me.multiSelect) {
3981
            locking = false;
3982
            checkSelection = 'checkboxmodel';
3983
            widthLock = 40;
3984
        }
3985
        if (me.autoLoad == false) {
3986
            autoLoad = false;
3987
        }
3988
        parameter = null;
3989
        if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
3990
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'";
3991
            fielGrid = 'rec.LookupGrid == 1';
3992
            locking = false;
3993
        } else {
3994
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
3995
        };
3996

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

    
4191
                } else {
4192
                    if (rec.GridView == 1) {
4193
                        switch (rec.FormatRef) {
4194
                            case "date":
4195
                                cols_.push({
4196
                                    xtype: 'minovadatecolumn',
4197
                                    text: rec.HeaderTitle,
4198
                                    dataIndex: rec.FieldName,
4199
                                    width: 100,
4200
                                    flex: 1,
4201
                                    filter: {
4202
                                        type: 'date',
4203
                                        itemDefaults: {
4204
                                            emptyText: 'Search for...'
4205
                                        }
4206
                                    }
4207
                                });
4208
                                break
4209
                            case "amountencrypt":
4210
                                cols_.push({
4211
                                    xtype: 'minovaamountcolumn',
4212
                                    align: 'right',
4213
                                    text: rec.HeaderTitle,
4214
                                    dataIndex: rec.FieldName,
4215
                                    width: 100,
4216
                                    flex: 1,
4217
                                    filter: {
4218
                                        type: 'string',
4219
                                        itemDefaults: {
4220
                                            emptyText: 'Search for...'
4221
                                        }
4222
                                    }
4223
                                });
4224
                                break
4225
                            case "amount":
4226
                                cols_.push({
4227
                                    xtype: 'minovacurrancycolumn',
4228
                                    text: rec.HeaderTitle,
4229
                                    align: 'right',
4230
                                    dataIndex: rec.FieldName,
4231
                                    width: 100,
4232
                                    flex: 1,
4233
                                    filter: {
4234
                                        type: 'number',
4235
                                        itemDefaults: {
4236
                                            emptyText: 'Search for...'
4237
                                        }
4238
                                    }
4239
                                });
4240
                                break
4241
                            case "datetime":
4242
                                cols_.push({
4243
                                    xtype: 'minovadatetimecolumn',
4244
                                    text: rec.HeaderTitle,
4245
                                    dataIndex: rec.FieldName,
4246
                                    width: 140,
4247
                                    flex: 1,
4248
                                    filter: {
4249
                                        type: 'string',
4250
                                        itemDefaults: {
4251
                                            emptyText: 'Search for...'
4252
                                        }
4253
                                    }
4254
                                });
4255
                                break
4256
                            default:
4257
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
4258
                                    cols_.push({
4259
                                        text: rec.HeaderTitle,
4260
                                        dataIndex: rec.FieldName,
4261
                                        width: 100,
4262
                                        flex: 1,
4263
                                        filter: {
4264
                                            type: 'string',
4265
                                            itemDefaults: {
4266
                                                emptyText: 'Search for...'
4267
                                            }
4268
                                        }
4269
                                    });
4270
                                } else if (rec.TableRef != "") {
4271
                                    if (rec.TableRef != null) {
4272
                                        var valueField = null;
4273
                                        var displayValue = null;
4274
                                        Ext.Ajax.request({
4275
                                            async: false,
4276
                                            method: 'POST',
4277
                                            url: '/UserControl/GetStore',
4278
                                            params: {
4279
                                                tableName: 'SDATATABLEFIELD',
4280
                                                param: 'TableName[equal]' + rec.TableRef
4281
                                            },
4282
                                            success: function (response) {
4283
                                                var results = Ext.decode(response.responseText);
4284
                                                data_ = results.data;
4285
                                                if (data_ != undefined) {
4286
                                                    valueField_ = $.grep(data_, function (r) {
4287
                                                        return r.ValueField == '1'
4288
                                                    });
4289
                                                    valueField = valueField_[0].FieldName
4290
                                                    displayValue_ = $.grep(data_, function (r) {
4291
                                                        return r.DisplayValue == '1'
4292
                                                    });
4293
                                                    displayValue = displayValue_[0].FieldName
4294
                                                }
4295
                                            }
4296
                                        });
4297
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
4298
                                        var count_ = 0;
4299
                                        if (store_) {
4300
                                            count_ = store_.count();
4301
                                        }
4302
                                        if (count_ == 0) {
4303
                                            Ext.create('Ext.data.Store', {
4304
                                                storeId: 'store_' + rec.FieldName,
4305
                                                autoLoad: false,
4306
                                                proxy: {
4307
                                                    method: 'POST',
4308
                                                    type: 'ajax',
4309
                                                    url: '/UserControl/GetStore',
4310
                                                    extraParams: {
4311
                                                        tableName: rec.TableRef,
4312
                                                        param: rec.ParamCombo
4313
                                                    },
4314
                                                    reader: {
4315
                                                        type: 'json',
4316
                                                        root: 'data',
4317
                                                        totalProperty: 'data[0].TotalCount'
4318
                                                    }
4319
                                                }
4320
                                            })
4321
                                        }
4322
                                        cols_.push({
4323
                                            xtype: 'minovacombocolumn',
4324
                                            text: rec.HeaderTitle,
4325
                                            dataIndex: rec.FieldName,
4326
                                            valueField: valueField,
4327
                                            displayField: displayValue,
4328
                                            store: 'store_' + rec.FieldName,
4329
                                            flex: 1,
4330
                                            filter: {
4331
                                                type: 'list',
4332
                                                itemDefaults: {
4333
                                                    emptyText: 'Search for...'
4334
                                                }
4335
                                            }
4336
                                        });
4337
                                    }
4338

    
4339
                                } else {
4340
                                    cols_.push({
4341
                                        text: rec.HeaderTitle,
4342
                                        dataIndex: rec.FieldName,
4343
                                        flex: 1,
4344
                                        filter: {
4345
                                            itemDefaults: {
4346
                                                emptyText: 'Search for...'
4347
                                            }
4348
                                        }
4349
                                    });
4350
                                }
4351
                                break
4352
                        }
4353
                    } else {
4354
                        cols_.push({
4355
                            text: rec.HeaderTitle,
4356
                            dataIndex: rec.FieldName,
4357
                            hidden: true,
4358
                            filter: {
4359
                                itemDefaults: {
4360
                                    emptyText: 'Search for...'
4361
                                }
4362
                            }
4363
                        });
4364
                    }
4365

    
4366
                }
4367
            });
4368
        }
4369
        var param_ = me.param;
4370
        if (param_ == undefined) {
4371
            param_ = ''
4372
        }
4373
        var jsStoreGrid = new Ext.data.Store({
4374
            storeId: me.storeName,
4375
            autoLoad: autoLoad,
4376
            pageSize: me.pagesize,
4377
            proxy: {
4378
                method: 'POST',
4379
                type: 'ajax',
4380
                url: '/UserControl/GetStorePagingAuth',
4381
                extraParams: {
4382
                    tableName: me.tableName,
4383
                    param: param_,
4384
                    menuId: MinovaUtil.GetMenuID()
4385
                },
4386
                reader: {
4387
                    type: 'json',
4388
                    root: 'data',
4389
                    totalProperty: 'totalRecords'
4390
                }
4391
            },
4392
            groupField: GroupField,
4393
            //sorters: ['tipe','cuisine','name'],
4394
        });
4395
        Ext.applyIf(me, {
4396
            autoScroll: true,
4397
            enableLocking: locking,
4398
            lockedGridConfig: {
4399
                header: false,
4400
                collapsible: true,
4401
                width: widthLock,
4402
                forceFit: locking,
4403
                listeners: {
4404
                    render: function (grid) {
4405
                        var pagingToolbar = grid.child('pagingtoolbar');
4406
                        if (pagingToolbar) {
4407
                            grid.remove(pagingToolbar, true);
4408
                        }
4409
                    }
4410
                }
4411
            },
4412
            listeners: {
4413
                viewready: function () {
4414
                    if (autoLoad == true) {
4415
                        this.getStore().loadPage(1);
4416
                    }
4417

    
4418
                },
4419
                beforeedit: function () {
4420
                    return false;
4421
                }
4422
            },
4423
            lockedViewConfig: {
4424
                scroll: 'horizontal'
4425
            },
4426
            viewConfig: {
4427
                emptyText: 'No Data Display',
4428
                deferEmptyText: false,
4429
                listeners: {
4430
                    refresh: function (dataview) {
4431
                        Ext.each(dataview.panel.columns, function (column) {
4432
                            if (column.autoSizeColumn == false)
4433
                                column.autoSizeColumn = true;
4434
                            column.autoSize();
4435
                        })
4436
                    }
4437
                }
4438
            },
4439
            selModel: {},
4440
            selType: checkSelection,
4441
            columns: cols_,
4442
            store: jsStoreGrid,
4443
            features: [{
4444
                ftype: 'grouping'
4445
            }
4446
            ],
4447
            plugins: [{
4448
                ptype: 'gridfilters'
4449
            }
4450
            ]
4451
        });
4452
        me.callParent(arguments);
4453
    }
4454
});
4455
/*Form ESS Generator*/
4456
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowForm', {
4457
    extend: 'Ext.form.Panel',
4458
    alias: ['widget.MinovaWorkflowForm', 'widget.minovaworkflowform', 'widget.workflowform'],
4459
    formname: this.name,
4460
    bizprocid: undefined,
4461
    taskid: undefined,
4462
    tableName: undefined,
4463
    titleform: undefined,
4464
    resizable: true,
4465
    border: false,
4466
    autoScroll: true,
4467
    minHeight: 20,
4468
    layout: 'column',
4469
    listeners: {
4470
        render: function () {
4471
            if (this.titleform != undefined) {
4472
                this.setTitle(this.titleform);
4473
            }
4474
        },
4475
    },
4476
    defaults: {
4477
        layout: 'form',
4478
        xtype: 'container',
4479
        defaultType: 'textfield',
4480
        style: 'width: 50%',
4481
    },
4482
    initComponent: function () {
4483
        var col1 = [];
4484
        var col2 = [];
4485
        var me = this;
4486
        var LangID = localStorage.LangId;
4487
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
4488
        var formname_ = me.name;
4489
        var nameTable_ = me.tableName;
4490
        Ext.Ajax.request({
4491
            async: false,
4492
            method: 'POST',
4493
            url: '/UserControl/GetStore',
4494
            params: {
4495
                tableName: 'PDSWFSTRUCTUREFIELD',
4496
                param: parameter
4497
            },
4498
            success: function (response) {
4499
                var results = Ext.decode(response.responseText);
4500
                hasil = results.data;
4501
            }
4502
        });
4503
        if (hasil.length > 0) {
4504
            Ext.each(hasil, function (rec) {
4505
                var formfield = undefined;
4506
                var readonly = false;
4507
                var ishidden = false;
4508
                var allowblank = true;
4509
                var startDt = null;
4510
                var endDt = null;
4511
                if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
4512
                    startDt = 'StartDate';
4513
                    endDt = 'EndDate';
4514
                }
4515
                if (rec.IsReadOnly == '1') {
4516
                    readonly = true;
4517
                }
4518
                if (rec.IsRequired == '1') {
4519
                    allowblank = false;
4520
                }
4521
                if (rec.IsVisible == '0') {
4522
                    ishidden = true;
4523
                }
4524
                if (rec.SearchType == "") //textfield
4525
                {
4526
                    switch (rec.FormatRef) {
4527
                        case "date":
4528
                            if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
4529
                                formfield = new Ext.form.DateField({
4530
                                    allowBlank: allowblank,
4531
                                    fieldLabel: rec.ScreenCaption,
4532
                                    readOnly: readonly,
4533
                                    msgTarget: 'side',
4534
                                    labelCls: 'label-minova',
4535
                                    labelWidth: 150,
4536
                                    hidden: ishidden,
4537
                                    name: rec.FieldName,
4538
                                    submitFormat: 'Ymd',
4539
                                    value: rec.DefaultValue,
4540
                                    anchor: '100%',
4541
                                    vtype: 'daterange',
4542
                                    start: startDt,
4543
                                    end: endDt,
4544
                                    formname: formname_,
4545
                                    nameTable: nameTable_,
4546
                                    hideMode: 'visibility',
4547
                                    listeners: {
4548
                                        change: function (val) {
4549
                                            var _label = val.name;
4550
                                            var _form = val.formname;
4551
                                            var _Value = val.getValue();
4552
                                            var target = rec.TriggerCombo;
4553
                                            var custumFunc = rec.SelectFunction;
4554
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4555
                                                Ext.Ajax.request({
4556
                                                    async: false,
4557
                                                    method: 'POST',
4558
                                                    url: '/UserControl/GetStore',
4559
                                                    params: {
4560
                                                        tableName: 'PCMFUNC',
4561
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4562
                                                    },
4563
                                                    success: function (response) {
4564
                                                        var results = Ext.decode(response.responseText);
4565
                                                        data_ = results.data[0];
4566
                                                        if (data_ != undefined) {
4567
                                                            custumFunc = data_.FunctionCode;
4568
                                                        }
4569
                                                    }
4570
                                                });
4571
                                            }
4572
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4573
                                            if (frm) {
4574
                                                if (custumFunc) {
4575
                                                    eval(custumFunc)
4576
                                                }
4577
                                            }
4578
                                        }
4579
                                    }
4580
                                });
4581
                            } else {
4582
                                formfield = new Ext.form.DateField({
4583
                                    allowBlank: allowblank,
4584
                                    fieldLabel: rec.ScreenCaption,
4585
                                    readOnly: readonly,
4586
                                    msgTarget: 'side',
4587
                                    labelCls: 'label-minova',
4588
                                    labelWidth: 150,
4589
                                    hidden: ishidden,
4590
                                    name: rec.FieldName,
4591
                                    submitFormat: 'Ymd',
4592
                                    value: rec.DefaultValue,
4593
                                    anchor: '100%',
4594
                                    formname: formname_,
4595
                                    nameTable: nameTable_,
4596
                                    hideMode: 'visibility',
4597
                                    listeners: {
4598
                                        change: function (val) {
4599
                                            var _label = val.name;
4600
                                            var _form = val.formname;
4601
                                            var _Value = val.getValue();
4602
                                            var target = rec.TriggerCombo;
4603
                                            var custumFunc = rec.SelectFunction;
4604
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4605
                                                Ext.Ajax.request({
4606
                                                    async: false,
4607
                                                    method: 'POST',
4608
                                                    url: '/UserControl/GetStore',
4609
                                                    params: {
4610
                                                        tableName: 'PCMFUNC',
4611
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4612
                                                    },
4613
                                                    success: function (response) {
4614
                                                        var results = Ext.decode(response.responseText);
4615
                                                        data_ = results.data[0];
4616
                                                        if (data_ != undefined) {
4617
                                                            custumFunc = data_.FunctionCode;
4618
                                                        }
4619
                                                    }
4620
                                                });
4621
                                            }
4622
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4623
                                            if (frm) {
4624
                                                if (custumFunc) {
4625
                                                    eval(custumFunc)
4626
                                                }
4627
                                            }
4628
                                        }
4629
                                    }
4630
                                });
4631
                            }
4632
                            break;
4633
                        case "time":
4634
                            formfield = new Ext.form.TimeField({
4635
                                allowBlank: allowblank,
4636
                                fieldLabel: rec.ScreenCaption,
4637
                                readOnly: readonly,
4638
                                labelCls: 'label-minova',
4639
                                labelWidth: 150,
4640
                                hidden: ishidden,
4641
                                name: rec.FieldName,
4642
                                msgTarget: 'side',
4643
                                format: 'Hi',
4644
                                submitFormat: 'Hi',
4645
                                increment: 5,
4646
                                value: rec.DefaultValue,
4647
                                anchor: '100%',
4648
                                formname: formname_,
4649
                                nameTable: nameTable_,
4650
                                listeners: {
4651
                                    change: function (val) {
4652
                                        var _label = val.name;
4653
                                        var _form = val.formname;
4654
                                        var _Value = val.getValue();
4655
                                        var target = rec.TriggerCombo;
4656
                                        var custumFunc = rec.SelectFunction;
4657
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4658
                                            Ext.Ajax.request({
4659
                                                async: false,
4660
                                                method: 'POST',
4661
                                                url: '/UserControl/GetStore',
4662
                                                params: {
4663
                                                    tableName: 'PCMFUNC',
4664
                                                    param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
4665
                                                },
4666
                                                success: function (response) {
4667
                                                    var results = Ext.decode(response.responseText);
4668
                                                    data_ = results.data[0];
4669
                                                    if (data_ != undefined) {
4670
                                                        custumFunc = data_.FunctionCode;
4671
                                                    }
4672
                                                }
4673
                                            });
4674
                                        }
4675
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4676
                                        if (frm) {
4677
                                            if (custumFunc) {
4678
                                                eval(custumFunc)
4679
                                            }
4680
                                        }
4681
                                    }
4682
                                }
4683
                            });
4684
                            break;
4685
                        case "amount":
4686
                            formfield = new Ext.form.TextField({
4687
                                allowBlank: allowblank,
4688
                                fieldLabel: rec.ScreenCaption,
4689
                                readOnly: readonly,
4690
                                labelCls: 'label-minova',
4691
                                labelWidth: 150,
4692
                                hidden: ishidden,
4693
                                name: rec.FieldName,
4694
                                msgTarget: 'side',
4695
                                value: rec.DefaultValue,
4696
                                maxLength: rec.Length,
4697
                                anchor: '100%',
4698
                                formname: formname_,
4699
                                nameTable: nameTable_,
4700
                                fieldStyle: 'text-align:right;',
4701
                                listeners: {
4702
                                    change: function (val) {
4703
                                        var _label = val.name;
4704
                                        var _form = val.formname;
4705
                                        var _Value = val.getValue();
4706
                                        var target = rec.TriggerCombo;
4707
                                        var custumFunc = rec.SelectFunction;
4708
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4709
                                            Ext.Ajax.request({
4710
                                                async: false,
4711
                                                method: 'POST',
4712
                                                url: '/UserControl/GetStore',
4713
                                                params: {
4714
                                                    tableName: 'PCMFUNC',
4715
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4716
                                                },
4717
                                                success: function (response) {
4718
                                                    var results = Ext.decode(response.responseText);
4719
                                                    data_ = results.data[0];
4720
                                                    if (data_ != undefined) {
4721
                                                        custumFunc = data_.FunctionCode;
4722
                                                    }
4723
                                                }
4724
                                            });
4725
                                        }
4726
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4727
                                        if (frm) {
4728
                                            if (custumFunc) {
4729
                                                eval(custumFunc)
4730
                                            }
4731
                                        }
4732
                                    }
4733
                                }
4734
                            });
4735
                            break;
4736
                        case "file":
4737
                            formfield = new MinovaUtil.MinovaES.UploadFile({
4738
                                allowBlank: allowblank,
4739
                                fieldLabel: rec.ScreenCaption,
4740
                                readOnly: readonly,
4741
                                readOnlyCls: 'minova-readonly',
4742
                                hidden: ishidden,
4743
                                labelCls: 'label-minova',
4744
                                name: rec.FieldName,
4745
                                msgTarget: 'side',
4746
                                fieldname: rec.FieldName,
4747
                                IsPrimaryKey: rec.IsPrimaryKey,
4748
                                tableName: rec.TableRef,
4749
                                triggerCls: 'x-form-search-trigger',
4750
                                formtarget: me.formname,
4751
                                anchor: '100%',
4752
                                formname: formname_,
4753
                                nameTable: nameTable_,
4754
                                listeners: {
4755
                                    change: function (val) {
4756
                                        var _label = val.name;
4757
                                        var _form = val.formname;
4758
                                        var _Value = val.getValue();
4759
                                        var target = rec.TriggerCombo;
4760
                                        var custumFunc = rec.SelectFunction;
4761
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4762
                                            Ext.Ajax.request({
4763
                                                async: false,
4764
                                                method: 'POST',
4765
                                                url: '/UserControl/GetStore',
4766
                                                params: {
4767
                                                    tableName: 'PCMFUNC',
4768
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4769
                                                },
4770
                                                success: function (response) {
4771
                                                    var results = Ext.decode(response.responseText);
4772
                                                    data_ = results.data[0];
4773
                                                    if (data_ != undefined) {
4774
                                                        custumFunc = data_.FunctionCode;
4775
                                                    }
4776
                                                }
4777
                                            });
4778
                                        }
4779
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4780
                                        if (frm) {
4781
                                            if (target) {
4782
                                                var f = frm.getForm().findField(target)
4783
                                                _store = f.getStore();
4784
                                                var _tbl = _store.proxy.extraParams.tableName;
4785
                                                var oldParam = _store.proxy.extraParams.param;
4786
                                                _store.proxy.extraParams = {
4787
                                                    tableName: _tbl,
4788
                                                    param: _label + '[=]' + _Value
4789
                                                };
4790
                                                _store.load();
4791
                                            }
4792
                                            if (custumFunc) {
4793
                                                eval(custumFunc)
4794
                                            }
4795
                                        }
4796
                                    }
4797
                                }
4798
                            });
4799
                            break;
4800
                        default:
4801
                            if (rec.DataType == 0) {
4802
                                if (rec.Length > 250) {
4803
                                    formfield = new Ext.form.TextArea({
4804
                                        allowBlank: allowblank,
4805
                                        fieldLabel: rec.ScreenCaption,
4806
                                        readOnly: readonly,
4807
                                        labelCls: 'label-minova',
4808
                                        labelWidth: 150,
4809
                                        hidden: ishidden,
4810
                                        name: rec.FieldName,
4811
                                        msgTarget: 'side',
4812
                                        value: rec.DefaultValue,
4813
                                        maxLength: rec.Length,
4814
                                        anchor: '100%',
4815
                                        formname: formname_,
4816
                                        nameTable: nameTable_,
4817
                                        listeners: {
4818
                                            change: function (val) {
4819
                                                var _label = val.name;
4820
                                                var _form = val.formname;
4821
                                                var _Value = val.getValue();
4822
                                                var target = rec.TriggerCombo;
4823
                                                var custumFunc = rec.SelectFunction;
4824
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4825
                                                    Ext.Ajax.request({
4826
                                                        async: false,
4827
                                                        method: 'POST',
4828
                                                        url: '/UserControl/GetStore',
4829
                                                        params: {
4830
                                                            tableName: 'PCMFUNC',
4831
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4832
                                                        },
4833
                                                        success: function (response) {
4834
                                                            var results = Ext.decode(response.responseText);
4835
                                                            data_ = results.data[0];
4836
                                                            if (data_ != undefined) {
4837
                                                                custumFunc = data_.FunctionCode;
4838
                                                            }
4839
                                                        }
4840
                                                    });
4841
                                                }
4842
                                                var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4843
                                                if (frm) {
4844
                                                    if (custumFunc) {
4845
                                                        eval(custumFunc)
4846
                                                    }
4847
                                                }
4848
                                            }
4849
                                        }
4850
                                    });
4851
                                } else {
4852
                                    if (rec.FixedValue != '') {
4853
                                        var storeData = [];
4854
                                        var str = rec.FixedValue;
4855
                                        var hasil = str.split('||');
4856
                                        hasil.forEach(function (h) {
4857
                                            store_ = h.split('=')
4858
                                            storeData.push({
4859
                                                code: store_[0],
4860
                                                desc: store_[1],
4861
                                            });
4862
                                        });
4863
                                        formfield = new Ext.form.ComboBox({
4864
                                            allowBlank: allowblank,
4865
                                            fieldLabel: rec.ScreenCaption,
4866
                                            forceSelection: true,
4867
                                            readOnly: readonly,
4868
                                            labelCls: 'label-minova',
4869
                                            labelWidth: 150,
4870
                                            hidden: ishidden,
4871
                                            name: rec.FieldName,
4872
                                            msgTarget: 'side',
4873
                                            value: rec.DefaultValue,
4874
                                            anchor: '100%',
4875
                                            formname: formname_,
4876
                                            nameTable: nameTable_,
4877
                                            formtarget: me.formname,
4878
                                            store: Ext.create('Ext.data.Store', {
4879
                                                storeId: 'store' + rec.FieldName,
4880
                                                autoLoad: true,
4881
                                                data: storeData
4882

    
4883
                                            }),
4884
                                            listeners: {
4885
                                                change: function (val) {
4886
                                                    var _label = val.name;
4887
                                                    var _form = val.formtarget;
4888
                                                    var _Value = val.getValue();
4889
                                                    var target = rec.TriggerCombo;
4890
                                                    var custumFunc = rec.SelectFunction;
4891
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4892
                                                    if (frm) {
4893
                                                        if (target) {
4894
                                                            var f = frm.getForm().findField(target)
4895
                                                            _store = f.getStore();
4896
                                                            var _tbl = _store.proxy.extraParams.tableName;
4897
                                                            var oldParam = _store.proxy.extraParams.param;
4898
                                                            _store.proxy.extraParams = {
4899
                                                                tableName: _tbl,
4900
                                                                param: _label + '[=]' + _Value
4901
                                                            };
4902
                                                            _store.load();
4903
                                                        }
4904
                                                        if (custumFunc) {
4905
                                                            eval(custumFunc)
4906
                                                        }
4907
                                                    }
4908
                                                }
4909
                                            },
4910
                                            queryMode: 'local',
4911
                                            valueField: 'code',
4912
                                            displayField: 'desc',
4913
                                        });
4914
                                    } else {
4915
                                        formfield = new Ext.form.TextField({
4916
                                            allowBlank: allowblank,
4917
                                            fieldLabel: rec.ScreenCaption,
4918
                                            readOnly: readonly,
4919
                                            labelCls: 'label-minova',
4920
                                            labelWidth: 150,
4921
                                            hidden: ishidden,
4922
                                            name: rec.FieldName,
4923
                                            msgTarget: 'side',
4924
                                            value: rec.DefaultValue,
4925
                                            maxLength: rec.Length,
4926
                                            anchor: '100%',
4927
                                            formname: formname_,
4928
                                            nameTable: nameTable_,
4929
                                            listeners: {
4930
                                                change: function (val) {
4931
                                                    var _label = val.name;
4932
                                                    var _form = val.formname;
4933
                                                    var _Value = val.getValue();
4934
                                                    var target = rec.TriggerCombo;
4935
                                                    var custumFunc = rec.SelectFunction;
4936
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4937
                                                        Ext.Ajax.request({
4938
                                                            async: false,
4939
                                                            method: 'POST',
4940
                                                            url: '/UserControl/GetStore',
4941
                                                            params: {
4942
                                                                tableName: 'PCMFUNC',
4943
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4944
                                                            },
4945
                                                            success: function (response) {
4946
                                                                var results = Ext.decode(response.responseText);
4947
                                                                data_ = results.data[0];
4948
                                                                if (data_ != undefined) {
4949
                                                                    custumFunc = data_.FunctionCode;
4950
                                                                }
4951
                                                            }
4952
                                                        });
4953
                                                    }
4954
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4955
                                                    if (frm) {
4956
                                                        if (custumFunc) {
4957
                                                            eval(custumFunc)
4958
                                                        }
4959
                                                    }
4960
                                                }
4961
                                            }
4962
                                        });
4963
                                    }
4964
                                }
4965
                            } else if (rec.DataType == 1 || rec.DataType == 2) {
4966
                                formfield = new MinovaUtil.MinovaES.MinovaNumberField({
4967
                                    allowBlank: allowblank,
4968
                                    fieldLabel: rec.ScreenCaption,
4969
                                    readOnly: readonly,
4970
                                    labelCls: 'label-minova',
4971
                                    labelWidth: 150,
4972
                                    msgTarget: 'side',
4973
                                    hidden: ishidden,
4974
                                    name: rec.FieldName,
4975
                                    value: rec.DefaultValue,
4976
                                    maxLength: rec.Length,
4977
                                    anchor: '100%',
4978
                                    formname: formname_,
4979
                                    nameTable: nameTable_,
4980
                                    fieldStyle: 'text-align:right;',
4981
                                    listeners: {
4982
                                        change: function (val) {
4983
                                            var _label = val.name;
4984
                                            var _form = val.formname;
4985
                                            var _Value = val.getValue();
4986
                                            var target = rec.TriggerCombo;
4987
                                            var custumFunc = rec.SelectFunction;
4988
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4989
                                                Ext.Ajax.request({
4990
                                                    async: false,
4991
                                                    method: 'POST',
4992
                                                    url: '/UserControl/GetStore',
4993
                                                    params: {
4994
                                                        tableName: 'PCMFUNC',
4995
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4996
                                                    },
4997
                                                    success: function (response) {
4998
                                                        var results = Ext.decode(response.responseText);
4999
                                                        data_ = results.data[0];
5000
                                                        if (data_ != undefined) {
5001
                                                            custumFunc = data_.FunctionCode;
5002
                                                        }
5003
                                                    }
5004
                                                });
5005
                                            }
5006
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5007
                                            if (frm) {
5008
                                                if (target) {
5009
                                                    var f = frm.getForm().findField(target)
5010
                                                    _store = f.getStore();
5011
                                                    var _tbl = _store.proxy.extraParams.tableName;
5012
                                                    var oldParam = _store.proxy.extraParams.param;
5013
                                                    _store.proxy.extraParams = {
5014
                                                        tableName: _tbl,
5015
                                                        param: _label + '[=]' + _Value
5016
                                                    };
5017
                                                    _store.load();
5018
                                                }
5019
                                                if (custumFunc) {
5020
                                                    eval(custumFunc)
5021
                                                }
5022
                                            }
5023
                                        }
5024
                                    }
5025
                                });
5026
                            } else if (rec.DataType == 3) {
5027
                                formfield = new Ext.form.TextField({
5028
                                    allowBlank: allowblank,
5029
                                    fieldLabel: rec.ScreenCaption,
5030
                                    readOnly: readonly,
5031
                                    labelCls: 'label-minova',
5032
                                    labelWidth: 150,
5033
                                    msgTarget: 'side',
5034
                                    hidden: ishidden,
5035
                                    name: rec.FieldName,
5036
                                    value: rec.DefaultValue,
5037
                                    maxLength: rec.Length,
5038
                                    precision: rec.Prec,
5039
                                    anchor: '100%',
5040
                                    formname: formname_,
5041
                                    nameTable: nameTable_,
5042
                                    fieldStyle: 'text-align:right;',
5043
                                    maskRe: '^[0-9]+(\.[0-9]{1,2})?$',
5044
                                    listeners: {
5045
                                        change: function (val) {
5046
                                            var _label = val.name;
5047
                                            var _form = val.formname;
5048
                                            var _Value = val.getValue();
5049
                                            var target = rec.TriggerCombo;
5050
                                            var custumFunc = rec.SelectFunction;
5051
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5052
                                                Ext.Ajax.request({
5053
                                                    async: false,
5054
                                                    method: 'POST',
5055
                                                    url: '/UserControl/GetStore',
5056
                                                    params: {
5057
                                                        tableName: 'PCMFUNC',
5058
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5059
                                                    },
5060
                                                    success: function (response) {
5061
                                                        var results = Ext.decode(response.responseText);
5062
                                                        data_ = results.data[0];
5063
                                                        if (data_ != undefined) {
5064
                                                            custumFunc = data_.FunctionCode;
5065
                                                        }
5066
                                                    }
5067
                                                });
5068
                                            }
5069
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5070
                                            if (frm) {
5071
                                                if (target) {
5072
                                                    var f = frm.getForm().findField(target)
5073
                                                    _store = f.getStore();
5074
                                                    var _tbl = _store.proxy.extraParams.tableName;
5075
                                                    var oldParam = _store.proxy.extraParams.param;
5076
                                                    _store.proxy.extraParams = {
5077
                                                        tableName: _tbl,
5078
                                                        param: _label + '[=]' + _Value
5079
                                                    };
5080
                                                    _store.load();
5081
                                                }
5082
                                                if (custumFunc) {
5083
                                                    eval(custumFunc)
5084
                                                }
5085
                                            }
5086
                                        }
5087
                                    }
5088
                                });
5089
                            }
5090
                    }
5091
                } else if (rec.SearchType != "") {
5092
                    if (rec.SearchType == "0") //combobox
5093
                    {
5094
                        valueField = null;
5095
                        displayValue = null;
5096
						if (rec.TableRef != "") {
5097
							Ext.Ajax.request({
5098
								async: false,
5099
								method: 'POST',
5100
								url: '/UserControl/GetStore',
5101
								params: {
5102
									tableName: 'SDATATABLEFIELD',
5103
									param: 'TableName[equal]' + rec.TableRef
5104
								},
5105
								success: function (response) {
5106
									var results = Ext.decode(response.responseText);
5107
									data_ = results.data;
5108
									if (data_ != undefined) {
5109
										valueField_ = $.grep(data_, function (r) {
5110
											return r.ValueField == '1'
5111
										});
5112
										if (valueField_.length > 0) {
5113
											valueField = valueField_[0].FieldName
5114
										}
5115
										displayValue_ = $.grep(data_, function (r) {
5116
											return r.DisplayValue == '1'
5117
										});
5118
										if (displayValue_.length > 0) {
5119
											displayValue = displayValue_[0].FieldName
5120
										}
5121
									}
5122
								}
5123
							});
5124
						}
5125
                        formfield = new Ext.form.ComboBox({
5126
                            allowBlank: allowblank,
5127
                            fieldLabel: rec.ScreenCaption,
5128
                            forceSelection: true,
5129
							anyMatch: true,
5130
                            readOnly: readonly,
5131
                            labelCls: 'label-minova',
5132
                            labelWidth: 150,
5133
                            hidden: ishidden,
5134
                            msgTarget: 'side',
5135
                            name: rec.FieldName,
5136
                            formname: formname_,
5137
                            nameTable: nameTable_,
5138
                            value: rec.DefaultValue,
5139
                            width: '95%',
5140
                            store: Ext.create('Ext.data.Store', {
5141
                                storeId: 'store' + rec.FieldName,
5142
                                autoLoad: false,
5143
                                proxy: {
5144
                                    method: 'POST',
5145
                                    type: 'ajax',
5146
                                    url: '/UserControl/GetStore',
5147
                                    extraParams: {
5148
                                        tableName: rec.TableRef,
5149
                                        param: rec.ParamCombo
5150
                                    },
5151
                                    reader: {
5152
                                        type: 'json',
5153
                                        root: 'data',
5154
                                        totalProperty: 'data[0].TotalCount'
5155
                                    }
5156
                                }
5157
                            }),
5158
                            formtarget: formname_,
5159
                            listeners: {
5160
                                afterrender: function (f) {
5161
                                    var store_ = f.getStore();
5162
                                    store_.load();
5163
                                },
5164
                                change: function (val) {
5165
                                    var _label = val.name;
5166
                                    var _form = val.formtarget;
5167
                                    var _Value = val.getValue();
5168
                                    var target = rec.TriggerCombo;
5169
                                    var custumFunc = rec.SelectFunction;
5170
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5171
                                    if (frm) {
5172

    
5173
                                        if (target) {
5174
                                            var f = frm.getForm().findField(target)
5175
                                            _store = f.getStore();
5176
                                            var _tbl = _store.proxy.extraParams.tableName;
5177
                                            var oldParam = _store.proxy.extraParams.param;
5178
                                            _store.proxy.extraParams = {
5179
                                                tableName: _tbl,
5180
                                                param: _label + '[=]' + _Value
5181
                                            };
5182
                                            _store.load();
5183
                                        }
5184
                                        if (custumFunc) {
5185
                                            eval(custumFunc)
5186
                                        }
5187
                                    }
5188
                                }
5189
                            },
5190
                            queryMode: 'local',
5191
                            displayField: displayValue,
5192
                            valueField: valueField,
5193
                        });
5194
                    } else if (rec.SearchType == '2') //Lookup
5195
                    {
5196
                        formfield = new MinovaUtil.MinovaES.MinovaLookupGrid({
5197
                            allowBlank: allowblank,
5198
                            fieldLabel: rec.ScreenCaption,
5199
                            readOnly: readonly,
5200
                            IsPrimaryKey: rec.IsPrimaryKey,
5201
                            msgTarget: 'side',
5202
                            labelCls: 'label-minova',
5203
                            labelWidth: 150,
5204
                            hidden: ishidden,
5205
                            name: rec.FieldName,
5206
                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
5207
                            triggerCls: 'x-form-search-trigger',
5208
                            vtype: 'alphanum', // disable space
5209
                            formtarget: me.formname, // nama form  yang akan di set value-nya
5210
                            anchor: '100%',
5211
                            formname: formname_,
5212
                            nameTable: nameTable_,
5213
                            LookupFunction: rec.LookupFunction,
5214
                            SearchFunction: rec.SearchFunction,
5215
                            listeners: {
5216
                                change: function (val) {
5217
                                    var _label = val.name;
5218
                                    var _form = val.formname;
5219
                                    var _Value = val.getValue();
5220
                                    var target = rec.TriggerCombo;
5221
                                    var custumFunc = rec.SelectFunction;
5222
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5223
                                        Ext.Ajax.request({
5224
                                            async: false,
5225
                                            method: 'POST',
5226
                                            url: '/UserControl/GetStore',
5227
                                            params: {
5228
                                                tableName: 'PCMFUNC',
5229
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5230
                                            },
5231
                                            success: function (response) {
5232
                                                var results = Ext.decode(response.responseText);
5233
                                                data_ = results.data[0];
5234
                                                if (data_ != undefined) {
5235
                                                    custumFunc = data_.FunctionCode;
5236
                                                }
5237
                                            }
5238
                                        });
5239
                                    }
5240
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5241
                                    if (frm) {
5242

    
5243
                                        if (target) {
5244
                                            var f = frm.getForm().findField(target)
5245
                                            _store = f.getStore();
5246
                                            var _tbl = _store.proxy.extraParams.tableName;
5247
                                            var oldParam = _store.proxy.extraParams.param;
5248
                                            _store.proxy.extraParams = {
5249
                                                tableName: _tbl,
5250
                                                param: _label + '[=]' + _Value
5251
                                            };
5252
                                            _store.load();
5253
                                        }
5254

    
5255
                                        if (custumFunc) {
5256
                                            eval(custumFunc)
5257
                                        }
5258

    
5259
                                    }
5260

    
5261
                                },
5262

    
5263
                            },
5264
                        });
5265
                    } else if (rec.SearchType == '3') //lookup tree
5266
                    {
5267
                        formfield = new MinovaUtil.MinovaES.MinovaLookupTree({
5268
                            allowBlank: allowblank,
5269
                            fieldLabel: rec.ScreenCaption,
5270
                            readOnly: readonly,
5271
                            IsPrimaryKey: rec.IsPrimaryKey,
5272
                            labelCls: 'label-minova',
5273
                            labelWidth: 150,
5274
                            hidden: ishidden,
5275
                            name: rec.FieldName,
5276
                            msgTarget: 'side',
5277
                            triggerCls: 'x-form-search-trigger',
5278
                            treeSructure: rec.SearchFunction, //'O-O-P',
5279
                            objClassValue: rec.ParamCombo, //'O',
5280
                            formname: formname_,
5281
                            targetField: rec.FieldName,
5282
                            nameTable: nameTable_,
5283
                            editable: false,
5284
                            anchor: '100%',
5285
                            listeners: {
5286
                                change3: function (val) {
5287
                                    var _label = val.name;
5288
                                    var _form = val.formname;
5289
                                    var _Value = val.getValue();
5290
                                    var target = rec.TriggerCombo;
5291
                                    var custumFunc = rec.SelectFunction;
5292
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5293
                                        Ext.Ajax.request({
5294
                                            async: false,
5295
                                            method: 'POST',
5296
                                            url: '/UserControl/GetStore',
5297
                                            params: {
5298
                                                tableName: 'PCMFUNC',
5299
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5300
                                            },
5301
                                            success: function (response) {
5302
                                                var results = Ext.decode(response.responseText);
5303
                                                data_ = results.data[0];
5304
                                                if (data_ != undefined) {
5305
                                                    custumFunc = data_.FunctionCode;
5306
                                                }
5307
                                            }
5308
                                        });
5309
                                    }
5310
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5311
                                    if (frm) {
5312

    
5313
                                        if (target) {
5314
                                            var f = frm.getForm().findField(target)
5315
                                            _store = f.getStore();
5316
                                            var _tbl = _store.proxy.extraParams.tableName;
5317
                                            var oldParam = _store.proxy.extraParams.param;
5318
                                            _store.proxy.extraParams = {
5319
                                                tableName: _tbl,
5320
                                                param: _label + '[=]' + _Value
5321
                                            };
5322
                                            _store.load();
5323
                                        }
5324
                                        if (custumFunc) {
5325
                                            eval(custumFunc)
5326
                                        }
5327
                                    }
5328
                                },
5329
                                blur: function (val) {
5330
                                    //if(val.value.split('-').length != 2){
5331
                                    var _label = val.name;
5332
                                    var _form = val.formname;
5333
                                    var _Value = val.getValue();
5334
                                    var target = rec.TriggerCombo;
5335
                                    var custumFunc = rec.SelectFunction;
5336
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5337
                                        Ext.Ajax.request({
5338
                                            async: false,
5339
                                            method: 'POST',
5340
                                            url: '/UserControl/GetStore',
5341
                                            params: {
5342
                                                tableName: 'PCMFUNC',
5343
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5344
                                            },
5345
                                            success: function (response) {
5346
                                                var results = Ext.decode(response.responseText);
5347
                                                data_ = results.data[0];
5348
                                                if (data_ != undefined) {
5349
                                                    custumFunc = data_.FunctionCode;
5350
                                                }
5351
                                            }
5352
                                        });
5353
                                    }
5354
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5355
                                    if (frm) {
5356

    
5357
                                        if (target) {
5358
                                            var f = frm.getForm().findField(target)
5359
                                            _store = f.getStore();
5360
                                            var _tbl = _store.proxy.extraParams.tableName;
5361
                                            var oldParam = _store.proxy.extraParams.param;
5362
                                            _store.proxy.extraParams = {
5363
                                                tableName: _tbl,
5364
                                                param: _label + '[=]' + _Value
5365
                                            };
5366
                                            _store.load();
5367
                                        }
5368
                                        if (custumFunc) {
5369
                                            eval(custumFunc)
5370
                                        }
5371
                                    }
5372
                                    //}
5373
                                }
5374

    
5375
                            }
5376
                        });
5377
                    }
5378
                }
5379
                if (isDesk) {
5380
                    if (rec.ColumnNo == 1) {
5381
                        col1.push(formfield);
5382
                    } else {
5383
                        col2.push(formfield);
5384
                    }
5385
                } else {
5386
                    col1.push(formfield);
5387
                }
5388

    
5389
            });
5390
        }
5391
        Ext.applyIf(me, {
5392
            items: [{
5393
                //width: 450,
5394
                style: 'width: 50%',
5395
                items: col1
5396
            }, {
5397
                //width: 450,
5398
                style: 'width: 50%',
5399
                items: col2
5400
            }
5401
            ],
5402
        });
5403
        this.callParent();
5404
    }
5405
});
5406
/*Gird ESS Generator*/
5407
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowGrid', {
5408
    extend: 'Ext.grid.Panel',
5409
    requires: ['Ext.grid.RowNumberer'],
5410
    alias: 'widget.minovaworkflowgrid',
5411
    alternateClassName: 'Ext.grid.MinovaGrid',
5412
    tableName: undefined,
5413
    param: undefined,
5414
    pagesize: undefined,
5415
    storeName: undefined,
5416
    enableLocking: true,
5417
    autoLoad: undefined,
5418
    multiSelect: undefined,
5419
    formname: this.name,
5420
    bizprocid: undefined,
5421
    taskid: undefined,
5422
    initComponent: function () {
5423
        var me = this;
5424
        var cols_ = [];
5425
        var fieldeditor = {};
5426
        var hasil = null;
5427
        var autoLoad = true;
5428
        var locking = true;
5429
        var widthLock = 250;
5430
        if (me.autoLoad == false) {
5431
            autoLoad = false;
5432
        }
5433
        var LangID = MinovaUtil.GetLangID();
5434
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
5435
        Ext.Ajax.request({
5436
            async: false,
5437
            method: 'POST',
5438
            url: '/UserControl/GetStore',
5439
            params: {
5440
                tableName: 'PDSWFSTRUCTUREFIELD',
5441
                param: parameter
5442
            },
5443
            success: function (response) {
5444
                var results = Ext.decode(response.responseText);
5445
                hasil = results.data;
5446
            }
5447
        });
5448

    
5449
        if (hasil.length > 0) {
5450
            Ext.each(hasil, function (rec) {
5451
                var readonly = false;
5452
                var ishidden = false;
5453
                var allowblank = true;
5454
                var null_ = null;
5455
                if (rec.IsReadOnly == '1') {
5456
                    readonly = true;
5457
                }
5458
                if (rec.IsRequired == '1') {
5459
                    allowblank = false;
5460
                }
5461
                if (rec.IsVisible == '1') {
5462
                    switch (rec.FormatRef) {
5463
                        case "date":
5464
                            cols_.push({
5465
                                xtype: 'minovadatecolumn',
5466
                                text: rec.HeaderTitle,
5467
                                dataIndex: rec.FieldName,
5468
                                width: 100
5469
                            });
5470
                            break
5471
                        case "amountencrypt":
5472
                            cols_.push({
5473
                                xtype: 'minovaamountcolumn',
5474
                                align: 'right',
5475
                                text: rec.HeaderTitle,
5476
                                dataIndex: rec.FieldName,
5477
                                width: 100
5478
                            });
5479
                            break
5480
                        case "amount":
5481
                            cols_.push({
5482
                                xtype: 'minovacurrancycolumn',
5483
                                align: 'right',
5484
                                text: rec.HeaderTitle,
5485
                                dataIndex: rec.FieldName,
5486
                                width: 100,
5487
                                filter: {
5488
                                    type: 'number',
5489
                                    itemDefaults: {
5490
                                        emptyText: 'Search for...'
5491
                                    }
5492
                                }
5493
                            });
5494
                            break
5495
                        case "datetime":
5496
                            cols_.push({
5497
                                xtype: 'minovadatetimecolumn',
5498
                                text: rec.HeaderTitle,
5499
                                dataIndex: rec.FieldName,
5500
                                width: 140,
5501
                                filter: {
5502
                                    type: 'string',
5503
                                    itemDefaults: {
5504
                                        emptyText: 'Search for...'
5505
                                    }
5506
                                }
5507
                            });
5508
                            break
5509
                        default:
5510
                            if (rec.TableRef != "") {
5511
                                if (rec.TableRef != null) {
5512
                                    var valueField = null;
5513
                                    var displayValue = null;
5514
                                    Ext.Ajax.request({
5515
                                        async: false,
5516
                                        method: 'POST',
5517
                                        url: '/UserControl/GetStore',
5518
                                        params: {
5519
                                            tableName: 'SDATATABLEFIELD',
5520
                                            param: 'TableName[equal]' + rec.TableRef
5521
                                        },
5522
                                        success: function (response) {
5523
                                            var results = Ext.decode(response.responseText);
5524
                                            data_ = results.data;
5525

    
5526
                                            if (data_ != undefined) {
5527
                                                if (data_.length > 0) {
5528
                                                    valueField_ = $.grep(data_, function (r) {
5529
                                                        return r.ValueField == '1'
5530
                                                    });
5531
                                                    valueField = valueField_[0].FieldName
5532
                                                    displayValue_ = $.grep(data_, function (r) {
5533
                                                        return r.DisplayValue == '1'
5534
                                                    });
5535
                                                    displayValue = displayValue_[0].FieldName
5536
                                                }
5537
                                            }
5538
                                        }
5539
                                    });
5540
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
5541
                                    var count_ = 0;
5542
                                    if (store_) {
5543
                                        count_ = store_.count();
5544
                                    }
5545
                                    if (count_ == 0) {
5546
                                        Ext.create('Ext.data.Store', {
5547
                                            storeId: 'store_' + rec.FieldName,
5548
                                            autoLoad: false,
5549
                                            proxy: {
5550
                                                method: 'POST',
5551
                                                type: 'ajax',
5552
                                                url: '/UserControl/GetStore',
5553
                                                extraParams: {
5554
                                                    tableName: rec.TableRef,
5555
                                                    param: rec.ParamCombo
5556
                                                },
5557
                                                reader: {
5558
                                                    type: 'json',
5559
                                                    root: 'data',
5560
                                                    totalProperty: 'data[0].TotalCount'
5561
                                                }
5562
                                            }
5563
                                        })
5564
                                    }
5565
                                    cols_.push({
5566
                                        xtype: 'minovacombocolumn',
5567
                                        text: rec.HeaderTitle,
5568
                                        dataIndex: rec.FieldName,
5569
                                        valueField: valueField,
5570
                                        displayField: displayValue,
5571
                                        store: 'store_' + rec.FieldName,
5572
                                        filter: {
5573
                                            type: 'list',
5574
                                            itemDefaults: {
5575
                                                emptyText: 'Search for...'
5576
                                            }
5577
                                        }
5578
                                    });
5579
                                }
5580
                            } else {
5581
                                cols_.push({
5582
                                    text: rec.HeaderTitle,
5583
                                    dataIndex: rec.FieldName,
5584
                                    filter: {
5585
                                        itemDefaults: {
5586
                                            emptyText: 'Search for...'
5587
                                        }
5588
                                    }
5589
                                });
5590
                            }
5591
                            break
5592
                    }
5593
                } else {
5594
                    cols_.push({
5595
                        text: rec.HeaderTitle,
5596
                        dataIndex: rec.FieldName,
5597
                        hidden: true,
5598
                        filter: {
5599
                            itemDefaults: {
5600
                                emptyText: 'Search for...'
5601
                            }
5602
                        }
5603
                    });
5604
                }
5605
            });
5606
        };
5607
        var param_ = me.param;
5608
        if (param_ == undefined) {
5609
            param_ = ''
5610
        }
5611
        var jsStoreGrid = new Ext.data.Store({
5612
            storeId: me.storeName,
5613
            autoLoad: autoLoad,
5614
            pageSize: 10,
5615
            proxy: {
5616
                method: 'POST',
5617
                type: 'ajax',
5618
                url: '/UserControl/GetStorePagingAuth',
5619
                extraParams: {
5620
                    tableName: me.tableName,
5621
                    param: param_,
5622
                    menuId: MinovaUtil.GetMenuID()
5623
                },
5624
                reader: {
5625
                    type: 'json',
5626
                    root: 'data',
5627
                    totalProperty: 'totalRecords'
5628
                }
5629
            }
5630
        });
5631
        Ext.applyIf(me, {
5632
            autoScroll: true,
5633
            enableLocking: locking,
5634
            lockedGridConfig: {
5635
                header: false,
5636
                collapsible: true,
5637
                width: widthLock,
5638
                forceFit: locking,
5639
                listeners: {
5640
                    render: function (grid) {
5641
                        var pagingToolbar = grid.child('pagingtoolbar');
5642
                        if (pagingToolbar) {
5643
                            grid.remove(pagingToolbar, true);
5644
                        }
5645
                    }
5646
                }
5647
            },
5648
            listeners: {
5649
                viewready: function () {
5650
                    if (autoLoad == true) {
5651
                        this.getStore().loadPage(1);
5652
                    }
5653

    
5654
                },
5655
                beforeedit: function () {
5656
                    return false;
5657
                }
5658
            },
5659
            lockedViewConfig: {
5660
                scroll: 'horizontal'
5661
            },
5662
            viewConfig: {
5663
                emptyText: 'No Data Display',
5664
                deferEmptyText: false,
5665
                listeners: {
5666
                    refresh: function (dataview) {
5667
                        Ext.each(dataview.panel.columns, function (column) {
5668
                            if (column.autoSizeColumn == false)
5669
                                column.autoSizeColumn = true;
5670
                            column.autoSize();
5671
                        })
5672
                    }
5673
                }
5674
            },
5675
            columns: cols_,
5676
            store: jsStoreGrid,
5677
            plugins: [{
5678
                ptype: 'gridfilters'
5679
            }
5680
            ]
5681
        });
5682
        this.callParent();
5683
    }
5684
});
5685
/*EditableGrid ESS Generator*/
5686
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowEditableGrid', {
5687
    extend: 'Ext.form.Panel',
5688
    alias: ['widget.minovaworkfloweditablegrid', 'widget.workfloweditablegrid1'],
5689
    requires: [
5690
		'Ext.grid.plugin.CellEditing',
5691
		'Ext.grid.RowNumberer',
5692
		'Ext.grid.Panel',
5693
    ],
5694
    anchor: '100%',
5695
    tableName: undefined,
5696
    hideButton: undefined,
5697
    multiSelect: undefined,
5698
    formname: this.name,
5699
    bizprocid: undefined,
5700
    bizflowid: undefined,
5701
    taskid: undefined,
5702
	features: undefined,
5703
    minHeight: 200,
5704
    maxHeight: 400,
5705
    initComponent: function () {
5706
        var me = this;
5707
        var isLookup = me.isLookup;
5708
        var hide_ = false;
5709
        var widthLock = 250;
5710
        var checkSelection = '';
5711
        if (me.hideButton == true) {
5712
            hide_ = true;
5713
        }
5714
        if (me.multiSelect) {
5715
            locking = false;
5716
            checkSelection = 'checkboxmodel';
5717
            widthLock = 40;
5718
        }
5719
        var tableName = me.tableName;
5720
		var features = me.features;
5721
        var cols = [];
5722
        var fieldStore = [];
5723
        var _url = 'GetAllField';
5724
        var hasil = null;
5725
        var height = me.height;
5726
        var storeID = 'store' + me.tableName;
5727
        var gridName = 'grid' + me.name;
5728
        if (me.storeName) {
5729
            storeID = me.storeName;
5730
        }
5731
        var LangID = MinovaUtil.GetLangID();
5732
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
5733
        Ext.Ajax.request({
5734
            async: false,
5735
            method: 'POST',
5736
            url: '/UserControl/GetStore',
5737
            params: {
5738
                tableName: 'PDSWFSTRUCTUREFIELD',
5739
                param: parameter
5740
            },
5741
            success: function (response) {
5742
                var results = Ext.decode(response.responseText);
5743
                hasil = results.data;
5744
            }
5745
        });
5746
        cols.push({
5747
            xtype: 'rownumberer'
5748
        });
5749
        var addData = 'var data={';
5750
        if (hasil.length > 0) {
5751
            Ext.each(hasil, function (rec) {
5752
                fieldStore.push(rec.FieldName);
5753
                if (rec.FieldName != 'Sequence') {
5754
                    addData = addData + rec.FieldName + ":" + "'',";
5755
                }
5756
                var null_ = null;
5757
                var ReadOnly_ = false;
5758
                if (rec.IsRequired == '1') {
5759
                    null_ = false;
5760
                } else {
5761
                    null_ = true;
5762
                }
5763
                var Hidden_ = false;
5764
                if (rec.IsReadOnly == '1') {
5765
                    ReadOnly_ = true;
5766
                }
5767
                if (rec.IsVisible == '1') {
5768
                    switch (rec.FormatRef) {
5769
                        case "date":
5770
                            cols.push({
5771
                                xtype: 'minovadatecolumn',
5772
                                hidden: Hidden_,
5773
                                text: rec.HeaderTitle,
5774
                                dataIndex: rec.FieldName,
5775
                                filter: {
5776
                                    itemDefaults: {
5777
                                        emptyText: 'Search for...',
5778
                                    }
5779
                                },
5780
                                editor: {
5781
                                    allowBlank: null_,
5782
                                    xtype: 'datefield',
5783
                                    hideMode: 'visibility',
5784
                                    readOnly: ReadOnly_,
5785
                                    id: tableName + rec.FieldName,
5786
                                    fieldGrid: rec.FieldName,
5787
                                    nameTable: rec.TableName,
5788
                                    value: rec.DefaultValue
5789
                                }
5790
                            });
5791
                            break
5792
                        case "amount":
5793
                            cols.push({
5794
                                xtype: 'minovacurrancycolumn',
5795
                                align: 'right',
5796
                                text: rec.HeaderTitle,
5797
                                dataIndex: rec.FieldName,
5798
                                hidden: Hidden_,
5799
                                filter: {
5800
                                    itemDefaults: {
5801
                                        emptyText: 'Search for...'
5802
                                    }
5803
                                },
5804
                                editor: {
5805
                                    allowBlank: null_,
5806
                                    xtype: 'minovacurrencyfield',
5807
                                    readOnly: ReadOnly_,
5808
                                    id: tableName + rec.FieldName,
5809
                                    nameTable: rec.TableName,
5810
                                    fieldGrid: rec.FieldName,
5811
                                    fieldStyle: 'text-align:right;',
5812
                                    value: '0'
5813
                                }
5814
                            });
5815
                            break
5816
                        default:
5817
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
5818
                                cols.push({
5819
                                    text: rec.HeaderTitle,
5820
                                    dataIndex: rec.FieldName,
5821
                                    width: 100,
5822
                                    filter: {
5823
                                        type: 'string',
5824
                                        itemDefaults: {
5825
                                            emptyText: 'Search for...'
5826
                                        }
5827
                                    }
5828
                                });
5829
                            } else if (rec.SearchType == '0') {
5830
                                var valueField = null;
5831
                                var displayValue = null;
5832
                                var TableRef = undefined;
5833
                                if (rec.TableRef != '') {
5834
                                    TableRef = rec.TableRef;
5835
                                    Ext.Ajax.request({
5836
                                        async: false,
5837
                                        method: 'POST',
5838
                                        url: '/UserControl/GetStore',
5839
                                        params: {
5840
                                            tableName: 'SDATATABLEFIELD',
5841
                                            param: 'TableName[equal]' + rec.TableRef
5842
                                        },
5843
                                        success: function (response) {
5844
                                            var results = Ext.decode(response.responseText);
5845
                                            data_ = results.data;
5846
                                            if (data_ != undefined) {
5847
                                                valueField_ = $.grep(data_, function (r) {
5848
                                                    return r.ValueField == '1'
5849
                                                });
5850
                                                valueField = valueField_[0].FieldName
5851
                                                displayValue_ = $.grep(data_, function (r) {
5852
                                                    return r.DisplayValue == '1'
5853
                                                });
5854
                                                displayValue = displayValue_[0].FieldName
5855
                                            }
5856
                                        }
5857
                                    });
5858
                                }
5859
                                Ext.create('Ext.data.Store', {
5860
                                    storeId: 'store_' + me.tableName + rec.FieldName,
5861
                                    autoLoad: true,
5862
                                    proxy: {
5863
                                        method: 'POST',
5864
                                        type: 'ajax',
5865
                                        url: '/UserControl/GetStoreAuth',
5866
                                        extraParams: {
5867
                                            tableName: TableRef,
5868
                                            param: rec.ParamCombo,
5869
                                            menuId: MinovaUtil.GetMenuID()
5870
                                        },
5871
                                        reader: {
5872
                                            type: 'json',
5873
                                            root: 'data',
5874
                                            totalProperty: 'data[0].TotalCount'
5875
                                        }
5876
                                    }
5877
                                });
5878
                                cols.push({
5879
                                    //xtype : 'minovacombocolumn',
5880
                                    hidden: Hidden_,
5881
                                    text: rec.HeaderTitle,
5882
                                    dataIndex: rec.FieldName,
5883
                                    //valueField : valueField,
5884
                                    //displayField : displayValue,
5885
                                    //store : 'store_' + me.tableName + rec.FieldName,
5886
                                    editor: {
5887
                                        allowBlank: null_,
5888
                                        xtype: 'minovacombobox',
5889
                                        readOnly: ReadOnly_,
5890
                                        id: rec.TableName + rec.FieldName,
5891
                                        nameTable: rec.TableName,
5892
                                        fieldGrid: rec.FieldName,
5893
                                        valueField: valueField,
5894
                                        displayField: displayValue,
5895
                                        store: 'store_' + me.tableName + rec.FieldName,
5896
                                        value: rec.DefaultValue
5897
                                    },
5898
                                    renderer: function (value) {
5899
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
5900
                                        var index = store.find(valueField, value);
5901
                                        var val = "";
5902
                                        if (index != -1) {
5903
                                            var rc = store.getAt(index);
5904
                                            val = rc.get(displayValue);
5905
                                        } else {
5906
                                            val = value;
5907
                                        }
5908
                                        return val;
5909
                                    },
5910
                                    filter: {
5911
                                        type: 'list',
5912
                                        itemDefaults: {
5913
                                            emptyText: 'Search for...'
5914
                                        }
5915
                                    }
5916
                                });
5917
                            } else if (rec.SearchType == '5') {							
5918
                                var valueField = null;
5919
                                var displayValue = null;
5920
                                var AdditionaldisplayValue = null;
5921
                                var TableRef = undefined;
5922
                                if (rec.TableRef != '') {
5923
                                    TableRef = rec.TableRef;
5924
                                    Ext.Ajax.request({
5925
                                        async: false,
5926
                                        method: 'POST',
5927
                                        url: '/UserControl/GetStore',
5928
                                        params: {
5929
                                            tableName: 'SDATATABLEFIELD',
5930
                                            param: 'TableName[equal]' + rec.TableRef
5931
                                        },
5932
                                        success: function (response) {
5933
                                            var results = Ext.decode(response.responseText);
5934
                                            data_ = results.data;
5935
                                            if (data_ != undefined) {
5936
                                                valueField_ = $.grep(data_, function (r) {
5937
                                                    return r.ValueField == '1'
5938
                                                });
5939
                                                if (valueField_.length > 0) {
5940
                                                    valueField = valueField_[0].FieldName
5941
                                                }
5942

    
5943
                                                displayValue_ = $.grep(data_, function (r) {
5944
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
5945
                                                });
5946
                                                if (displayValue_.length > 0) {
5947
                                                    displayValue = displayValue_[0].FieldName;
5948
                                                }
5949
                                                if (displayValue_.length >= 2) {
5950
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
5951
                                                }
5952
                                            }
5953
                                        }
5954
                                    });
5955
                                }
5956
                                Ext.create('Ext.data.Store', {
5957
                                    storeId: 'store_' + me.tableName + rec.FieldName,
5958
                                    autoLoad: true,
5959
                                    proxy: {
5960
                                        method: 'POST',
5961
                                        type: 'ajax',
5962
                                        url: '/UserControl/GetStoreAuth',
5963
                                        extraParams: {
5964
                                            tableName: TableRef,
5965
                                            param: rec.ParamCombo,
5966
                                            menuId: MinovaUtil.GetMenuID()
5967
                                        },
5968
                                        reader: {
5969
                                            type: 'json',
5970
                                            root: 'data',
5971
                                            totalProperty: 'data[0].TotalCount'
5972
                                        }
5973
                                    }
5974
                                });
5975
                                cols.push({
5976
                                    //xtype : 'minovacombocolumn',
5977
                                    hidden: Hidden_,
5978
                                    text: rec.HeaderTitle,
5979
                                    dataIndex: rec.FieldName,
5980
                                    //valueField : valueField,
5981
                                    //displayField : displayValue,
5982
                                    //store : 'store_' + me.tableName + rec.FieldName,
5983
                                    tpl: Ext.create('Ext.XTemplate',
5984
                                            '<ul class="x-list-plain"><tpl for=".">',
5985
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
5986
                                            '</tpl></ul>'),
5987
                                    displayTpl: Ext.create('Ext.XTemplate',
5988
                                        '<tpl for=".">',
5989
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
5990
                                        '</tpl>'),
5991
                                    editor: {
5992
                                        allowBlank: null_,
5993
                                        xtype: 'combobox',
5994
                                        readOnly: ReadOnly_,
5995
                                        id: rec.TableName + rec.FieldName,
5996
                                        nameTable: rec.TableName,
5997
                                        fieldGrid: rec.FieldName,
5998
                                        valueField: valueField,
5999
                                        displayField: displayValue,
6000
                                        store: 'store_' + me.tableName + rec.FieldName,
6001
                                        value: rec.DefaultValue,
6002
                                        tpl: Ext.create('Ext.XTemplate',
6003
                                            '<ul class="x-list-plain"><tpl for=".">',
6004
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
6005
                                            '</tpl></ul>'),
6006
                                        displayTpl: Ext.create('Ext.XTemplate',
6007
                                            '<tpl for=".">',
6008
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
6009
                                            '</tpl>')
6010
                                    },
6011
                                    renderer: function (value) {
6012
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
6013
                                        var index = store.find(valueField, value);
6014
                                        var val = "";
6015
                                        if (index != -1) {
6016
                                            var rc = store.getAt(index);
6017
                                            //val = rc.get(displayValue);
6018
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
6019
                                        } else {
6020
                                            val = value;
6021
                                        }
6022
                                        return val;
6023
                                    },
6024
                                    filter: {
6025
                                        type: 'list',
6026
                                        itemDefaults: {
6027
                                            emptyText: 'Search for...'
6028
                                        }
6029
                                    }
6030
                                });
6031
                            } else if (rec.SearchType == '2') {
6032
                                var triger = (rec.TriggerCombo).split('$');
6033
                                var targetField_ = triger[0];
6034
                                var fieldValue_ = triger[1];
6035
                                cols.push({
6036
                                    text: rec.HeaderTitle,
6037
                                    hidden: Hidden_,
6038
                                    dataIndex: rec.FieldName,
6039
                                    filter: {
6040
                                        itemDefaults: {
6041
                                            emptyText: 'Search for...'
6042
                                        }
6043
                                    },
6044
                                    editor: {
6045
                                        allowBlank: null_,
6046
                                        xtype: 'minovalookupgrid',
6047
                                        readOnly: ReadOnly_,
6048
                                        isGrid: true,
6049
                                        fieldTarget: targetField_,
6050
                                        fieldValue: fieldValue_,
6051
                                        isGrid: true,
6052
                                        id: tableName + rec.FieldName,
6053
                                        tableName: rec.TableRef,
6054
                                        triggerCls: 'x-form-search-trigger',
6055
                                        vtype: 'alphanum',
6056
                                        nameTable: rec.TableName,
6057
                                        fieldGrid: rec.FieldName,
6058
                                        listeners: {
6059
                                            change: function (val) {
6060
                                                var custumFunc = rec.SelectFunction;
6061
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6062
                                                    Ext.Ajax.request({
6063
                                                        async: false,
6064
                                                        method: 'POST',
6065
                                                        url: '/UserControl/GetStore',
6066
                                                        params: {
6067
                                                            tableName: 'PCMFUNC',
6068
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6069
                                                        },
6070
                                                        success: function (response) {
6071
                                                            var results = Ext.decode(response.responseText);
6072
                                                            data_ = results.data[0];
6073
                                                            if (data_ != undefined) {
6074
                                                                custumFunc = data_.FunctionCode;
6075
                                                            }
6076
                                                        }
6077
                                                    });
6078
                                                }
6079
                                                if (custumFunc) {
6080
                                                    eval(custumFunc)
6081
                                                }
6082
                                            }
6083
                                        }
6084
                                    }
6085
                                });
6086
                            } else if (rec.SearchType == '3') {
6087
                                cols.push({
6088
                                    text: rec.HeaderTitle,
6089
                                    hidden: Hidden_,
6090
                                    dataIndex: rec.FieldName,
6091
                                    filter: {
6092
                                        itemDefaults: {
6093
                                            emptyText: 'Search for...'
6094
                                        }
6095
                                    },
6096
                                    editor: {
6097
                                        allowBlank: null_,
6098
                                        xtype: 'MinovaLookupTree',
6099
                                        readOnly: ReadOnly_,
6100
                                        id: tableName + rec.FieldName,
6101
                                        tableName: rec.TableRef,
6102
                                        triggerCls: 'x-form-search-trigger',
6103
                                        vtype: 'alphanum',
6104
                                        treeSructure: rec.SearchFunction,
6105
                                        objClassValue: rec.ParamCombo,
6106
                                        nameTable: rec.TableName,
6107
                                        fieldGrid: rec.FieldName,
6108
                                        listeners: {
6109
                                            change: function (val) {
6110
                                                var custumFunc = rec.SelectFunction;
6111
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6112
                                                    Ext.Ajax.request({
6113
                                                        async: false,
6114
                                                        method: 'POST',
6115
                                                        url: '/UserControl/GetStore',
6116
                                                        params: {
6117
                                                            tableName: 'PCMFUNC',
6118
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6119
                                                        },
6120
                                                        success: function (response) {
6121
                                                            var results = Ext.decode(response.responseText);
6122
                                                            data_ = results.data[0];
6123
                                                            if (data_ != undefined) {
6124
                                                                custumFunc = data_.FunctionCode;
6125
                                                            }
6126
                                                        }
6127
                                                    });
6128
                                                }
6129
                                                if (custumFunc) {
6130
                                                    eval(custumFunc)
6131
                                                }
6132
                                            }
6133
                                        }
6134
                                    }
6135
                                });
6136
                            } 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) {
6137
                                var triger = (rec.TriggerCombo).split('&');
6138
                                var targetField_ = triger[0];
6139
                                var fieldValue_ = triger[0];
6140
                                cols.push({
6141
                                    text: rec.HeaderTitle,
6142
                                    hidden: Hidden_,
6143
                                    dataIndex: rec.FieldName,
6144
                                    filter: {
6145
                                        itemDefaults: {
6146
                                            emptyText: 'Search for...'
6147
                                        }
6148
                                    },
6149
                                    editor: {
6150
                                        allowBlank: null_,
6151
                                        xtype: 'lookupemployee',
6152
                                        readOnly: ReadOnly_,
6153
                                        isGrid: true,
6154
                                        fieldTarget: targetField_,
6155
                                        fieldValue: fieldValue_,
6156
                                        isGrid: true,
6157
                                        id: tableName + rec.FieldName,
6158
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
6159
                                        triggerCls: 'x-form-search-trigger',
6160
                                        vtype: 'alphanum', // disable space
6161
                                        nameTable: rec.TableName,
6162
                                        fieldGrid: rec.FieldName,
6163
                                        listeners: {
6164
                                            change: function (val) {
6165
                                                var custumFunc = rec.SelectFunction;
6166
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6167
                                                    Ext.Ajax.request({
6168
                                                        async: false,
6169
                                                        method: 'POST',
6170
                                                        url: '/UserControl/GetStore',
6171
                                                        params: {
6172
                                                            tableName: 'PCMFUNC',
6173
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6174
                                                        },
6175
                                                        success: function (response) {
6176
                                                            var results = Ext.decode(response.responseText);
6177
                                                            data_ = results.data[0];
6178
                                                            if (data_ != undefined) {
6179
                                                                custumFunc = data_.FunctionCode;
6180
                                                            }
6181
                                                        }
6182
                                                    });
6183
                                                }
6184
                                                if (custumFunc) {
6185
                                                    eval(custumFunc)
6186
                                                }
6187
                                            }
6188
                                        }
6189
                                    }
6190
                                });
6191
                            } else if (rec.SearchType == '4' && isLookup != true) {
6192
                                cols.push({
6193
                                    text: rec.HeaderTitle,
6194
                                    hidden: Hidden_,
6195
                                    dataIndex: rec.FieldName,
6196
                                    filter: {
6197
                                        itemDefaults: {
6198
                                            emptyText: 'Search for...'
6199
                                        }
6200
                                    },
6201
                                    editor: {
6202
                                        allowBlank: null_,
6203
                                        xtype: 'lookupemployee',
6204
                                        readOnly: ReadOnly_,
6205
                                        isGrid: true,
6206
                                        fieldTarget: targetField_,
6207
                                        fieldValue: fieldValue_,
6208
                                        isGrid: true,
6209
                                        id: tableName + rec.FieldName,
6210
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
6211
                                        triggerCls: 'x-form-search-trigger',
6212
                                        vtype: 'alphanum', // disable space
6213
                                        nameTable: rec.TableName,
6214
                                        fieldGrid: rec.FieldName,
6215
                                        listeners: {
6216
                                            change: function (val) {
6217
                                                var custumFunc = rec.SelectFunction;
6218
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6219
                                                    Ext.Ajax.request({
6220
                                                        async: false,
6221
                                                        method: 'POST',
6222
                                                        url: '/UserControl/GetStore',
6223
                                                        params: {
6224
                                                            tableName: 'PCMFUNC',
6225
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6226
                                                        },
6227
                                                        success: function (response) {
6228
                                                            var results = Ext.decode(response.responseText);
6229
                                                            data_ = results.data[0];
6230
                                                            if (data_ != undefined) {
6231
                                                                custumFunc = data_.FunctionCode;
6232
                                                            }
6233
                                                        }
6234
                                                    });
6235
                                                }
6236
                                                if (custumFunc) {
6237
                                                    eval(custumFunc)
6238
                                                }
6239
                                            }
6240
                                        }
6241
                                    }
6242
                                });
6243
                            } else if (rec.FixedValue != '') { // add by taufan
6244
                                cols.push({
6245
                                    text: rec.HeaderTitle,
6246
                                    hidden: Hidden_,
6247
                                    dataIndex: rec.FieldName,
6248
                                    filter: {
6249
                                        itemDefaults: {
6250
                                            emptyText: 'Search for...'
6251
                                        }
6252
                                    },
6253
                                    editor: {
6254
                                        allowBlank: null_,
6255
                                        xtype: 'minovafixvalue',
6256
                                        readOnly: ReadOnly_,
6257
                                        id: rec.TableName + rec.FieldName,
6258
                                        name: rec.TableName + rec.FieldName,
6259
                                        nameTable: rec.TableName,
6260
                                        fieldGrid: rec.FieldName,
6261
                                        fixedValue: rec.FixedValue,
6262
                                        valueField: 'code',
6263
                                        displayField: 'desc',
6264
                                        value: rec.DefaultValue
6265
                                    },
6266
                                    renderer: function (value) {
6267
                                        var val = "";
6268
                                        var storeData = [];
6269
                                        var str = rec.FixedValue;
6270
                                        var hasil = str.split('||');
6271
                                        hasil.forEach(function (h) {
6272
                                            store_ = h.split('=')
6273
                                            storeData.push({
6274
                                                code: store_[0],
6275
                                                desc: store_[1]
6276
                                            });
6277
                                        });
6278
                                        var item = storeData.find(x => x.code == value);
6279
                                        if (item != undefined) {
6280
                                            val = item.desc;
6281
                                        }
6282
                                        return val;
6283
                                    }
6284
                                });
6285
                            } else {
6286
                                cols.push({
6287
                                    text: rec.HeaderTitle,
6288
                                    hidden: Hidden_,
6289
									cellWrap: true,
6290
                                    dataIndex: rec.FieldName,
6291
                                    filter: {
6292
                                        itemDefaults: {
6293
                                            emptyText: 'Search for...'
6294
                                        }
6295
                                    },
6296
                                    editor: {
6297
                                        allowBlank: null_,
6298
                                        xtype: 'textareafield',
6299
                                        readOnly: ReadOnly_,
6300
                                        id: tableName + rec.FieldName,
6301
                                        nameTable: rec.TableName,
6302
                                        fieldGrid: rec.FieldName,
6303
                                        value: rec.DefaultValue,
6304
										grow: true,
6305
										listeners: {
6306
                                           
6307
											change: function (val) {
6308
                                                var custumFunc = null;
6309
                                                Ext.Ajax.request({
6310
                                                    async: false,
6311
                                                    method: 'POST',
6312
                                                    url: '/UserControl/GetStore',
6313
                                                    params: {
6314
                                                        tableName: 'SDATATABLEFIELD',
6315
                                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
6316
                                                    },
6317
                                                    success: function (response) {
6318
                                                        var results = Ext.decode(response.responseText);
6319
                                                        data_ = results.data[0];
6320
                                                        if (data_ != undefined) {
6321
                                                            custumFunc = data_.SelectFunction;
6322
                                                            //console.log(data_)
6323
                                                        }
6324
                                                    }
6325
                                                });
6326

    
6327
                                                if (custumFunc) {
6328
                                                    eval(custumFunc)
6329
                                                }
6330
                                            }
6331
											}
6332
                                        },
6333
										 /*
6334
										renderer: function (v) {
6335
											result = v.replace(/\r\n\r\n/g, "</p><p>").replace(/\n\n/g, "</p><p>");
6336
											result = result.replace(/\r\n/g, "<br />").replace(/\n/g, "<br />");
6337
											return result
6338
										}*/	
6339
                                });
6340
                            }
6341
                            break
6342
                    }
6343
                } else {
6344
                    cols.push({
6345
                        text: rec.HeaderTitle,
6346
                        hidden: Hidden_,
6347
                        dataIndex: rec.FieldName,
6348
                        hidden: true,
6349
                        editor: {
6350
                            allowBlank: true,
6351
                            xtype: 'textfield',
6352
                            readOnly: ReadOnly_,
6353
                            id: tableName + rec.FieldName,
6354
                            nameTable: rec.TableName,
6355
                            fieldGrid: rec.FieldName,
6356
                            value: rec.DefaultValue
6357
                        },
6358
                        filter: {
6359
                            itemDefaults: {
6360
                                emptyText: 'Search for...'
6361
                            }
6362
                        }
6363
                    });
6364
                }
6365
            });
6366

    
6367
        };
6368
        addData = addData + "}";
6369
        Ext.applyIf(me, {
6370
            items: [{
6371
                xtype: 'grid',
6372
                id: gridName,
6373
                name: gridName,
6374
                height: height,
6375
                addFlag: true,
6376
                deleteFlag: true,
6377
                minHeight: me.minHeight,
6378
                maxHeight: me.maxHeight,
6379
                store: Ext.create('Ext.data.Store', {
6380
                    storeId: storeID,
6381
                    fields: fieldStore,
6382
					//groupField: 'QuestionGroup',
6383
					grouper: {
6384
						sortProperty: 'SeqQuest',
6385
						groupFn: function (record) {
6386
							return record.get('QuestionGroup');
6387
						}
6388
					},
6389
                    proxy: {
6390
                        method: 'POST',
6391
                        type: 'ajax',
6392
                        url: '',
6393
                        reader: {
6394
                            type: 'json',
6395
                            root: 'data'
6396
                        }
6397
                    }
6398
                }),
6399
                dockedItems: [{
6400
                    xtype: 'toolbar',
6401
                    items: [{
6402
                        text: 'Add',
6403
                        hidden: hide_,
6404
                        name: tableName + 'Add',
6405
                        iconCls: 'fa-plus-circle',
6406
                        style: 'font-family: FontAwesome',
6407
                        handler: function () {
6408
                            var grid = Ext.getCmp(gridName);
6409
                            if (grid.addFlag === true) {
6410
                                var store = Ext.StoreMgr.lookup(storeID)
6411
                                idx = store.getCount();
6412
                                var action = getParam('action');
6413
                                var data = '';
6414
                                var Sequence = 0;
6415
                                if (idx == 0) {
6416
                                    Sequence = 1;
6417
                                } else {
6418
                                    Sequence = 1 + idx;
6419
                                }
6420
                                var seq = 'Sequence';
6421
                                var SequenceValue = Sequence;
6422
                                eval(addData);
6423
                                data[seq] = SequenceValue;
6424
                                store.insert(idx, data);
6425
                            }
6426
                        }
6427
                    }, {
6428
                        text: 'Delete',
6429
                        hidden: hide_,
6430
                        name: tableName + 'DeleteText',
6431
                        iconCls: 'fa-trash-o',
6432
                        style: 'font-family: FontAwesome',
6433
                        handler: function () {
6434
                            var grid = Ext.getCmp(gridName);
6435
                            if (grid.deleteFlag === true) {
6436
                                var me = this,
6437
                                store = Ext.StoreMgr.lookup(storeID)
6438
                                var grid = Ext.getCmp(gridName);
6439
                                Ext.MessageBox.show({
6440
                                    title: 'Remove tab',
6441
                                    msg: "This will remove. Do you want to continue?",
6442
                                    buttons: Ext.MessageBox.YESNO,
6443
                                    fn: function (choice) {
6444
                                        console.log(choice);
6445
                                        if (choice === 'yes') {
6446
                                            var selection = grid.getView().getSelectionModel().getSelection()[0];
6447
                                            if (selection) {
6448
                                                store.remove(selection);
6449
                                            }
6450
                                        }
6451
                                    }
6452
                                });
6453
                            }
6454
                        }
6455
                    }
6456
                    ]
6457
                }
6458
                ],
6459
                columns: cols,
6460
				selModel: 'rowmodel', //YN
6461
                selType: checkSelection,
6462
                plugins: {
6463
                    ptype: 'rowediting',
6464
                    pluginId: 'rowEditing',
6465
                    clicksToEdit: 1,//0
6466
                    listeners: {}
6467
                },
6468
				features: features,
6469
				viewConfig: {
6470
					listeners: {
6471
						refresh: function (dataview) {
6472
							Ext.each(dataview.panel.columns, function (column) {
6473
								column.autoSize();
6474
							})
6475
						}
6476
					}
6477
				}
6478
            }
6479
            ]
6480
        });
6481
        me.callParent(arguments);
6482
    }
6483
});
6484
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowEditableGrid1', {
6485
    extend: 'Ext.form.Panel',
6486
    alias: ['widget.minovaworkfloweditablegrid1', 'widget.workfloweditablegrid1'],
6487
    requires: [
6488
		'Ext.grid.plugin.CellEditing',
6489
		'Ext.grid.Panel',
6490
    ],
6491
    anchor: '100%',
6492
    tableName: undefined,
6493
    hideButton: undefined,
6494
    multiSelect: undefined,
6495
    formname: this.name,
6496
    bizprocid: undefined,
6497
    bizflowid: undefined,
6498
    taskid: undefined,
6499
    initComponent: function () {
6500
        var me = this;
6501
        var hide_ = false;
6502
        var widthLock = 250;
6503
        var checkSelection = '';
6504

    
6505
        if (me.hideButton == true) {
6506
            hide_ = true;
6507
        }
6508
        if (me.multiSelect) {
6509
            locking = false;
6510
            checkSelection = 'checkboxmodel';
6511
            widthLock = 40;
6512
        }
6513
        var tableName = me.tableName;
6514
        var cols = [];
6515
        var fieldStore = [];
6516
        var _url = 'GetAllField';
6517
        var hasil = null;
6518
        var height = me.height;
6519
        var storeID = 'store' + me.tableName;
6520
        var gridName = 'grid' + me.name;
6521
        if (me.storeName) {
6522
            storeID = me.storeName;
6523
        }
6524
        var LangID = MinovaUtil.GetLangID();
6525
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
6526
        Ext.Ajax.request({
6527
            async: false,
6528
            method: 'POST',
6529
            url: '/UserControl/GetStore',
6530
            params: {
6531
                tableName: 'PDSWFSTRUCTUREFIELD',
6532
                param: parameter
6533
            },
6534
            success: function (response) {
6535
                var results = Ext.decode(response.responseText);
6536
                hasil = results.data;
6537
            }
6538
        });
6539
        if (hasil.length > 0) {
6540
            Ext.each(hasil, function (rec) {
6541
                fieldStore.push(rec.FieldName)
6542
                var readonly = false;
6543
                var ishidden = false;
6544
                var allowblank = true;
6545
                if (rec.IsReadOnly == '1') {
6546
                    readonly = true;
6547
                }
6548
                if (rec.IsRequired == '1') {
6549
                    allowblank = false;
6550
                }
6551
                if (rec.IsVisible == '1') {
6552
                    switch (rec.FormatRef) {
6553
                        case "date":
6554
                            cols.push({
6555
                                xtype: 'minovadatecolumn',
6556
                                text: rec.HeaderTitle,
6557
                                dataIndex: rec.FieldName,
6558
                                editor: {
6559
                                    allowBlank: allowblank,
6560
                                    xtype: 'datefield',
6561
                                    hideMode: 'visibility',
6562
                                    readOnly: readonly,
6563
                                    name: 'grid' + tableName + rec.FieldName,
6564
                                    id: 'grid' + tableName + rec.FieldName,
6565
                                    value: rec.DefaultValue,
6566
                                    formname: me.formname,
6567
                                    listeners: {
6568
                                        change: function (val) {
6569
                                            var _label = val.name;
6570
                                            var _form = val.formname;
6571
                                            var _Value = val.getValue();
6572
                                            var target = rec.TriggerCombo;
6573
                                            var custumFunc = rec.SelectFunction;
6574
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6575
                                                Ext.Ajax.request({
6576
                                                    async: false,
6577
                                                    method: 'POST',
6578
                                                    url: '/UserControl/GetStore',
6579
                                                    params: {
6580
                                                        tableName: 'PCMFUNC',
6581
                                                        param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
6582
                                                    },
6583
                                                    success: function (response) {
6584
                                                        var results = Ext.decode(response.responseText);
6585
                                                        data_ = results.data[0];
6586
                                                        if (data_ != undefined) {
6587
                                                            custumFunc = data_.FunctionCode;
6588
                                                        }
6589
                                                    }
6590
                                                });
6591
                                            }
6592
                                            var frm = Ext.ComponentQuery.query('[name=' + _form + ']')[0];
6593
                                            if (frm) {
6594
                                                if (custumFunc) {
6595
                                                    eval(custumFunc)
6596
                                                }
6597
                                            }
6598
                                        }
6599
                                    }
6600
                                }
6601
                            });
6602
                            break;
6603
                        case "amount":
6604
                            cols.push({
6605
                                xtype: 'minovacurrancycolumn',
6606
                                align: 'right',
6607
                                text: rec.HeaderTitle,
6608
                                dataIndex: rec.FieldName,
6609
                                editor: {
6610
                                    allowBlank: allowblank,
6611
                                    xtype: 'textfield',
6612
                                    readOnly: readonly,
6613
                                    name: 'grid' + tableName + rec.FieldName,
6614
                                    id: 'grid' + tableName + rec.FieldName,
6615
                                    value: rec.DefaultValue
6616
                                }
6617
                            });
6618
                            break;
6619
                        case "time":
6620
                            cols.push({
6621
                                text: rec.HeaderTitle,
6622
                                dataIndex: rec.FieldName,
6623
                                editor: {
6624
                                    allowBlank: allowblank,
6625
                                    xtype: 'timefield',
6626
                                    readOnly: readonly,
6627
                                    name: 'grid' + tableName + rec.FieldName,
6628
                                    id: 'grid' + tableName + rec.FieldName,
6629
                                    msgTarget: 'side',
6630
                                    format: 'Hi',
6631
                                    submitFormat: 'Hi',
6632
                                    increment: 5,
6633
                                    value: rec.DefaultValue,
6634
                                    formname: me.formname,
6635
                                    listeners: {
6636
                                        change: function (val) {
6637
                                            var _label = val.name;
6638
                                            var _form = val.formname;
6639
                                            var _Value = val.getValue();
6640
                                            var target = rec.TriggerCombo;
6641
                                            var custumFunc = rec.SelectFunction;
6642
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6643
                                                Ext.Ajax.request({
6644
                                                    async: false,
6645
                                                    method: 'POST',
6646
                                                    url: '/UserControl/GetStore',
6647
                                                    params: {
6648
                                                        tableName: 'PCMFUNC',
6649
                                                        param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
6650
                                                    },
6651
                                                    success: function (response) {
6652
                                                        var results = Ext.decode(response.responseText);
6653
                                                        data_ = results.data[0];
6654
                                                        if (data_ != undefined) {
6655
                                                            custumFunc = data_.FunctionCode;
6656
                                                        }
6657
                                                    }
6658
                                                });
6659
                                            }
6660
                                            var frm = Ext.ComponentQuery.query('[name=' + _form + ']')[0];
6661
                                            if (frm) {
6662
                                                if (custumFunc) {
6663
                                                    eval(custumFunc)
6664
                                                }
6665
                                            }
6666
                                        }
6667
                                    }
6668
                                }
6669
                            });
6670
                            break;
6671
                        default:
6672
                            if (rec.SearchType != "") {
6673
                                if (rec.SearchType == "0") {
6674
                                    var valueField = null;
6675
                                    var displayValue = null;
6676
                                    var TableRef = undefined;
6677
                                    if (rec.TableRef != '') {
6678
                                        TableRef = rec.TableRef;
6679
                                        Ext.Ajax.request({
6680
                                            async: false,
6681
                                            method: 'POST',
6682
                                            url: '/UserControl/GetStore',
6683
                                            params: {
6684
                                                tableName: 'SDATATABLEFIELD',
6685
                                                param: 'TableName[equal]' + rec.TableRef
6686
                                            },
6687
                                            success: function (response) {
6688
                                                var results = Ext.decode(response.responseText);
6689
                                                data_ = results.data;
6690
                                                if (data_ != undefined) {
6691
                                                    valueField_ = $.grep(data_, function (r) {
6692
                                                        return r.ValueField == '1'
6693
                                                    });
6694
                                                    valueField = valueField_[0].FieldName
6695
                                                    displayValue_ = $.grep(data_, function (r) {
6696
                                                        return r.DisplayValue == '1'
6697
                                                    });
6698
                                                    displayValue = displayValue_[0].FieldName
6699
                                                }
6700
                                            }
6701
                                        });
6702
                                    }
6703
                                    //create Store
6704
                                    Ext.create('Ext.data.Store', {
6705
                                        storeId: 'store_' + me.tableName + rec.FieldName,
6706
                                        autoLoad: true,
6707
                                        proxy: {
6708
                                            method: 'POST',
6709
                                            type: 'ajax',
6710
                                            url: '/UserControl/GetStore',
6711
                                            extraParams: {
6712
                                                tableName: TableRef,
6713
                                                param: rec.ParamCombo
6714
                                            },
6715
                                            reader: {
6716
                                                type: 'json',
6717
                                                root: 'data',
6718
                                                totalProperty: 'data[0].TotalCount'
6719
                                            }
6720
                                        }
6721
                                    });
6722
                                    cols.push({
6723
                                        xtype: 'minovacombocolumn',
6724
                                        text: rec.HeaderTitle,
6725
                                        dataIndex: rec.FieldName,
6726
                                        valueField: valueField,
6727
                                        displayField: displayValue,
6728
                                        store: 'store_' + me.tableName + rec.FieldName,
6729
                                        editor: {
6730
                                            allowBlank: allowblank,
6731
                                            xtype: 'combobox',
6732
                                            readOnly: readonly,
6733
                                            name: 'grid' + tableName + rec.FieldName,
6734
                                            id: 'grid' + tableName + rec.FieldName,
6735
                                            valueField: valueField,
6736
                                            displayField: displayValue,
6737
                                            store: 'store_' + me.tableName + rec.FieldName,
6738
                                            value: rec.DefaultValue,
6739
                                            formname: me.formname,
6740
                                            listeners: {
6741
                                                change: function (val) {
6742
                                                    var _label = val.name;
6743
                                                    var _form = val.formname;
6744
                                                    var _Value = val.getValue();
6745
                                                    var target = rec.TriggerCombo;
6746
                                                    var custumFunc = rec.SelectFunction;
6747
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6748
                                                        Ext.Ajax.request({
6749
                                                            async: false,
6750
                                                            method: 'POST',
6751
                                                            url: '/UserControl/GetStore',
6752
                                                            params: {
6753
                                                                tableName: 'PCMFUNC',
6754
                                                                param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
6755
                                                            },
6756
                                                            success: function (response) {
6757
                                                                var results = Ext.decode(response.responseText);
6758
                                                                data_ = results.data[0];
6759
                                                                if (data_ != undefined) {
6760
                                                                    custumFunc = data_.FunctionCode;
6761
                                                                }
6762
                                                            }
6763
                                                        });
6764
                                                    }
6765
                                                    var frm = Ext.ComponentQuery.query('[name=' + _form + ']')[0];
6766
                                                    if (frm) {
6767
                                                        if (custumFunc) {
6768
                                                            eval(custumFunc)
6769
                                                        }
6770
                                                    }
6771
                                                }
6772
                                            }
6773
                                        }
6774
                                    });
6775
                                } else if (rec.SearchType == "2") {
6776
                                    cols.push({
6777
                                        text: rec.HeaderTitle,
6778
                                        dataIndex: rec.FieldName,
6779
                                        editor: {
6780
                                            xtype: 'minovalookupgrid',
6781
                                            allowBlank: allowblank,
6782
                                            readOnly: readonly,
6783
                                            msgTarget: 'side',
6784
                                            labelCls: 'label-minova',
6785
                                            labelWidth: 150,
6786
                                            name: 'grid' + tableName + rec.FieldName,
6787
                                            id: 'grid' + tableName + rec.FieldName,
6788
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
6789
                                            triggerCls: 'x-form-search-trigger',
6790
                                            vtype: 'alphanum', // disable space
6791
                                            formtarget: me.formname, // nama form  yang akan di set value-nya
6792
                                            anchor: '100%',
6793
                                            formname: me.formname,
6794
                                            listeners: {
6795
                                                change: function (val) {
6796
                                                    var _label = val.name;
6797
                                                    var _form = val.formname;
6798
                                                    var _Value = val.getValue();
6799
                                                    var target = rec.TriggerCombo;
6800
                                                    var custumFunc = rec.SelectFunction;
6801
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6802
                                                        Ext.Ajax.request({
6803
                                                            async: false,
6804
                                                            method: 'POST',
6805
                                                            url: '/UserControl/GetStore',
6806
                                                            params: {
6807
                                                                tableName: 'PCMFUNC',
6808
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6809
                                                            },
6810
                                                            success: function (response) {
6811
                                                                var results = Ext.decode(response.responseText);
6812
                                                                data_ = results.data[0];
6813
                                                                if (data_ != undefined) {
6814
                                                                    custumFunc = data_.FunctionCode;
6815
                                                                }
6816
                                                            }
6817
                                                        });
6818
                                                    }
6819
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
6820
                                                    if (frm) {
6821
                                                        if (target) {
6822
                                                            var f = frm.getForm().findField(target)
6823
                                                            _store = f.getStore();
6824
                                                            var _tbl = _store.proxy.extraParams.tableName;
6825
                                                            var oldParam = _store.proxy.extraParams.param;
6826
                                                            _store.proxy.extraParams = {
6827
                                                                tableName: _tbl,
6828
                                                                param: _label + '[=]' + _Value
6829
                                                            };
6830
                                                            _store.load();
6831
                                                        }
6832
                                                        if (custumFunc) {
6833
                                                            eval(custumFunc)
6834
                                                        }
6835

    
6836
                                                    }
6837

    
6838
                                                },
6839

    
6840
                                            }
6841
                                        }
6842
                                    });
6843
                                } else if (rec.SearchType == "3") {
6844
                                    cols.push({
6845
                                        text: rec.HeaderTitle,
6846
                                        dataIndex: rec.FieldName,
6847
                                        editor: {
6848
                                            xtype: 'minovalookuptree',
6849
                                            allowBlank: allowblank,
6850
                                            fieldLabel: rec.ScreenCaption,
6851
                                            readOnly: readonly,
6852
                                            labelCls: 'label-minova',
6853
                                            labelWidth: 150,
6854
                                            name: 'grid' + tableName + rec.FieldName,
6855
                                            id: 'grid' + tableName + rec.FieldName,
6856
                                            msgTarget: 'side',
6857
                                            triggerCls: 'x-form-search-trigger',
6858
                                            treeSructure: rec.SearchFunction, //'O-O-P',
6859
                                            objClassValue: rec.ParamCombo, //'O',
6860
                                            formname: me.formname,
6861
                                            targetField: rec.FieldName,
6862
                                            anchor: '100%',
6863
                                            listeners: {
6864
                                                change: function (val) {
6865
                                                    var _label = val.name;
6866
                                                    var _form = val.formname;
6867
                                                    var _Value = val.getValue();
6868
                                                    var target = rec.TriggerCombo;
6869
                                                    var custumFunc = rec.SelectFunction;
6870
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6871
                                                        Ext.Ajax.request({
6872
                                                            async: false,
6873
                                                            method: 'POST',
6874
                                                            url: '/UserControl/GetStore',
6875
                                                            params: {
6876
                                                                tableName: 'PCMFUNC',
6877
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6878
                                                            },
6879
                                                            success: function (response) {
6880
                                                                var results = Ext.decode(response.responseText);
6881
                                                                data_ = results.data[0];
6882
                                                                if (data_ != undefined) {
6883
                                                                    custumFunc = data_.FunctionCode;
6884
                                                                }
6885
                                                            }
6886
                                                        });
6887
                                                    }
6888
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
6889
                                                    if (frm) {
6890

    
6891
                                                        if (target) {
6892
                                                            var f = frm.getForm().findField(target)
6893
                                                            _store = f.getStore();
6894
                                                            var _tbl = _store.proxy.extraParams.tableName;
6895
                                                            var oldParam = _store.proxy.extraParams.param;
6896
                                                            _store.proxy.extraParams = {
6897
                                                                tableName: _tbl,
6898
                                                                param: _label + '[=]' + _Value
6899
                                                            };
6900
                                                            _store.load();
6901
                                                        }
6902
                                                        if (custumFunc) {
6903
                                                            eval(custumFunc)
6904
                                                        }
6905
                                                    }
6906
                                                }
6907
                                            }
6908
                                        }
6909
                                    });
6910
                                } else if (rec.SearchType == "4") {
6911
                                    cols.push({
6912
                                        text: rec.HeaderTitle,
6913
                                        dataIndex: rec.FieldName,
6914
                                        editor: {
6915
                                            xtype: 'lookupemployee',
6916
                                            allowBlank: allowblank,
6917
                                            fieldLabel: rec.ScreenCaption,
6918
                                            readOnly: readonly,
6919
                                            labelCls: 'label-minova',
6920
                                            name: 'grid' + tableName + rec.FieldName,
6921
                                            id: 'grid' + tableName + rec.FieldName,
6922
                                            msgTarget: 'side',
6923
                                            fieldname: rec.FieldName,
6924
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
6925
                                            triggerCls: 'x-form-search-trigger',
6926
                                            vtype: 'alphanum', // disable space
6927
                                            formtarget: formname, // nama form  yang akan di set value-nya
6928
                                            isLookup: isLookup,
6929
                                            anchor: '100%',
6930
                                            formname: formname,
6931
                                            listeners: {
6932
                                                change: function (val) {
6933
                                                    var _label = val.name;
6934
                                                    var _form = val.formname;
6935
                                                    var _Value = val.getValue();
6936
                                                    var target = rec.TriggerCombo;
6937
                                                    var custumFunc = rec.SelectFunction;
6938
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6939
                                                        Ext.Ajax.request({
6940
                                                            async: false,
6941
                                                            method: 'POST',
6942
                                                            url: '/UserControl/GetStore',
6943
                                                            params: {
6944
                                                                tableName: 'PCMFUNC',
6945
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6946
                                                            },
6947
                                                            success: function (response) {
6948
                                                                var results = Ext.decode(response.responseText);
6949
                                                                data_ = results.data[0];
6950
                                                                if (data_ != undefined) {
6951
                                                                    custumFunc = data_.FunctionCode;
6952
                                                                }
6953
                                                            }
6954
                                                        });
6955
                                                    }
6956
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
6957
                                                    if (frm) {
6958

    
6959
                                                        if (target) {
6960
                                                            var f = frm.getForm().findField(target)
6961
                                                            _store = f.getStore();
6962
                                                            var _tbl = _store.proxy.extraParams.tableName;
6963
                                                            var oldParam = _store.proxy.extraParams.param;
6964
                                                            _store.proxy.extraParams = {
6965
                                                                tableName: _tbl,
6966
                                                                param: _label + '[=]' + _Value
6967
                                                            };
6968
                                                            _store.load();
6969
                                                        }
6970
                                                        if (custumFunc) {
6971
                                                            eval(custumFunc)
6972
                                                        }
6973

    
6974
                                                    }
6975

    
6976
                                                },
6977

    
6978
                                            },
6979
                                        }
6980
                                    });
6981
                                }
6982
                            } else {
6983
                                if (rec.FixedValue != "") {
6984
                                    var storeData = [];
6985
                                    var str = rec.FixedValue;
6986
                                    var hasil = str.split('||');
6987
                                    hasil.forEach(function (h) {
6988
                                        store_ = h.split('=')
6989
                                        storeData.push({
6990
                                            code: store_[0],
6991
                                            desc: store_[1],
6992
                                        });
6993
                                    });
6994
                                    cols.push({
6995
                                        xtype: 'minovacombocolumn',
6996
                                        text: rec.HeaderTitle,
6997
                                        dataIndex: rec.FieldName,
6998
                                        valueField: valueField,
6999
                                        displayField: displayValue,
7000
                                        store: Ext.create('Ext.data.Store', {
7001
                                            storeId: 'store' + rec.FieldName,
7002
                                            autoLoad: true,
7003
                                            data: storeData
7004

    
7005
                                        }),
7006
                                        editor: {
7007
                                            xtype: 'combobox',
7008
                                            allowBlank: allowblank,
7009
                                            forceSelection: true,
7010
                                            readOnly: readonly,
7011
                                            labelCls: 'label-minova',
7012
                                            labelWidth: 150,
7013
                                            name: 'grid' + tableName + rec.FieldName,
7014
                                            id: 'grid' + tableName + rec.FieldName,
7015
                                            msgTarget: 'side',
7016
                                            value: rec.DefaultValue,
7017
                                            anchor: '100%',
7018
                                            formname: me.formname,
7019
                                            formtarget: me.formname,
7020
                                            store: Ext.create('Ext.data.Store', {
7021
                                                storeId: 'store' + rec.FieldName,
7022
                                                autoLoad: true,
7023
                                                data: storeData
7024

    
7025
                                            }),
7026
                                            listeners: {
7027
                                                change: function (val) {
7028
                                                    var _label = val.name;
7029
                                                    var _form = val.formtarget;
7030
                                                    var _Value = val.getValue();
7031
                                                    var target = rec.TriggerCombo;
7032
                                                    var custumFunc = rec.SelectFunction;
7033
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
7034
                                                    if (frm) {
7035
                                                        if (target) {
7036
                                                            var f = frm.getForm().findField(target)
7037
                                                            _store = f.getStore();
7038
                                                            var _tbl = _store.proxy.extraParams.tableName;
7039
                                                            var oldParam = _store.proxy.extraParams.param;
7040
                                                            _store.proxy.extraParams = {
7041
                                                                tableName: _tbl,
7042
                                                                param: _label + '[=]' + _Value
7043
                                                            };
7044
                                                            _store.load();
7045
                                                        }
7046
                                                        if (custumFunc) {
7047
                                                            eval(custumFunc)
7048
                                                        }
7049
                                                    }
7050
                                                }
7051
                                            },
7052
                                            queryMode: 'local',
7053
                                            valueField: 'code',
7054
                                            displayField: 'desc',
7055
                                        }
7056
                                    })
7057
                                } else {
7058
                                    cols.push({
7059
                                        text: rec.HeaderTitle,
7060
                                        dataIndex: rec.FieldName,
7061
                                        editor: {
7062
                                            allowBlank: allowblank,
7063
                                            xtype: 'textfield',
7064
                                            readOnly: readonly,
7065
                                            name: 'grid' + tableName + rec.FieldName,
7066
                                            id: 'grid' + tableName + rec.FieldName,
7067
                                            value: rec.DefaultValue
7068
                                        }
7069
                                    });
7070
                                }
7071
                            }
7072
                            break;
7073
                    }
7074
                } else {
7075
                    cols.push({
7076
                        text: rec.HeaderTitle,
7077
                        dataIndex: rec.FieldName,
7078
                        hidden: true,
7079
                        editor: {
7080
                            allowBlank: true,
7081
                            xtype: 'textfield',
7082
                            readOnly: false,
7083
                            name: 'grid' + tableName + rec.FieldName,
7084
                            id: 'grid' + tableName + rec.FieldName,
7085
                        }
7086
                    });
7087
                }
7088
            });
7089
        };
7090

    
7091
        this.editing = Ext.create('Ext.grid.plugin.CellEditing');
7092
        Ext.applyIf(me, {
7093
            items: [{
7094
                xtype: 'grid',
7095
                id: gridName,
7096
                name: gridName,
7097
                height: height,
7098
                store: Ext.create('Ext.data.Store', {
7099
                    storeId: storeID,
7100
                    fields: fieldStore,
7101
                    proxy: {
7102
                        method: 'POST',
7103
                        type: 'ajax',
7104
                        url: '',
7105
                        reader: {
7106
                            type: 'json',
7107
                            root: 'data'
7108
                        }
7109
                    }
7110
                }),
7111
                dockedItems: [{
7112
                    xtype: 'toolbar',
7113
                    items: [{
7114
                        text: 'Add',
7115
                        hidden: hide_,
7116
                        name: tableName + 'Add',
7117
                        iconCls: 'fa-plus-circle',
7118
                        style: 'font-family: FontAwesome',
7119
                        handler: function () {
7120
                            var store = Ext.StoreMgr.lookup(storeID)
7121
                            idx = store.getCount();
7122
                            var action = getParam('action');
7123
                            var data = '';
7124
                            var Sequence = 0;
7125
                            if (idx == 0) {
7126
                                Sequence = 1;
7127
                            } else {
7128
                                Sequence = 1 + idx;
7129
                            }
7130
                            data = {
7131
                                Sequence: Sequence
7132
                            };
7133
                            store.insert(idx, data);
7134
                        }
7135
                    }, {
7136
                        text: 'Delete',
7137
                        hidden: hide_,
7138
                        name: tableName + 'DeleteText',
7139
                        iconCls: 'fa-trash-o',
7140
                        style: 'font-family: FontAwesome',
7141
                        handler: function () {
7142
                            var me = this,
7143
                            store = Ext.StoreMgr.lookup(storeID);
7144
                            var grid = Ext.getCmp(gridName);
7145
                            Ext.MessageBox.show({
7146
                                title: 'Remove tab',
7147
                                msg: "This will remove. Do you want to continue?",
7148
                                buttons: Ext.MessageBox.YESNO,
7149
                                fn: function (choice) {
7150
                                    console.log(choice);
7151
                                    if (choice === 'yes') {
7152
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
7153
                                        if (selection) {
7154
                                            store.remove(selection);
7155
                                        }
7156
                                    }
7157
                                }
7158
                            });
7159
                        }
7160
                    }
7161
                    ]
7162
                }
7163
                ],
7164
                columns: cols,
7165
                selType: checkSelection,
7166
                plugins: [this.editing],
7167
                // plugins: {
7168
                // ptype: 'rowediting',
7169
                // pluginId: 'rowEditing',
7170
                // clicksToEdit: 0,
7171
                // listeners: {
7172
                // }
7173
                // }
7174
            }
7175
            ]
7176
        });
7177
        me.callParent(arguments);
7178
    }
7179
});
7180
Ext.define('MinovaUtil.MinovaES.MinovaForm', {
7181
    extend: 'Ext.form.Panel',
7182
    alias: ['widget.minovaForm', 'widget.minovaform'],
7183
    tableName: undefined,
7184
    param: undefined,
7185
    titleform: undefined,
7186
    formname: this.name,
7187
    isLookup: undefined,
7188
    hidebutton: undefined,
7189
    //frame: true,
7190
    resizable: true,
7191
    border: false,
7192
    autoScroll: true,
7193
    minHeight: 20,
7194
    layout: 'column',
7195
    submitproc: undefined, //true if stil edit ,add
7196
    actionsubmit: undefined,
7197
    iseditform: undefined,
7198
    isFormReadOnly: undefined, // true== form di read only default false
7199
    isDisplay: undefined, // true if display only and false or undefined or empety if form can be edit
7200
    searchcustomization: undefined,
7201
    getIsFormReadOnly: function () {
7202
        return this.isFormReadOnly;
7203
    },
7204
    setIsFormReadOnly: function (value) {
7205
        var me = this;
7206
        me.isFormReadOnly = value;
7207
        return me;
7208
    },
7209
    getIsEditform: function () {
7210
        return this.iseditform;
7211
    },
7212
    setIsEditform: function (value) {
7213
        var me = this;
7214
        me.iseditform = value;
7215
        return me;
7216
    },
7217
    getActionSubmit: function () {
7218
        return this.actionsubmit;
7219
    },
7220
    setActionSubmit: function (value) {
7221
        var me = this;
7222
        me.actionsubmit = value;
7223
        return me;
7224
    },
7225
    getSubmitProc: function () {
7226
        return this.submitnproc;
7227
    },
7228
    setSubmitProc: function (value) {
7229
        var me = this;
7230
        me.submitnproc = value;
7231
        return me;
7232
    },
7233
    listeners: {
7234
        render: function () {
7235
            if (this.isLookup == 1 || this.isLookup == 'Y' || this.hidebutton == 1 || this.hidebutton == 'Y') {
7236
                var v = Ext.ComponentQuery.query('[name=formLookupFilter]')[0];
7237
                if (v) {
7238
                    v.setMaxHeight(200);
7239
                }
7240

    
7241
            }
7242
            if (this.titleform != undefined) {
7243
                this.setTitle(this.titleform);
7244
            }
7245
        },
7246

    
7247
    },
7248
    defaults: {
7249
        layout: 'form',
7250
        xtype: 'container',
7251
        defaultType: 'textfield',
7252
        style: 'width: 50%',
7253
        //height: 1000
7254
    },
7255
    initComponent: function () {
7256
        var col1 = [];
7257
        var col2 = [];
7258
        var me = this;
7259
        LangID = localStorage.LangId;
7260
        isLookup = me.isLookup;
7261
        //var _url = 'GetAllField';
7262

    
7263
        if (isLookup == 1 || isLookup == true || isLookup == 'Y') {}
7264
        isDisplay = me.isDisplay;
7265
        var hasil = null;
7266
        //hamid 200916
7267
        //Ext.Ajax.request({
7268
        //	async : false,
7269
        //	method : 'POST',
7270
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
7271
        //	success : function (response) {
7272
        //		var results = Ext.decode(response.responseText);
7273
        //		hasil = results.data;
7274
        //	}
7275
        //});
7276
        //end
7277

    
7278

    
7279
        //hamid
7280
        //if (me.isLookup == 1 || isLookup == true || isLookup == 'Y') {
7281
        parameter = null;
7282
        if (me.isLookup == true || isLookup == 1 || isLookup == 'Y') {
7283
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupFilter='1'"
7284
        } else if (me.searchcustomization == true) {
7285
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',IsCustomizationFilter='1'"
7286
        } else {
7287
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
7288
        }
7289
        Ext.Ajax.request({
7290
            async: false,
7291
            method: 'POST',
7292
            url: '/UserControl/GetStore',
7293
            params: {
7294
                tableName: 'PDSBS0007',
7295
                param: parameter
7296
            },
7297
            success: function (response) {
7298
                var results = Ext.decode(response.responseText);
7299
                hasil = results.data;
7300
            }
7301
        });
7302
        //end
7303
        if (hasil.length > 0) {
7304
            // hasil = hasil.sort(MinovaUtil.SortBy("Sequence"))
7305
            var me = this;
7306
            Ext.each(hasil, function (rec) {
7307
                var null_ = null;
7308
                if (rec.IsPrimaryKey == true) {
7309
                    null_ = false;
7310
                }
7311
                if (rec.IsRequired == true) {
7312
                    null_ = false;
7313
                } else {
7314
                    null_ = true;
7315
                }
7316
                var formfield = MinovaUtil.FieldGenerator.Form(me.name, rec, null_, isDisplay, me.tableName, me.isLookup);
7317
                var descField = undefined;
7318
                //if (isDisplay == true && rec.SearchType !='') {
7319
                //    descField = new Ext.form.Display({
7320
                //        fieldCode:'codeDisplay'+rec.name+rec.tableName,
7321
                //        allowBlank: true,
7322
                //        fieldLabel: 'Desc ' + rec.ScreenCaption,
7323
                //        readOnly: true,
7324
                //        maxLength: rec.Length,
7325
                //        anchor: '100%',
7326
                //        submitValue: false
7327
                //    });
7328
                //}
7329
                //else {
7330
                //    if (rec.SearchType == '2') {// lookup
7331
                //        descField = new Ext.form.TextField({
7332
                //            fieldCode: 'codeEdit' + rec.name + rec.tableName,
7333
                //            allowBlank: true,
7334
                //            fieldLabel: 'Desc ' + rec.ScreenCaption,
7335
                //            readOnly: true,
7336
                //            maxLength: rec.Length,
7337
                //            anchor: '100%',
7338
                //            submitValue: false
7339
                //        });
7340
                //    }
7341
                //    if (rec.SearchType == '3') {// tree
7342
                //        descField = new Ext.form.TextField({
7343
                //            fieldCode: 'codeEdit' + rec.name + rec.tableName,
7344
                //            allowBlank: true,
7345
                //            fieldLabel: 'Desc ' + rec.ScreenCaption,
7346
                //            readOnly: true,
7347
                //            maxLength: rec.Length,
7348
                //            anchor: '100%',
7349
                //            submitValue: false
7350
                //        });
7351
                //    }
7352
                //    if (rec.SearchType == '4' && me.isLookup != true) {
7353
                //        descField = new Ext.form.TextField({
7354
                //            fieldCode: 'codeEdit' + rec.name + rec.tableName,
7355
                //            allowBlank: true,
7356
                //            fieldLabel: 'Full Name',
7357
                //            readOnly: true,
7358
                //            maxLength: rec.Length,
7359
                //            anchor: '100%',
7360
                //            submitValue: false
7361
                //        });
7362
                //    }
7363

    
7364
                //}
7365

    
7366
                if (me.isLookup == true || isLookup == 1 || isLookup == 'Y') {
7367
                    col1.push(formfield);
7368
                    if (descField) {
7369
                        col1.push(descField)
7370
                    }
7371
                } else {
7372
                    if (isDesk) {
7373
                        if (rec.ColumnNo == 1) {
7374
                            col1.push(formfield);
7375
                            if (descField) {
7376
                                col1.push(descField)
7377
                            }
7378
                        } else {
7379
                            col2.push(formfield);
7380
                            if (descField) {
7381
                                col2.push(descField)
7382
                            }
7383
                        }
7384
                    } else {
7385
                        col1.push(formfield);
7386
                        if (descField) {
7387
                            col1.push(descField)
7388
                        }
7389
                    }
7390

    
7391
                }
7392

    
7393
                if (rec.IsPrimaryKey == 1 && me.isLookup == undefined) {
7394
                    formfieldKey = new Ext.form.TextField({
7395
                        hidden: true,
7396
                        name: "Key_" + rec.FieldName,
7397
                    });
7398
                    col2.push(formfieldKey);
7399
                }
7400

    
7401
            });
7402
            //console.log(col1);
7403
        }
7404
        Ext.applyIf(me, {
7405
            items: [{
7406
                //width: 450,
7407
                style: 'width: 50%',
7408
                items: col1
7409
            }, {
7410
                //width: 450,
7411
                style: 'width: 50%',
7412
                items: col2
7413
            }
7414
            ],
7415
        });
7416
        this.callParent();
7417
    }
7418
});
7419

    
7420
Ext.define('MinovaUtil.MinovaES.MinovaGridForm', {
7421
    extend: 'Ext.form.Panel',
7422
    alias: ['widget.minovagridform', 'widget.MinovaGridForm'],
7423
    tableName: undefined, //nama tabel
7424
    param: undefined, //param query
7425
    pagesize: undefined,
7426
    storename: undefined,
7427
    titleform: undefined,
7428
    titlegrid: undefined,
7429
    heightgrid: undefined,
7430
    heightform: undefined,
7431
    iseditform: undefined,
7432
    lastheightform: undefined,
7433
    layoutType: undefined,
7434
    lastpage: undefined,
7435
    lastTitle: undefined,
7436
    getLastTitle: function () {
7437
        return this.lastTitle;
7438
    },
7439
    setLastTitle: function (value) {
7440
        var me = this;
7441
        me.lastTitle = value;
7442
        return me;
7443
    },
7444
    getLastpage: function () {
7445
        return this.lastpage;
7446
    },
7447
    setLastpage: function (value) {
7448
        var me = this;
7449
        me.lastpage = value;
7450
        return me;
7451
    },
7452
    getLayoutType: function () {
7453
        return this.layoutType;
7454
    },
7455
    setLayoutType: function (value) {
7456
        var me = this;
7457
        me.layoutType = value;
7458
        return me;
7459
    },
7460
    getLastheightform: function () {
7461
        return this.lastheightform;
7462
    },
7463
    setLastheightform: function (value) {
7464
        var me = this;
7465
        me.lastheightform = value;
7466
        return me;
7467
    },
7468

    
7469
    getIsEditform: function () {
7470
        return this.iseditform;
7471
    },
7472
    setIsEditform: function (value) {
7473
        var me = this;
7474
        me.iseditform = value;
7475
        return me;
7476
    },
7477
    initComponent: function () {
7478
        var me = this;
7479
        var storename = me.storename;
7480
        if (storename == "" || storename == undefined) {
7481
            storename = "store" + me.tableName;
7482
        }
7483
        var tableName = me.tableName;
7484
        Ext.applyIf(me, {
7485
            items: [{
7486
                layoutType: "MinovaGridForm",
7487
                title: me.titlegrid,
7488
                xtype: "minovagrid",
7489
                tableName: tableName, // nama tebel/dataset
7490
                name: "MinovaGridFormGrid" + tableName, //name bebeas
7491
                param: me.param, // parameter filteran
7492
                pagesize: me.pagesize, // jumlah record yang muncul per page
7493
                storename: storename, //nama store bebas
7494
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
7495
                height: 330,
7496
                bodyPadding: 0,
7497
                dockedItems: [{
7498
                    xtype: 'pagingtoolbar',
7499
                    store: storename, // harus sama dengan naa store diatas
7500
                    dock: 'bottom', //posisi paging
7501
                    pageSize: me.pagesize,
7502
                    displayInfo: true
7503
                }
7504
                ],
7505

    
7506
                listeners: {
7507
                    viewready: function () {
7508
                        //alert('ready')
7509
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + this.tableName + ']')[0];
7510
                        formEdit.setHidden(true);
7511

    
7512
                        if (MinovaUtil.GetActionMenu() == 0 || MinovaUtil.GetActionMenu() == undefined || MinovaUtil.GetActionMenu() == "") {
7513
                            Ext.ComponentQuery.query('[name=actionBtn]')[0].setHidden(true)
7514
                            Ext.ComponentQuery.query('[name=Edit' + me.tableName + ']')[0].setHidden(true)
7515
                            Ext.ComponentQuery.query('[name=Delete_]')[0].setHidden(true)
7516
                        } else {
7517
                            Ext.ComponentQuery.query('[name=actionBtn]')[0].setHidden(false)
7518
                            //Ext.ComponentQuery.query('[name=Edit_]')[0].setHidden(true)
7519
                            Ext.ComponentQuery.query('[name=Delete_]')[0].setHidden(true)
7520
                            Ext.ComponentQuery.query('[name=Edit' + me.tableName + ']')[0].setHidden(false)
7521
                        }
7522
                    },
7523
                    selectionchange: function () {
7524
                        //case md
7525
                        var layout = null;
7526
                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7527
                        if (pnl) {
7528
                            layout = pnl.getLayoutType();
7529

    
7530
                        }
7531
                        //end case
7532

    
7533
                        if (layout == 'L003') {
7534
                            var selection = this.getView().getSelectionModel().getSelection()[0];
7535
                            var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + this.tableName + ']')[0];
7536
                            var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + this.tableName + ']')[0];
7537
                            if (selection) {
7538
                                formDisplay.getForm().setValues(selection.data);
7539
                                formEdit.getForm().setValues(selection.data);
7540
                            }
7541

    
7542
                        }
7543
                    },
7544
                    itemdblclick: function () {
7545
                        var me = this;
7546
                        //case md
7547
                        var layout = null;
7548
                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7549
                        if (pnl) {
7550
                            layout = pnl.getLayoutType();
7551

    
7552
                        } else {
7553
                            pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
7554
                            layout = pnl.getLayoutType();
7555
                        }
7556
                        //end case
7557
                        var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + this.tableName + ']')[0];
7558
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + this.tableName + ']')[0];
7559
                        var submit_ = formEdit.getSubmitProc();
7560
                        var selection = me.getView().getSelectionModel().getSelection()[0];
7561
                        if (submit_ == undefined) {
7562
                            submit_ = false;
7563
                        }
7564
                        if (submit_ == false) {
7565

    
7566
                            formDisplay.getForm().setValues(selection.data);
7567
                            formEdit.getForm().setValues(selection.data);
7568
                            if (layout == 'L003') {
7569
                                formDisplay.setHidden(false);
7570
                                Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + this.tableName + ']')[0].setHidden(true);
7571
                                var heigh = pnl.getLastheightform();
7572

    
7573
                                var pDetail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
7574
                                if (pDetail) {
7575
                                    pDetail.setHeight(heigh + 100);
7576
                                } else {
7577
                                    pDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
7578
                                    var mainPnl_ = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
7579
                                    var mainPnl = mainPnl_.getHeight();
7580
                                    //pDetail.setHeight(mainPnl + 100);
7581

    
7582
                                }
7583
                            } else {
7584
                                formDisplay.setTitle("View")
7585
                                formEdit.setTitle("Edit")
7586
                            }
7587
                        } else {
7588
                            alert('still process')
7589
                        }
7590

    
7591
                    },
7592
                    beforeedit: function () {
7593
                        return false;
7594
                    }
7595
                }
7596
            }, {
7597
                xtype: 'minovaform',
7598
                name: "MinovaGridFormDisplay" + tableName,
7599
                tableName: tableName, // nama tabel /dataset
7600
                isLookup: '', // 1 or 'Y' for lookup
7601
                isDisplay: true, // true== form is displayfield
7602
                buttons: [{
7603
                    text: 'Edit',
7604
                    name: 'Edit' + tableName,
7605
                    iconCls: 'fa-edit',
7606
                    style: 'font-family: FontAwesome',
7607
                    handler: function () {
7608

    
7609
                        f = this.up().up();
7610
                        f.setSubmitProc(false);
7611
                        f.setHidden(true);
7612
                        //f.setActionSubmit(1);
7613
                        Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7614
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7615
                        formEdit.setSubmitProc(true);
7616
                        formEdit.setHidden(false);
7617
                        formEdit.setActionSubmit(1);
7618
                        var p = Ext.ComponentQuery.query('[name=DetailMD]')[0];
7619
                        if (p) {
7620
                            var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7621
                            var lastTitile = p.getTitle();
7622
                            pnl.setLastTitle(lastTitile);
7623
                            p.setTitle('Edit - ' + lastTitile)
7624

    
7625
                        }
7626

    
7627
                    }
7628
                }, {
7629
                    text: 'Back to Grid',
7630
                    name: 'Edit' + tableName,
7631
                    iconCls: 'fa-reply',
7632
                    style: 'font-family: FontAwesome',
7633
                    handler: function () {
7634
                        var layout = null;
7635
                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7636
                        if (pnl) {
7637
                            layout = pnl.getLayoutType();
7638

    
7639
                        }
7640

    
7641
                        f = this.up().up();
7642
                        f.setSubmitProc(false);
7643
                        f.setHidden(true);
7644
                        Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(false);
7645
                        Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0].setHidden(true);
7646

    
7647
                        if (layout == 'L003') {
7648
                            var grid_ = Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + f.tableName + ']')[0];
7649
                            grid_.setHidden(false);
7650
                            Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7651
                            Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(grid_.getHeight() + 100)
7652
                        }
7653
                    }
7654
                }
7655
                ],
7656
            }, {
7657
                xtype: 'minovaform',
7658
                name: "MinovaGridFormEdit" + tableName,
7659
                tableName: tableName, // nama tabel /dataset
7660
                isLookup: '', // 1 or 'Y' for lookup
7661
                isDisplay: false, // true== form is displayfield
7662
                buttons: [{
7663
                    text: 'Save',
7664
                    name: 'btnSaveMD',
7665
                    name: 'Save' + tableName,
7666
                    iconCls: 'fa-save',
7667
                    style: 'font-family: FontAwesome',
7668
                    handler: function () {
7669
                        f = this.up().up();
7670
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7671

    
7672
                        if (formEdit.getForm().isValid()) {
7673

    
7674
                            if (Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]) {
7675
                                var action_ = formEdit.getActionSubmit();
7676
                                var main_ = Ext.ComponentQuery.query('[name=mainORM]')[0];
7677
                                var record = main_.getRecordSelect();
7678

    
7679
                                if (record == undefined) {
7680
                                    var treeDetail = Ext.ComponentQuery.query('[name=treeDetail]')[0];
7681
                                    treeDetail.getSelectionModel().select(0);
7682
                                    record = treeDetail.getView().getSelectionModel().getSelection()[0];
7683

    
7684
                                }
7685
                                var frmValue = formEdit.getValues();
7686
                                var InitStartDate = 'InitStartDate';
7687
                                var InitStartDateValue = record.get('StartDate');
7688
                                frmValue[InitStartDate] = InitStartDateValue;
7689

    
7690
                                var InitEndDate = 'InitEndDate';
7691
                                var InitEndDateValue = record.get('EndDate');
7692
                                frmValue[InitEndDate] = InitEndDateValue;
7693

    
7694
                                var InitParentObject = 'InitParentObject';
7695
                                var InitParentObjectValue = record.get('ObjectId');
7696
                                if (InitParentObjectValue == undefined) {
7697
                                    InitParentObjectValue = "";
7698
                                }
7699
                                frmValue[InitParentObject] = InitParentObjectValue;
7700

    
7701
                                var InitParentClass = 'InitParentClass';
7702
                                var InitParentClassValue = record.get('ObjectType');
7703
                                if (InitParentClassValue == undefined) {
7704
                                    InitParentClassValue = "";
7705
                                }
7706
                                frmValue[InitParentClass] = InitParentClassValue;
7707
                                var frmValue_ = Ext.encode(frmValue);
7708

    
7709
                                Ext.Ajax.request({
7710
                                    method: 'POST',
7711
                                    url: '/Devt/SaveMaintainORM',
7712
                                    params: {
7713
                                        tableName: f.tableName,
7714
                                        data: frmValue_,
7715
                                        action: action_,
7716
                                        /*
7717
                                        InitStartDate: InitStartDate,
7718
                                        InitEndaDate: InitEndaDate,
7719
                                        InitParentObject: InitParentObject,
7720
                                        InitParentClass: InitParentClass
7721
                                         */
7722
                                    },
7723
                                    waitMsg: 'Saving Data...',
7724
                                    success: function (response) {
7725
                                        var result = Ext.decode(response.responseText);
7726
                                        if (result.success) {
7727
                                            MinovaMessage('Not Null', '000006', '', 'S')
7728

    
7729
                                            var pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
7730
                                            if (pnl) {
7731
                                                Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0].setHeight(394);
7732
                                                layout = pnl.getLayoutType();
7733
                                                pnl.setLastpage(undefined);
7734
                                                var last = 'MinovaGridFormGrid' + f.tableName;
7735
                                                var grid_ = Ext.ComponentQuery.query('[name=' + last + ']')[0]
7736

    
7737
                                                var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7738
                                                formEdit.setSubmitProc(false);
7739
                                                formEdit.setHidden(true);
7740
                                                grid_.setHidden(false);
7741
                                                grid_.getStore().reload()
7742

    
7743
                                            }
7744
                                            if (layout == 'L003') {
7745
                                                var grid_ = Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + f.tableName + ']')[0];
7746
                                                grid_.setHidden(false);
7747
                                                Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7748
                                                var detail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
7749
                                                if (detail) {
7750
                                                    detail.setHeight(grid_.getHeight() + 100)
7751
                                                } else {
7752
                                                    var p = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
7753
                                                    var p_ = Ext.ComponentQuery.query('[name=DetailMD]')[0];
7754
                                                    p_.setTitle(p.getLastTitle());
7755
                                                }
7756

    
7757
                                            }
7758

    
7759
                                        } else {
7760
                                            MinovaMessage('Not Null', '000005', result.message.text, 'E')
7761
                                        }
7762
                                        var grid = Ext.ComponentQuery.query('[name=gridMenuMDOrm]')[0];
7763
                                        var s = grid.getStore();
7764
                                        s.removeAll();
7765
                                        var ObjectType = getParam("ObjectType");
7766
                                        var Lang = null;
7767
                                        Ext.Ajax.request({
7768
                                            async: false,
7769
                                            method: 'POST',
7770
                                            url: '/Devt/GetLangID',
7771
                                            success: function (response) {
7772
                                                Lang = response.responseText;
7773
                                            }
7774
                                        });
7775
                                        Ext.Ajax.request({
7776
                                            async: true,
7777
                                            method: 'POST',
7778
                                            url: '/UserControl/GetStore',
7779
                                            params: {
7780
                                                tableName: 'PHRCM0006',
7781
                                                param: 'Language[equal]' + Lang + ',ObjectClass[equal]' + ObjectType
7782

    
7783
                                            },
7784
                                            success: function (response) {
7785
                                                var results = Ext.decode(response.responseText);
7786
                                                var data_ = results.data;
7787
                                                s.loadData(results.data);
7788
                                                // console.log(data_)
7789
                                            }
7790
                                        });
7791
                                    },
7792
                                    failure: function (response) {
7793
                                        var result = Ext.decode(response.responseText);
7794
                                        console.log(result);
7795
                                    }
7796
                                });
7797
                            } else {
7798
                                var frmValue = Ext.encode(formEdit.getValues());
7799
                                Ext.Ajax.request({
7800
                                    method: 'POST',
7801
                                    url: '/Devt/SaveTable',
7802
                                    params: {
7803
                                        tableName: f.tableName,
7804
                                        data: frmValue,
7805
                                        action: formEdit.getActionSubmit()
7806
                                    },
7807
                                    waitMsg: 'Saving Data...',
7808
                                    success: function (response) {
7809
                                        var result = Ext.decode(response.responseText);
7810
                                        if (result.success) {
7811
                                            MinovaMessage('Not Null', '000006', '', 'S')
7812

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

    
7815
                                            if (pnl) {
7816
                                                Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(394);
7817
                                                layout = pnl.getLayoutType();
7818
                                                pnl.setLastpage(undefined);
7819
                                                var last = 'MinovaGridFormGrid' + f.tableName;
7820
                                                var grid_ = Ext.ComponentQuery.query('[name=' + last + ']')[0]
7821

    
7822
                                                var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7823
                                                formEdit.setSubmitProc(false);
7824
                                                formEdit.setHidden(true);
7825
                                                grid_.setHidden(false);
7826
                                                grid_.getStore().reload()
7827
                                                var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0]
7828
                                                mpnl.setTitle(pnl.getLastTitle());
7829

    
7830
                                            }
7831
                                            if (layout == 'L003') {
7832
                                                var grid_ = Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + f.tableName + ']')[0];
7833
                                                grid_.setHidden(false);
7834
                                                Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7835
                                                Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(grid_.getHeight() + 100)
7836
                                            }
7837

    
7838
                                        } else {
7839
                                            MinovaMessage('Not Null', '000005', result.message.text, 'E')
7840
                                        }
7841
                                    },
7842
                                    failure: function (response) {
7843
                                        var result = Ext.decode(response.responseText);
7844
                                        //console.log(result);
7845
                                    }
7846
                                });
7847
                            }
7848

    
7849
                        }
7850
                    }
7851
                }, {
7852
                    text: 'Delete',
7853
                    iconCls: 'fa-trash-o',
7854
                    name: 'Delete',
7855
                    style: 'font-family: FontAwesome',
7856
                    action: 'CRUDdelete',
7857
                    handler: function () {
7858
                        //add fungsi Delete
7859
                        f = this.up().up();
7860
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7861
                        var frmValue = Ext.encode(formEdit.getValues());
7862
                        if (formEdit.getForm().isValid()) {
7863
                            Ext.Ajax.request({
7864
                                method: 'POST',
7865
                                url: '/Devt/SaveTable',
7866
                                params: {
7867
                                    tableName: f.tableName,
7868
                                    data: frmValue,
7869
                                    action: 2
7870
                                },
7871
                                waitMsg: 'Saving Data...',
7872
                                success: function (response) {
7873
                                    var result = Ext.decode(response.responseText);
7874
                                    if (result.success) {
7875
                                        MinovaMessage('Not Null', '000006', '', 'S')
7876

    
7877
                                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7878
                                        if (pnl) {
7879
                                            layout = pnl.getLayoutType();
7880
                                            pnl.setLastpage(undefined);
7881

    
7882
                                        }
7883
                                        if (layout == 'L003') {
7884
                                            var grid_ = Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + f.tableName + ']')[0];
7885
                                            grid_.setHidden(false);
7886
                                            Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7887
                                            Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(grid_.getHeight() + 100)
7888
                                        }
7889

    
7890
                                    } else {
7891
                                        MinovaMessage('Not Null', '000005', result.message.text, 'E')
7892
                                    }
7893
                                },
7894
                                failure: function (response) {
7895
                                    var result = Ext.decode(response.responseText);
7896
                                    //console.log(result);
7897
                                }
7898
                            });
7899
                        }
7900
                    }
7901

    
7902
                }, {
7903
                    text: 'Cancel',
7904
                    iconCls: 'fa-reply',
7905
                    style: 'font-family: FontAwesome',
7906
                    handler: function () {
7907
                        f = this.up().up();
7908
                        f.setSubmitProc(false);
7909
                        f.setHidden(true);
7910
                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7911

    
7912
                        if (pnl) {
7913
                            //'L001'=grid L002 =heder detail L003=card L004=custom
7914
                            layout = pnl.getLayoutType();
7915
                            var last = 'MinovaGridFormGrid' + f.tableName;
7916
                            var grid_ = Ext.ComponentQuery.query('[name=' + last + ']')[0];
7917
                            grid_.setHidden(false);
7918
                            pnl.setLastpage(undefined);
7919
                            var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0]
7920
                            mpnl.setTitle(pnl.getLastTitle());
7921
                            if (layout == 'L003') {
7922
                                Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(400);
7923
                            } else {
7924
                                Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(false);
7925
                            }
7926
                        } else {
7927
                            // Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(false);
7928
                            var mdDetail = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
7929
                            layout = mdDetail.getLayoutType();
7930
                            if (layout == 'L003') {
7931
                                var panelDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
7932
                                Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + tableName + ']')[0].setHidden(false)
7933

    
7934
                                panelDetail.setHeight(400);
7935
                            } else {
7936
                                Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(false);
7937
                            }
7938
                        }
7939

    
7940
                    }
7941
                }
7942
                ],
7943
            }
7944
            ]
7945
        });
7946
        me.callParent(arguments);
7947
    }
7948
});
7949

    
7950
Ext.define('MinovaUtil.MinovaES.MinovaGridCard', {
7951
    extend: 'Ext.form.Panel',
7952
    alias: ['widget.minovagridcard', 'widget.MinovaGridCard'],
7953
    tableName: undefined, //nama tabel
7954
    param: undefined, //param query
7955
    //hidebutton: undefined,
7956
    pagesize: undefined,
7957
    storename: undefined,
7958
    titleform: undefined,
7959
    titlegrid: undefined,
7960
    heightgrid: undefined,
7961
    heightform: undefined,
7962
    iseditform: undefined,
7963

    
7964
    getIsEditform: function () {
7965
        return this.iseditform;
7966
    },
7967
    setIsEditform: function (value) {
7968
        var me = this;
7969
        me.iseditform = value;
7970
        return me;
7971
    },
7972
    initComponent: function () {
7973
        var me = this;
7974
        var storename = me.storename;
7975
        if (storename == "" || storename == undefined) {
7976
            storename = "store" + me.tableName;
7977
        }
7978
        var tableName = me.tableName;
7979
        Ext.applyIf(me, {
7980
            items: [{
7981
                layoutType: "MinovaGridCard",
7982
                //title: me.titlegrid,
7983
                xtype: "minovagrid",
7984
                tableName: tableName, // nama tebel/dataset
7985
                name: "MinovaGridCardGrid" + tableName, //name bebeas
7986
                param: me.param, // parameter filteran
7987
                pagesize: me.pagesize, // jumlah record yang muncul per page
7988
                storename: storename, //nama store bebas
7989
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
7990
                height: 330,
7991
                bodyPadding: 0,
7992
                dockedItems: [{
7993
                    xtype: 'pagingtoolbar',
7994
                    store: storename, // harus sama dengan naa store diatas
7995
                    dock: 'bottom', //posisi paging
7996
                    pageSize: me.pagesize,
7997
                    displayInfo: true
7998
                }
7999
                ],
8000

    
8001
                listeners: {
8002
                    viewready: function () {
8003
                        if (MinovaUtil.GetActionMenu() == 0 || MinovaUtil.GetActionMenu() == undefined || MinovaUtil.GetActionMenu() == "") {
8004
                            Ext.ComponentQuery.query('[name=actionBtn]')[0].setHidden(true)
8005
                            Ext.ComponentQuery.query('[name=Edit' + me.tableName + ']')[0].setHidden(true)
8006
                        } else {
8007
                            Ext.ComponentQuery.query('[name=actionBtn]')[0].setHidden(false)
8008
                            //Ext.ComponentQuery.query('[name=Edit_]')[0].setHidden(true)
8009
                            Ext.ComponentQuery.query('[name=Delete_]')[0].setHidden(true)
8010
                            Ext.ComponentQuery.query('[name=Edit' + me.tableName + ']')[0].setHidden(false)
8011
                        }
8012
                        //case orm
8013
                        if (this.layoutType == "MinovaGridCard") {
8014
                            var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
8015
                            var formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
8016
                            formDisplay.setHidden(true);
8017
                            formEdit.setHidden(true);
8018
                        } else if (this.layoutType == "MinovaGridForm") {
8019
                            var formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
8020
                            formEdit.setHidden(true);
8021
                        } else {
8022
                            var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
8023
                            var formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
8024
                            formDisplay.setHidden(true);
8025
                            formEdit.setHidden(true);
8026
                        }
8027

    
8028
                    },
8029
                    itemdblclick: function () {
8030
                        //alert('a')
8031
                        var me = this;
8032

    
8033
                        var formDisplay = undefined;
8034
                        var formEdit = undefined;
8035
                        //case md orm
8036

    
8037
                        if (this.layoutType == "MinovaGridCard") {
8038
                            formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
8039
                            formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
8040
                        } else if (this.layoutType == "MinovaGridForm") {
8041
                            formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
8042
                            formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
8043
                            // formDisplay.setHidden(true);
8044

    
8045
                        } else {
8046
                            formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
8047
                            formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
8048

    
8049
                        }
8050
                        var submit_ = formEdit.getSubmitProc();
8051
                        var selection = me.getView().getSelectionModel().getSelection()[0];
8052
                        if (submit_ == undefined) {
8053
                            submit_ = false;
8054
                        }
8055
                        if (submit_ == false) {
8056

    
8057
                            if (this.layoutType == "MinovaGridCard") {
8058

    
8059
                                formDisplay.getForm().setValues(selection.data);
8060
                                formEdit.getForm().setValues(selection.data);
8061
                                formDisplay.setHidden(false);
8062
                                formEdit.setHidden(true);
8063
                                this.setHidden(true);
8064
                            } else if (this.layoutType == "MinovaGridForm") {
8065
                                formEdit.setHidden(true);
8066
                                formDisplay.getForm().setValues(selection.data);
8067
                                formEdit.getForm().setValues(selection.data);
8068
                            } else {
8069
                                formDisplay.setHidden(true);
8070
                                formEdit.setHidden(true);
8071

    
8072
                                formDisplay.getForm().setValues(selection.data);
8073
                                formEdit.getForm().setValues(selection.data);
8074
                            }
8075
                            // untuk case ORM
8076
                            var display_ = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + tableName + ']')[0].getHeight();
8077
                            if (display_) {
8078
                                var pnlORM = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0]
8079
                                var pnlMD = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
8080
                                if (pnlORM) {
8081
                                    pnlORM.setHeight(pnl + 100);
8082
                                }
8083
                                if (pnlMD) {
8084
                                    Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0].setHeight(pnlMD + 600);
8085
                                    Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(pnlMD + 600);
8086
                                }
8087
                            }
8088
                            //end case ORM and MD
8089
                        } else {
8090
                            alert('still process')
8091
                        }
8092

    
8093
                    },
8094
                    beforeedit: function () {
8095
                        return false;
8096
                    }
8097
                }
8098
            }, {
8099
                xtype: 'minovaform',
8100
                name: "MinovaGridCardDisplay" + tableName,
8101
                tableName: tableName, // nama tabel /dataset
8102
                isLookup: '', // 1 or 'Y' for lookup
8103
                isDisplay: true, // true== form is displayfield
8104
                buttons: [{
8105
                    text: 'Edit',
8106
                    name: 'Edit' + tableName,
8107
                    iconCls: 'fa-edit',
8108
                    style: 'font-family: FontAwesome',
8109
                    handler: function () {
8110
                        f = this.up().up();
8111
                        f.setSubmitProc(false);
8112
                        f.setHidden(true);
8113
                        var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + f.tableName + ']')[0].setHidden(true);
8114
                        Ext.ComponentQuery.query('[name=MinovaGridCardGrid' + f.tableName + ']')[0].setHidden(true);
8115
                        Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + f.tableName + ']')[0].setHidden(false);
8116

    
8117
                    }
8118
                }, {
8119
                    text: 'Back to Grid',
8120
                    name: 'Cancel' + tableName,
8121
                    iconCls: 'fa-reply',
8122
                    style: 'font-family: FontAwesome',
8123
                    handler: function () {
8124
                        f = this.up().up();
8125
                        f.setSubmitProc(false);
8126
                        f.setHidden(true);
8127
                        var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + f.tableName + ']')[0].setHidden(true);
8128
                        Ext.ComponentQuery.query('[name=MinovaGridCardGrid' + f.tableName + ']')[0].setHidden(false);
8129
                        Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + f.tableName + ']')[0].setHidden(true);
8130

    
8131
                    }
8132
                }
8133
                ],
8134
            }, {
8135
                xtype: 'minovaform',
8136
                name: "MinovaGridCardEdit" + tableName,
8137
                tableName: tableName, // nama tabel /dataset
8138
                isLookup: '', // 1 or 'Y' for lookup
8139
                isDisplay: false, // true== form is displayfield
8140
                buttons: [{
8141
                    text: 'Save',
8142
                    name: 'Save' + tableName,
8143
                    iconCls: 'fa-save',
8144
                    style: 'font-family: FontAwesome',
8145
                    handler: function () {
8146
                        f = this.up().up();
8147
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + f.tableName + ']')[0];
8148
                    }
8149
                }, {
8150
                    text: 'Delete',
8151
                    iconCls: 'fa-trash-o',
8152
                    name: 'Delete',
8153
                    style: 'font-family: FontAwesome',
8154
                    action: 'CRUDdelete'
8155
                }, {
8156
                    text: 'Back to Grid',
8157
                    name: 'EditForm' + tableName,
8158
                    iconCls: 'fa-reply',
8159
                    style: 'font-family: FontAwesome',
8160
                    handler: function () {
8161
                        f = this.up().up();
8162
                        f.setSubmitProc(false);
8163
                        f.setHidden(true);
8164
                        var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + f.tableName + ']')[0].setHidden(true);
8165
                        Ext.ComponentQuery.query('[name=MinovaGridCardGrid' + f.tableName + ']')[0].setHidden(false);
8166
                        Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + f.tableName + ']')[0].setHidden(true);
8167

    
8168
                    }
8169
                }
8170
                ],
8171
            }
8172
            ]
8173
        });
8174
        me.callParent(arguments);
8175
    }
8176
});
8177

    
8178
Ext.define('MinovaUtil.MinovaES.MinovaFloatField', {
8179
    extend: 'Ext.form.field.Number',
8180
    alias: 'widget.minovafloatfield',
8181
    hideTrigger: true,
8182
    allowDecimals: true,
8183
    precision: undefined,
8184
    isValid: function () {
8185
        var b = this,
8186
		a = b.disabled,
8187
		c = b.forceValidation || !a;
8188
        return c ? b.validateValue(b.processRawValue(b.getValue())) : a
8189
    },
8190
    setValue: function (v) {
8191
        this.setRawValue(this.getFormattedValue(v));
8192
    },
8193
    getValue: function () {
8194
        var val = this.removeFormat(this.getRawValue());
8195
        this.value = val;
8196
        return val;
8197
    },
8198
    getSubmitValue: function () {
8199
        return this.removeFormat(this.getRawValue());
8200
    },
8201
    removeFormat: function (v) {
8202
        if (Ext.isEmpty(v))
8203
            return v;
8204
        else {
8205
            v = v.replace(Ext.util.Format.currencySign, '');
8206
            v = v.replace(new RegExp('[' + Ext.util.Format.thousandSeparator + ']', 'g'), '');
8207
            return v;
8208
        }
8209
    },
8210
    onFocus: function () {
8211
        this.setRawValue(this.removeFormat(this.getRawValue()));
8212
    },
8213
    onBlur: function () {
8214
        this.setRawValue(this.getFormattedValue(this.getValue()));
8215
    },
8216
    getFormattedValue: function (v) {
8217
        var prec = '';
8218
        if (this.precision != '' && this.precision > 0) {
8219
            for (var i = 0; i < this.precision; i++) {
8220
                prec = prec + '0'
8221
            }
8222
        }
8223
        return Ext.util.Format.number(v, '0,000.' + prec);
8224
    }
8225
});
8226
Ext.define('MinovaUtil.MinovaES.MinovaNumberField', {
8227
    extend: 'Ext.form.field.Number',
8228
    alias: 'widget.minovanumberfield',
8229
    //hideTrigger: true,
8230
    isValid: function () {
8231
        var b = this,
8232
		a = b.disabled,
8233
		c = b.forceValidation || !a;
8234
        return c ? b.validateValue(b.processRawValue(b.getValue())) : a
8235
    },
8236
    setValue: function (v) {
8237
        this.setRawValue(this.getFormattedValue(v));
8238
    },
8239
    getValue: function () {
8240
        var val = this.removeFormat(this.getRawValue());
8241
        this.value = val;
8242
        return val;
8243
    },
8244
    getSubmitValue: function () {
8245
        return this.removeFormat(this.getRawValue());
8246
    },
8247
    removeFormat: function (v) {
8248
        if (Ext.isEmpty(v))
8249
            return v;
8250
        else {
8251
            v = v.replace(Ext.util.Format.currencySign, '');
8252
            v = v.replace(new RegExp('[' + Ext.util.Format.thousandSeparator + ']', 'g'), '');
8253
            return v;
8254
        }
8255
    },
8256
    onFocus: function () {
8257
        this.setRawValue(this.removeFormat(this.getRawValue()));
8258
    },
8259
    onBlur: function () {
8260
        this.setRawValue(this.getFormattedValue(this.getValue()));
8261
    },
8262
    getFormattedValue: function (v) {
8263
        return Ext.util.Format.number(v, '0,000');
8264
    }
8265
});
8266

    
8267
Ext.define('MinovaUtil.MinovaES.SysDateTime', {
8268
    extend: 'Ext.form.field.Text',
8269
    alias: ['widget.minovasysdatetime'],
8270
    undefinedText: '&#160;',
8271
    setValue: function (v) {
8272
        var value = v;
8273
        var hasil = null;
8274
        /*
8275
		if (value === undefined) {
8276
		return this.undefinedText;
8277
		}
8278
		if (value === null) {
8279
		return this.setRawValue(null);
8280
		}
8281
		 */
8282
        //hamid 200916
8283
        //if (value != null || value != "" || value != undefined) {
8284
        //    return this.setRawValue(null);
8285
        if (value == "" || value == null) {
8286
            return this.setRawValue("");
8287
            //end
8288
        } else {
8289
            var d = value.substring(6, 8);
8290
            var m = value.substring(4, 6);
8291
            var y = value.substring(0, 4);
8292
            var h = value.substring(8, 10);
8293
            var mt = value.substring(10, 12);
8294
            var s = value.substring(12, 14);
8295
            hasil = d + '/' + m + '/' + y + '  ' + '  ' + h + ':' + mt + ':' + s;
8296
        }
8297

    
8298
        this.setRawValue(hasil);
8299
    },
8300
    getRawValue: function () {
8301
        return this.getValue();
8302
    },
8303
    getValue: function () {
8304
        var value = this.rawValue;
8305
        var hasil = null;
8306
        if (value != undefined) {
8307
            var d = value.substring(0, 2);
8308
            var m = value.substring(3, 5);
8309
            var y = value.substring(6, 10);
8310
            var h = value.substring(14, 16);
8311
            var mt = value.substring(17, 19);
8312
            var s = value.substring(20, 22);
8313
            hasil = y + m + d + h + mt + s;
8314
        }
8315
        return hasil;
8316
    }
8317
});
8318
Ext.define('MinovaUtil.MinovaES.MinovaDateTime', {
8319
    extend: 'Ext.form.field.Trigger',
8320
    alias: ['widget.minovadatetime', 'widget.MinovaDateTime'],
8321
    tableName: undefined,
8322
    param: undefined,
8323
    anchor: '50%',
8324
    initComponent: function () {
8325
        var me = this;
8326
        Ext.applyIf(me, {});
8327
        me.callParent(arguments);
8328
    },
8329
    onTriggerClick: function () {
8330
        Ext.create('Ext.window.Window', {
8331
            title: 'Hello',
8332
            modal: true,
8333
            layout: 'fit',
8334
            dockedItems: [{
8335
                xtype: 'toolbar',
8336
                dock: 'bottom',
8337
                align: 'center',
8338
                items: [{
8339
                    xtype: 'tbspacer'
8340
                }, {
8341
                    xtype: 'button',
8342
                    text: 'Today'
8343
                }, {
8344
                    xtype: 'tbspacer'
8345
                }, ]
8346
            }
8347
            ],
8348
            items: [{
8349
                xtype: 'panel',
8350
                layout: 'hbox',
8351
                items: [{
8352
                    xtype: 'datepicker',
8353
                    name: 'date',
8354
                    showToday: false,
8355
                    handler: function (picker, date) {}
8356

    
8357
                }, {
8358
                    xtype: 'sliderfield',
8359
                    width: 60,
8360
                    name: 'hour',
8361
                    labelAlign: 'top',
8362
                    fieldLabel: 'Hour',
8363
                    value: 0,
8364
                    increment: 1,
8365
                    minValue: 0,
8366
                    maxValue: 24,
8367
                    margin: '10 5 3 20',
8368
                    renderTo: Ext.getBody(),
8369
                }, {
8370
                    xtype: 'sliderfield',
8371
                    width: 60,
8372
                    name: 'minute',
8373
                    labelAlign: 'top',
8374
                    fieldLabel: 'Minute',
8375
                    value: 0,
8376
                    increment: 1,
8377
                    minValue: 0,
8378
                    maxValue: 60,
8379
                    margin: '10 5 3 20',
8380
                    renderTo: Ext.getBody(),
8381
                }, {
8382
                    xtype: 'sliderfield',
8383
                    width: 60,
8384
                    name: 'second',
8385
                    labelAlign: 'top',
8386
                    fieldLabel: 'Second',
8387
                    value: 0,
8388
                    increment: 1,
8389
                    minValue: 0,
8390
                    maxValue: 60,
8391
                    margin: '10 5 3 20',
8392
                    renderTo: Ext.getBody(),
8393
                }
8394
                ]
8395
            }
8396
            ]
8397
        }).show();
8398
    }
8399
});
8400

    
8401
Ext.define('MinovaUtil.MinovaES.MinovaMDORM', {
8402
    extend: 'Ext.form.Panel',
8403
    alias: ['widget.minovamdorm'],
8404

    
8405
    //controller: 'sample',
8406
    controller: 'orm-manage-controller',
8407
    tableName: undefined, //nama tabel
8408
    param: undefined, //param query
8409
    pagesize: undefined,
8410
    storename: undefined,
8411
    titleform: undefined,
8412
    titlegrid: undefined,
8413
    heightgrid: undefined,
8414
    heightform: undefined,
8415
    iseditform: undefined,
8416
    lastheightform: undefined,
8417
    layoutType: undefined,
8418
    lastpage: undefined,
8419
    lastTitle: undefined,
8420
    getLastTitle: function () {
8421
        return this.lastTitle;
8422
    },
8423
    setLastTitle: function (value) {
8424
        var me = this;
8425
        me.lastTitle = value;
8426
        return me;
8427
    },
8428
    getLastpage: function () {
8429
        return this.lastpage;
8430
    },
8431
    setLastpage: function (value) {
8432
        var me = this;
8433
        me.lastpage = value;
8434
        return me;
8435
    },
8436
    getLayoutType: function () {
8437
        return this.layoutType;
8438
    },
8439
    setLayoutType: function (value) {
8440
        var me = this;
8441
        me.layoutType = value;
8442
        return me;
8443
    },
8444
    getLastheightform: function () {
8445
        return this.lastheightform;
8446
    },
8447
    setLastheightform: function (value) {
8448
        var me = this;
8449
        me.lastheightform = value;
8450
        return me;
8451
    },
8452

    
8453
    getIsEditform: function () {
8454
        return this.iseditform;
8455
    },
8456
    setIsEditform: function (value) {
8457
        var me = this;
8458
        me.iseditform = value;
8459
        return me;
8460
    },
8461
    initComponent: function () {
8462
        var me = this;
8463
        var userAction = MinovaUtil.GetActionMenu();
8464
        var crudBtn = true;
8465
        if (userAction == '1') {
8466
            crudBtn = false
8467
        }
8468
        var storename = me.storename;
8469
        if (storename == "" || storename == undefined) {
8470
            storename = "store" + me.tableName;
8471
        }
8472
        var tableName = me.tableName;
8473
        Ext.applyIf(me, {
8474
            items: [{
8475
                layoutType: "MinovaGridForm",
8476
                title: me.titlegrid,
8477
                xtype: "minovagridmd",
8478
                tableName: tableName, // nama tebel/dataset
8479
                name: "MinovaGridFormGrid", //name bebeas
8480
                param: me.param, // parameter filteran
8481
                pagesize: me.pagesize, // jumlah record yang muncul per page
8482
                storename: storename, //nama store bebas
8483
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
8484
                height: 330,
8485
                bodyPadding: 0,
8486
                tbar: [{
8487
                    xtype: 'button',
8488
                    text: 'Action',
8489
                    hidden: crudBtn,
8490
                    name: 'actionGrid',
8491
                    menu: [{
8492
                        text: 'Add',
8493
                        action: 'addGrid',
8494
                        name: 'addGridORM',
8495
                        action: 'CRUDaddNewRecord',
8496
                        style: 'font-family: FontAwesome',
8497
                        itemId: 'AddData',
8498
                        iconCls: 'fa-plus-circle',
8499

    
8500
                    }, {
8501
                        text: 'Copy',
8502
                        action: 'copyGrid',
8503
                        name: 'CopyGridORM',
8504
                        iconCls: 'fa-copy',
8505
                        style: 'font-family: FontAwesome',
8506
                    }, {
8507
                        text: 'Edit',
8508
                        action: 'editGrid',
8509
                        name: 'EditGridORM',
8510
                        iconCls: 'fa-edit',
8511
                        style: 'font-family: FontAwesome',
8512
                    }, {
8513
                        text: 'Delete',
8514
                        name: 'DeleteGridORM',
8515
                        hidden: true,
8516
                        iconCls: 'fa-trash-o',
8517
                        style: 'font-family: FontAwesome',
8518
                    }
8519
                    ]
8520
                }, {
8521
                    xtype: 'tbfill'
8522
                }, {
8523
                    text: 'Clear Filters',
8524
                    tooltip: 'Clear all filters',
8525
                    name: 'clearbtn',
8526
                    handler: function () {
8527
                        var tolbar = this.up()
8528
                        var grid_ = tolbar.up()
8529
                        grid_.filters.clearFilters()
8530
                    }
8531
                }, ],
8532

    
8533
                dockedItems: [{
8534
                    xtype: 'pagingtoolbar',
8535
                    store: storename, // harus sama dengan naa store diatas
8536
                    dock: 'bottom', //posisi paging
8537
                    pageSize: me.pagesize,
8538
                    displayInfo: true
8539
                }
8540
                ],
8541
                listeners: {
8542
                    afterrender: function (me) {
8543
                        if (MinovaUtil.GetActionMenu() == "1") {}
8544
                        else {}
8545
                    },
8546

    
8547
                },
8548

    
8549
            }, {
8550
                xtype: 'minovaform',
8551
                name: "MinovaGridFormDisplay",
8552
                //name: "MinovaGridFormEdit",
8553
                border: false,
8554
                tableName: tableName, // nama tabel /dataset
8555
                isLookup: '', // 1 or 'Y' for lookup
8556
                isDisplay: true, // true== form is displayfield
8557
                /*
8558
                buttons: [{
8559
                text: 'Edit',
8560
                name: 'EditDisplay',
8561
                iconCls: 'fa-edit',
8562
                style: 'font-family: FontAwesome',
8563
                }, {
8564
                text: 'Back to Grid',
8565
                name: 'BackGrid',
8566
                iconCls: 'fa-reply',
8567
                style: 'font-family: FontAwesome',
8568
                }
8569
                ],
8570
                 */
8571
            }, {
8572
                xtype: 'minovaform',
8573
                //name: "MinovaGridFormDisplay",
8574
                name: "MinovaGridFormEdit",
8575
                border: false,
8576
                tableName: tableName, // nama tabel /dataset
8577
                isLookup: '', // 1 or 'Y' for lookup
8578
                isDisplay: false, // true== form is displayfield
8579
                /*
8580
                buttons: [{
8581
                text: 'Save',
8582
                name: 'btnSaveMD',
8583
                iconCls: 'fa-save',
8584
                style: 'font-family: FontAwesome',
8585
                }, {
8586
                text: 'Delete',
8587
                iconCls: 'fa-trash-o',
8588
                name: 'btnDeleteMD',
8589
                style: 'font-family: FontAwesome',
8590
                action: 'CRUDdelete',
8591
                }, {
8592
                text: 'Cancel',
8593
                name: 'btnCancelMD',
8594
                iconCls: 'fa-reply',
8595
                style: 'font-family: FontAwesome',
8596
                }
8597
                ],
8598
                 */
8599
            }
8600
            ]
8601

    
8602
        });
8603
        me.callParent(arguments);
8604
    }
8605
});
8606

    
8607
Ext.define('MinovaUtil.MinovaES.MinovaHeaderMD', {
8608
    extend: 'Ext.form.Panel',
8609
    alias: ['widget.MinovaHeadermd', 'widget.MinovaHeaderMD'],
8610
    allTableName: undefined,
8611
    param: undefined,
8612
    //frame: true,
8613
    resizable: true,
8614
    autoScroll: true,
8615
    minHeight: 20,
8616
    layout: 'column',
8617
    name: 'HeaderMD',
8618
    getAllTableName: function () {
8619
        return this.allTableName;
8620
    },
8621
    setAllTableName: function (value) {
8622
        var me = this;
8623
        me.allTableName = value;
8624
        return me;
8625
    },
8626
    listeners: {
8627
        afterrender: function (me) {
8628

    
8629
            var nowDate = MinovaUtil.GetNowDate()
8630
            var allTbl = me.getAllTableName();
8631
            //alert(allTbl);
8632
            var splitTable = allTbl.split(',')
8633
            splitTable.forEach(function (tbl) {
8634
                // console.log(tbl);
8635
                //set values form
8636
                var nowDate = MinovaUtil.GetNowDate();
8637
                parameter = null;
8638
                if (me.isEmployee == true) {
8639
                    parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("EmployeeID")
8640
                } else {
8641
                    parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
8642
                }
8643
                Ext.Ajax.request({
8644
                    method: 'POST',
8645
                    //async: false,
8646
                    url: '/UserControl/GetStore',
8647
                    params: {
8648
                        tableName: tbl,
8649
                        param: parameter
8650
                    },
8651
                    success: function (response) {
8652
                        var results = Ext.decode(response.responseText);
8653
                        hasil = results.data;
8654
                        //console.log(hasil)
8655
                        if (hasil.length > 0) {
8656
                            me.getForm().setValues(hasil[0]);
8657

    
8658
                            //console.log(me)
8659
                        }
8660

    
8661
                    }
8662
                });
8663
            });
8664

    
8665
            //setTimeout(function () {
8666
            //    // var me_ = Ext.ComponentQuery.query('[name=Header]')[0];
8667
            //    // me_.setTitle(me_.getTitle() + ' - ' + Ext.ComponentQuery.query('[name=FullName]')[0].getValue());
8668
            //}, 100);
8669

    
8670
        },
8671

    
8672
    },
8673

    
8674
    initComponent: function () {
8675
        var me = this;
8676
        var col1 = [];
8677
        var col2 = [];
8678
        var hasil = null;
8679
        //get moduletype
8680
        //var ModuleType = 'PA';
8681
        //var ModuleType = MinovaUtil.GetModuleType()
8682
        //get Lang
8683
        var LangId = localStorage.LangId;
8684
        var allTable = null;
8685
        var tbl = null;
8686
        var tblTemp = null;
8687
        var nowDate = MinovaUtil.GetNowDate();
8688
        //var Photo_ = 'nophoto.gif';
8689
        var Photo = 'nophoto.gif';
8690
        tableName = null;
8691
        parameter = null;
8692
        // get Photo
8693
        //hamid200916
8694
        if (me.isEmployee == true) {
8695
            tableName = 'PHRPA0001';
8696
            parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("EmployeeID");
8697
        } else {
8698
            tableName = 'PHRRC0001';
8699
            parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
8700
        }
8701
        Ext.Ajax.request({
8702
            method: 'POST',
8703
            async: false,
8704
            url: '/UserControl/GetStore',
8705
            params: {
8706
                tableName: tableName,
8707
                param: parameter
8708
            },
8709
            success: function (response) {
8710
                var results = Ext.decode(response.responseText);
8711
                hasil = results.data;
8712
                if (hasil.length > 0) {
8713
                    dataPhoto = hasil[0].Picture
8714
                    if (dataPhoto != "") {
8715
                        Photo = dataPhoto;
8716
                    }
8717
                }
8718

    
8719
            }
8720
        });
8721

    
8722
        var hasil = undefined;
8723
        Ext.Ajax.request({
8724
            async: false,
8725
            method: 'POST',
8726
            url: '/UserControl/GetStore',
8727
            params: {
8728
                tableName: 'PDSBS0009',
8729
                param: 'MenuID[=]' + MinovaUtil.GetMenuID() + ',LangId[=]' + LangId
8730
            },
8731
            success: function (response) {
8732
                hasil = Ext.decode(response.responseText).data;
8733

    
8734
            }
8735
        });
8736

    
8737
        //sorting results
8738
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
8739
        if (hasil.length > 0) {
8740
            Ext.each(hasil, function (rec) {
8741
                tblTemp = rec.TableName;
8742
                if (tbl != tblTemp) {
8743
                    tbl = tblTemp;
8744
                    if (allTable == null) {
8745
                        allTable = tbl
8746
                    } else {
8747
                        allTable = allTable + ',' + tbl
8748
                    }
8749

    
8750
                }
8751
                // build form
8752
                if (rec.TableRef != '') {
8753
                    valueField = null;
8754
                    displayValue = null;
8755
                    Ext.Ajax.request({
8756
                        async: false,
8757
                        method: 'POST',
8758
                        url: '/UserControl/GetStore',
8759
                        params: {
8760
                            tableName: 'SDATATABLEFIELD',
8761
                            param: 'TableName[equal]' + rec.TableRef
8762
                        },
8763
                        success: function (response) {
8764
                            var results = Ext.decode(response.responseText);
8765
                            data_ = results.data;
8766
                            if (data_ != undefined) {
8767
                                valueField_ = $.grep(data_, function (r) {
8768
                                    return r.ValueField == '1'
8769
                                });
8770
                                if (valueField_.length > 0) {
8771
                                    valueField = valueField_[0].FieldName
8772
                                }
8773

    
8774
                                displayValue_ = $.grep(data_, function (r) {
8775
                                    return r.DisplayValue == '1'
8776
                                });
8777
                                if (displayValue_.length > 0) {
8778
                                    displayValue = displayValue_[0].FieldName
8779
                                }
8780
                            }
8781
                        }
8782
                    });
8783

    
8784
                    formfield = new Ext.form.Display({
8785
                        fieldLabel: rec.ScreenCaption,
8786
                        name: rec.FieldName,
8787
                        //value: rec.DefaultValue,
8788
                        padding: 0,
8789
                        labelCls: 'label-minova',
8790
                        labelWidth: 150,
8791
                        anchor: '80%',
8792
                        store: Ext.create('Ext.data.Store', {
8793
                            storeId: 'storeDisplay' + rec.FieldName,
8794
                            //autoLoad: true,
8795
                            proxy: {
8796
                                method: 'POST',
8797
                                type: 'ajax',
8798
                                extraParams: {
8799
                                    tableName: rec.TableRef,
8800
                                    param: ''
8801
                                },
8802
                                reader: {
8803
                                    type: 'json',
8804
                                    root: 'data',
8805
                                    totalProperty: 'data[0].TotalCount'
8806
                                }
8807
                            }
8808
                        }),
8809
                        listeners: {
8810
                            afterrender: function (f) {
8811
                                var store = Ext.StoreMgr.lookup('storeDisplay' + rec.FieldName);
8812
                                var ParamCombo = rec.ParamCombo;
8813
                                var param = '';
8814
                                //if (ParamCombo != '') {
8815
                                if ((rec.TableRef).toLowerCase() == 'phrom0001') {
8816
                                    var splitParam = ParamCombo.split(']');
8817
                                    switch (rec.FieldName) {
8818
                                        case 'Position':
8819
                                            ParamCombo = 'P'
8820
                                            break;
8821
                                        case 'CostCenter':
8822
                                            ParamCombo = 'CC'
8823
                                            break;
8824
                                        case 'Organization':
8825
                                            ParamCombo = 'O'
8826
                                            break;
8827
                                        case 'Job':
8828
                                            ParamCombo = 'J'
8829
                                            break;
8830
                                    }
8831
                                    //if (splitParam.length == 1) {
8832
                                    param = 'StartDate[<=]' + MinovaUtil.GetNowDate() + 'EndDate[>=]' + MinovaUtil.GetNowDate() + ',ObjectClass[=]' + ParamCombo
8833
                                    //} else {
8834
                                    //    param = ParamCombo;
8835
                                    //}
8836
                                }
8837
                                //}
8838
                                Ext.Ajax.request({
8839
                                    method: 'POST',
8840
                                    async: false,
8841
                                    url: '/UserControl/GetStore',
8842
                                    params: {
8843
                                        tableName: rec.TableRef,
8844
                                        param: param
8845
                                    },
8846
                                    success: function (response) {
8847
                                        var results = Ext.decode(response.responseText);
8848

    
8849
                                        //dt = results.data;
8850
                                        store.loadData(results.data);
8851

    
8852
                                    }
8853
                                });
8854
                            },
8855
                            change: function (f) {
8856
                                //alert(this.valueField, value);
8857
                                var display = this.displayField;
8858
                                var value = this.getValue();
8859
                                var st = f.store
8860
                                var r = st.findRecord(f.valueField, f.value)
8861
                                if (r != null) {
8862
                                    f.setRawValue(r.get(f.displayField))
8863
                                } else {
8864
                                    f.setRawValue(f.value);
8865

    
8866
                                }
8867
                            }
8868

    
8869
                        },
8870
                        queryMode: 'local',
8871
                        displayField: displayValue,
8872
                        valueField: valueField,
8873
                    });
8874
                } else {
8875
                    formfield = new Ext.form.Display({
8876
                        fieldLabel: rec.ScreenCaption,
8877
                        name: rec.FieldName,
8878
                        labelCls: 'label-minova',
8879
                        labelWidth: 150,
8880
                        //value: rec.DefaultValue,
8881
                        padding: 0,
8882
                        anchor: '80%'
8883
                    });
8884
                }
8885
                if (isDesk) {
8886
                    if (rec.Column == 1) {
8887
                        col1.push(formfield);
8888
                    } else {
8889
                        col2.push(formfield);
8890
                    }
8891
                } else {
8892
                    col1.push(formfield);
8893
                }
8894

    
8895
            });
8896
            //set allTable
8897
            this.setAllTableName(allTable);
8898
        }
8899

    
8900
        Ext.applyIf(me, {
8901
            items: [{
8902
                bodyPadding: 0,
8903
                width: 400,
8904
                margin: '10 5 3 30',
8905
                items: col1
8906
            }, {
8907
                bodyPadding: 0,
8908
                width: 400,
8909
                margin: '10 5 3 30',
8910
                items: col2
8911
            }, {
8912
                width: 150,
8913
                //margin: '10 5 3 30',
8914
                items: [{
8915
                    xtype: 'image',
8916
                    id: 'imageusermd',
8917
                    name: 'imageusermd',
8918
                    width: 120,
8919
                    height: 150,
8920
                    padding: 5,
8921
                    border: true,
8922
                    src: '/Devt/GetFileData?FileName=' + Photo + '&download=false',
8923
                }
8924
                ]
8925
            }
8926
            ],
8927
        });
8928
        me.callParent(arguments);
8929

    
8930
    }
8931
});
8932

    
8933

    
8934

    
8935

    
8936
/*Add Taufan (Header Master Data For ERP)*/
8937
Ext.define('MinovaUtil.MinovaES.MinovaHeaderMDLogistic', {
8938
    extend: 'Ext.form.Panel',
8939
    alias: ['widget.MinovaHeadermdLogistic', 'widget.MinovaHeaderMDLogistic', 'widget.minovaheadermdlogistic'],
8940
    tablenameheader: undefined,
8941
    keyid: undefined,
8942
    allTableName: undefined,
8943
    param: undefined,
8944
    resizable: true,
8945
    autoScroll: true,
8946
    minHeight: 20,
8947
    layout: 'column',
8948
    name: 'HeaderMDLogistic',
8949
    getAllTableName: function () {
8950
        return this.allTableName;
8951
    },
8952
    setAllTableName: function (value) {
8953
        var me = this;
8954
        me.allTableName = value;
8955
        return me;
8956
    },
8957
    listeners: {
8958
        afterrender: function (me) {
8959
            var nowDate = MinovaUtil.GetNowDate()
8960
            var allTbl = me.getAllTableName();
8961
            var splitTable = allTbl.split(',')
8962
            splitTable.forEach(function (tbl) {
8963
                var nowDate = MinovaUtil.GetNowDate();
8964
                var parameter = me.keyid + '[=]' + getParam("KeyValue");
8965
                Ext.Ajax.request({
8966
                    method: 'POST',
8967
                    url: '/UserControl/GetStore',
8968
                    params: {
8969
                        tableName: tbl,
8970
                        param: parameter
8971
                    },
8972
                    success: function (response) {
8973
                        var results = Ext.decode(response.responseText);
8974
                        hasil = results.data;
8975
                        if (hasil.length > 0) {
8976
                            me.getForm().setValues(hasil[0]);
8977
                        }
8978
                    }
8979
                });
8980
            });
8981
        }
8982
    },
8983
    initComponent: function () {
8984
        var me = this;
8985
        var col1 = [];
8986
        var col2 = [];
8987
        var hasil = null;
8988
        var LangId = localStorage.LangId;
8989
        var allTable = null;
8990
        var tbl = null;
8991
        var tblTemp = null;
8992
        var nowDate = MinovaUtil.GetNowDate();
8993
        var Photo = 'nophoto.gif';
8994
        var hasil = undefined;
8995
        var parameter = me.keyid + '[=]' + getParam("KeyValue");
8996
        Ext.Ajax.request({
8997
            method: 'POST',
8998
            async: false,
8999
            url: '/UserControl/GetStore',
9000
            params: {
9001
                tableName: me.tablenameheader,
9002
                param: parameter
9003
            },
9004
            success: function (response) {
9005
                var results = Ext.decode(response.responseText);
9006
                hasil = results.data;
9007
                if (hasil.length > 0) {
9008
                    dataPhoto = hasil[0].Photo
9009
                    if (dataPhoto != "") {
9010
                        Photo = dataPhoto;
9011
                    }
9012
                }
9013
            }
9014
        });
9015
        Ext.Ajax.request({
9016
            async: false,
9017
            method: 'POST',
9018
            url: '/UserControl/GetStore',
9019
            params: {
9020
                tableName: 'PDSBS0009',
9021
                param: 'MenuID[=]' + MinovaUtil.GetMenuID() + ',LangId[=]' + LangId
9022
            },
9023
            success: function (response) {
9024
                hasil = Ext.decode(response.responseText).data;
9025
            }
9026
        });
9027
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
9028
        if (hasil.length > 0) {
9029
            Ext.each(hasil, function (rec) {
9030
                tblTemp = rec.TableName;
9031
                if (tbl != tblTemp) {
9032
                    tbl = tblTemp;
9033
                    if (allTable == null) {
9034
                        allTable = tbl
9035
                    } else {
9036
                        allTable = allTable + ',' + tbl
9037
                    }
9038
                }
9039
                if (rec.TableRef != '') {
9040
                    valueField = null;
9041
                    displayValue = null;
9042
                    Ext.Ajax.request({
9043
                        async: false,
9044
                        method: 'POST',
9045
                        url: '/UserControl/GetStore',
9046
                        params: {
9047
                            tableName: 'SDATATABLEFIELD',
9048
                            param: 'TableName[equal]' + rec.TableRef
9049
                        },
9050
                        success: function (response) {
9051
                            var results = Ext.decode(response.responseText);
9052
                            data_ = results.data;
9053
                            if (data_ != undefined) {
9054
                                valueField_ = $.grep(data_, function (r) {
9055
                                    return r.ValueField == '1'
9056
                                });
9057
                                if (valueField_.length > 0) {
9058
                                    valueField = valueField_[0].FieldName
9059
                                }
9060
                                displayValue_ = $.grep(data_, function (r) {
9061
                                    return r.DisplayValue == '1'
9062
                                });
9063
                                if (displayValue_.length > 0) {
9064
                                    displayValue = displayValue_[0].FieldName
9065
                                }
9066
                            }
9067
                        }
9068
                    });
9069

    
9070
                    formfield = new Ext.form.Display({
9071
                        fieldLabel: rec.ScreenCaption,
9072
                        name: rec.FieldName,
9073
                        padding: 0,
9074
                        labelCls: 'label-minova',
9075
                        labelWidth: 150,
9076
                        anchor: '80%',
9077
                        store: Ext.create('Ext.data.Store', {
9078
                            storeId: 'storeDisplay' + rec.FieldName,
9079
                            proxy: {
9080
                                method: 'POST',
9081
                                type: 'ajax',
9082
                                extraParams: {
9083
                                    tableName: rec.TableRef,
9084
                                    param: ''
9085
                                },
9086
                                reader: {
9087
                                    type: 'json',
9088
                                    root: 'data',
9089
                                    totalProperty: 'data[0].TotalCount'
9090
                                }
9091
                            }
9092
                        }),
9093
                        listeners: {
9094
                            afterrender: function (f) {
9095
                                var store = Ext.StoreMgr.lookup('storeDisplay' + rec.FieldName);
9096
                                var ParamCombo = rec.ParamCombo;
9097
                                var param = '';
9098
                                Ext.Ajax.request({
9099
                                    method: 'POST',
9100
                                    async: false,
9101
                                    url: '/UserControl/GetStore',
9102
                                    params: {
9103
                                        tableName: rec.TableRef,
9104
                                        param: param
9105
                                    },
9106
                                    success: function (response) {
9107
                                        var results = Ext.decode(response.responseText);
9108
                                        store.loadData(results.data);
9109
                                    }
9110
                                });
9111
                            },
9112
                            change: function (f) {
9113
                                var display = this.displayField;
9114
                                var value = this.getValue();
9115
                                var st = f.store
9116
                                var r = st.findRecord(f.valueField, f.value)
9117
                                if (r != null) {
9118
                                    f.setRawValue(r.get(f.displayField))
9119
                                } else {
9120
                                    f.setRawValue(f.value);
9121
                                }
9122
                            }
9123
                        },
9124
                        queryMode: 'local',
9125
                        displayField: displayValue,
9126
                        valueField: valueField,
9127
                    });
9128
                } else {
9129
                    formfield = new Ext.form.Display({
9130
                        fieldLabel: rec.ScreenCaption,
9131
                        name: rec.FieldName,
9132
                        labelCls: 'label-minova',
9133
                        labelWidth: 150,
9134
                        padding: 0,
9135
                        anchor: '80%'
9136
                    });
9137
                }
9138
                if (isDesk) {
9139
                    if (rec.Column == 1) {
9140
                        col1.push(formfield);
9141
                    } else {
9142
                        col2.push(formfield);
9143
                    }
9144
                } else {
9145
                    col1.push(formfield);
9146
                }
9147

    
9148
            });
9149
            this.setAllTableName(allTable);
9150
        }
9151
        Ext.applyIf(me, {
9152
            items: [{
9153
                bodyPadding: 0,
9154
                width: 400,
9155
                margin: '10 5 3 30',
9156
                items: col1
9157
            }, {
9158
                bodyPadding: 0,
9159
                width: 400,
9160
                margin: '10 5 3 30',
9161
                items: col2
9162
            }, {
9163
                width: 150,
9164
                items: [{
9165
                    xtype: 'image',
9166
                    id: 'imageusermd',
9167
                    name: 'imageusermd',
9168
                    width: 120,
9169
                    height: 150,
9170
                    padding: 5,
9171
                    border: true,
9172
                    src: '/Devt/GetFileData?FileName=' + Photo + '&download=false',
9173
                }
9174
                ]
9175
            }
9176
            ]
9177
        });
9178
        me.callParent(arguments);
9179
    }
9180
});
9181
Ext.define('MinovaUtil.MinovaES.Column.MinovaDateTimeColumn', {
9182
    extend: 'Ext.grid.column.Column',
9183
    alias: ['widget.minovadatetimecolumn'],
9184
    alternateClassName: 'Ext.grid.MinovaDateTimeColumn',
9185
    undefinedText: '&#160;',
9186
    defaultRenderer: function (value) {
9187
        //hamid200916
9188
        //if (value === undefined) {
9189
        if (value === "") {
9190
            return this.undefinedText;
9191
            //end
9192
        }
9193

    
9194
        var d = value.substring(6, 8);
9195
        var m = value.substring(4, 6);
9196
        var y = value.substring(0, 4);
9197
        var h = value.substring(8, 10);
9198
        var mt = value.substring(10, 12);
9199
        var s = value.substring(12, 14);
9200
        var hasil = d + '/' + m + '/' + y + '  ' + '  ' + h + ':' + mt + ':' + s;
9201
        return hasil;
9202
    }
9203
});
9204
Ext.define('MinovaUtil.MinovaES.Column.MinovaDateColumn', {
9205
    extend: 'Ext.grid.column.Column',
9206
    alias: ['widget.minovadatecolumn'],
9207
    alternateClassName: 'Ext.grid.MinovaDateColumn',
9208
    undefinedText: '&#160;',
9209
    defaultRenderer: function (value) {
9210
        if (value === "" || value === undefined || value === null) {
9211
            return "";
9212
        }
9213
        var d = value.substring(6, 8);
9214
        var m = value.substring(4, 6);
9215
        var y = value.substring(0, 4);
9216
        var hasil = d + '/' + m + '/' + y;
9217
        return hasil;
9218
    }
9219
});
9220
Ext.define('MinovaUtil.MinovaES.MinovaComboColumn', {
9221
    extend: 'Ext.grid.column.Column',
9222
    alias: ['widget.minovacombocolumn'],
9223
    initComponent: function () {
9224
        this.callParent(arguments);
9225
    },
9226
    defaultRenderer: function (value) {
9227
        if (typeof(this.store) !== 'object') {
9228
            Ext.data.StoreManager.lookup(this.store).load();
9229
            this.store = Ext.data.StoreManager.lookup(this.store);
9230
        }
9231
        var idx = this.store.findExact(this.valueField, value);
9232
        if (this.store.getAt(idx)) {
9233
            var result = this.store.getAt(idx).get(this.displayField);
9234
            value = result ? result : value;
9235
        }
9236
        return value;
9237
    }
9238
});
9239
//atien
9240
Ext.define('MinovaUtil.MinovaES.MinovaAmountColumn', {
9241
    extend: 'Ext.grid.column.Column',
9242
    alias: ['widget.minovaamountcolumn'],
9243
    initComponent: function () {
9244
        this.callParent(arguments);
9245
    },
9246
    defaultRenderer: function (value) {
9247
        if (value != "") {
9248
            Ext.Ajax.request({
9249
                async: false,
9250
                method: 'POST',
9251
                url: '/Devt/DecryptData',
9252
                params: {
9253
                    dt: value
9254

    
9255
                },
9256
                success: function (response) {
9257
                    var results = Ext.decode(response.responseText);
9258
                    value = results.data;
9259
                    Ext.util.Format.thousandSeparator = "."
9260

    
9261
                    value = Ext.util.Format.number(value, '0,000');
9262
                }
9263
            });
9264
        }
9265

    
9266
        return value;
9267
    }
9268
});
9269
//end amount column
9270
//hamid200916
9271
Ext.define('MinovaUtil.MinovaES.MinovaMDApplicant', {
9272
    extend: 'Ext.form.Panel',
9273
    alias: ['widget.minovamdApp', 'widget.MinovaMDApplicant'],
9274
    controller: 'recruitment-controller',
9275
    tableName: undefined, //nama tabel
9276
    param: undefined, //param query
9277
    pagesize: undefined,
9278
    storename: undefined,
9279
    titleform: undefined,
9280
    titlegrid: undefined,
9281
    heightgrid: undefined,
9282
    heightform: undefined,
9283
    iseditform: undefined,
9284
    lastheightform: undefined,
9285
    layoutType: undefined,
9286
    lastpage: undefined,
9287
    lastTitle: undefined,
9288
    getLastTitle: function () {
9289
        return this.lastTitle;
9290
    },
9291
    setLastTitle: function (value) {
9292
        var me = this;
9293
        me.lastTitle = value;
9294
        return me;
9295
    },
9296
    getLastpage: function () {
9297
        return this.lastpage;
9298
    },
9299
    setLastpage: function (value) {
9300
        var me = this;
9301
        me.lastpage = value;
9302
        return me;
9303
    },
9304
    getLayoutType: function () {
9305
        return this.layoutType;
9306
    },
9307
    setLayoutType: function (value) {
9308
        var me = this;
9309
        me.layoutType = value;
9310
        return me;
9311
    },
9312
    getLastheightform: function () {
9313
        return this.lastheightform;
9314
    },
9315
    setLastheightform: function (value) {
9316
        var me = this;
9317
        me.lastheightform = value;
9318
        return me;
9319
    },
9320

    
9321
    getIsEditform: function () {
9322
        return this.iseditform;
9323
    },
9324
    setIsEditform: function (value) {
9325
        var me = this;
9326
        me.iseditform = value;
9327
        return me;
9328
    },
9329
    initComponent: function () {
9330
        var me = this;
9331
        var storename = me.storename;
9332
        if (storename == "" || storename == undefined) {
9333
            storename = "store" + me.tableName;
9334
        }
9335
        var isHired = false;
9336
        nowDate = MinovaUtil.GetNowDate();
9337
        Ext.Ajax.request({
9338
            async: false,
9339
            method: 'POST',
9340
            url: '/UserControl/GetStore',
9341
            params: {
9342
                tableName: 'PHRRC0002',
9343
                param: 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
9344

    
9345
            },
9346
            success: function (response) {
9347
                var results = Ext.decode(response.responseText);
9348
                dataForm = results.data;
9349
                //cek is hired or blacklist
9350
                dataForm_ = $.grep(dataForm, function (r) {
9351
                    return r.ApplicantStatus == '05'
9352
                });
9353
                if (dataForm_.length == 0) {
9354
                    dataForm_ = $.grep(dataForm, function (r) {
9355
                        return r.ApplicantStatus == '99'
9356
                    });
9357
                }
9358
                if (dataForm_ != null && dataForm_.length > 0) {
9359
                    isHired = true;
9360
                }
9361
            }
9362
        });
9363

    
9364
        var tableName = me.tableName;
9365
        Ext.applyIf(me, {
9366
            items: [{
9367
                layoutType: "MinovaGridForm",
9368
                title: me.titlegrid,
9369
                xtype: "minovagrid1",
9370
                tableName: tableName, // nama tebel/dataset
9371
                name: "MinovaGridFormGrid",
9372
                param: me.param, // parameter filteran
9373
                pagesize: me.pagesize, // jumlah record yang muncul per page
9374
                storename: storename, //nama store bebas
9375
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
9376
                height: 330,
9377
                bodyPadding: 0,
9378
                tbar: [{
9379

    
9380
                    xtype: 'button',
9381
                    text: 'Action',
9382
                    name: 'actionGrid',
9383
                    hidden: isHired,
9384
                    menu: [{
9385
                        text: 'Add',
9386
                        name: 'addGrid',
9387
                        action: 'CRUDaddNewRecord',
9388
                        style: 'font-family: FontAwesome',
9389
                        itemId: 'AddData',
9390
                        iconCls: 'fa-plus-circle',
9391
                        hidden: isHired
9392

    
9393
                    }, {
9394
                        text: 'Copy',
9395
                        name: 'CopyGrid',
9396
                        iconCls: 'fa-copy',
9397
                        style: 'font-family: FontAwesome',
9398
                        hidden: isHired
9399
                    }, {
9400
                        text: 'Edit',
9401
                        name: 'EditGrid',
9402
                        iconCls: 'fa-edit',
9403
                        style: 'font-family: FontAwesome',
9404
                        hidden: isHired
9405
                    }, {
9406
                        text: 'Delete',
9407
                        name: 'DeleteGrid',
9408
                        hidden: true,
9409
                        iconCls: 'fa-trash-o',
9410
                        style: 'font-family: FontAwesome',
9411
                    }
9412
                    ],
9413
                    listeners: {
9414
                        afterender: function () {
9415
                            var me = this;
9416
                            nowDate = MinovaUtil.GetNowDate();
9417
                            var isHired = false;
9418
                            Ext.Ajax.request({
9419
                                async: false,
9420
                                method: 'POST',
9421
                                url: '/UserControl/GetStore',
9422
                                params: {
9423
                                    tableName: 'PHRRC0027',
9424
                                    param: 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID") + ',ActivityType[=]8'
9425

    
9426
                                },
9427
                                success: function (response) {
9428
                                    var results = Ext.decode(response.responseText);
9429
                                    dataForm = results.data;
9430
                                    if (dataForm != null) {
9431
                                        isHired = true;
9432
                                    }
9433
                                }
9434
                            });
9435
                            if (isHired) {
9436
                                me.setHidden(true);
9437
                            } else {
9438
                                me.setHidden(false);
9439
                            }
9440

    
9441
                        },
9442

    
9443
                    },
9444
                }, {
9445
                    xtype: 'tbfill'
9446
                }, {
9447
                    text: 'Clear Filters',
9448
                    tooltip: 'Clear all filters',
9449
                    name: 'clearbtn',
9450
                    handler: function () {
9451
                        var tolbar = this.up()
9452
                        var grid_ = tolbar.up()
9453
                        grid_.filters.clearFilters()
9454
                    }
9455
                }, ],
9456

    
9457
                dockedItems: [{
9458
                    xtype: 'pagingtoolbar',
9459
                    store: storename, // harus sama dengan naa store diatas
9460
                    dock: 'bottom', //posisi paging
9461
                    pageSize: me.pagesize,
9462
                    displayInfo: true
9463
                }
9464
                ],
9465

    
9466
            }, {
9467
                xtype: 'minovaform',
9468
                name: "MinovaGridFormDisplay",
9469
                tableName: tableName, // nama tabel /dataset
9470
                isLookup: '', // 1 or 'Y' for lookup
9471
                isDisplay: true, // true== form is displayfield
9472
            }, {
9473
                xtype: 'minovaform',
9474
                name: "MinovaGridFormEdit",
9475
                tableName: tableName, // nama tabel /dataset
9476
                isLookup: '', // 1 or 'Y' for lookup
9477
                isDisplay: false, // true== form is displayfield
9478
            }
9479
            ]
9480
        });
9481
        me.callParent(arguments);
9482
    }
9483
});
9484
//end
9485

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

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

    
9576
                    }, {
9577
                        text: 'Copy',
9578
                        name: 'CopyGrid',
9579
                        iconCls: 'fa-copy',
9580
                        style: 'font-family: FontAwesome',
9581
                    }, {
9582
                        text: 'Edit',
9583
                        name: 'EditGrid',
9584
                        iconCls: 'fa-edit',
9585
                        style: 'font-family: FontAwesome',
9586
                    }, {
9587
                        text: 'Delete',
9588
                        name: 'DeleteGrid',
9589
                        hidden: true,
9590
                        iconCls: 'fa-trash-o',
9591
                        style: 'font-family: FontAwesome',
9592
                    }
9593
                    ]
9594
                }, {
9595
                    xtype: 'tbfill'
9596
                }, {
9597
                    text: 'Clear Filters',
9598
                    tooltip: 'Clear all filters',
9599
                    name: 'clearbtn',
9600
                    handler: function () {
9601
                        var tolbar = this.up()
9602
                        var grid_ = tolbar.up()
9603
                        grid_.filters.clearFilters()
9604
                    }
9605
                }, ],
9606

    
9607
                dockedItems: [{
9608
                    xtype: 'pagingtoolbar',
9609
                    store: storename, // harus sama dengan naa store diatas
9610
                    dock: 'bottom', //posisi paging
9611
                    pageSize: me.pagesize,
9612
                    displayInfo: true
9613
                }
9614
                ],
9615

    
9616
            }, {
9617
                xtype: 'minovaform',
9618
                name: "MinovaGridFormDisplay",
9619
                tableName: tableName, // nama tabel /dataset
9620
                isLookup: '', // 1 or 'Y' for lookup
9621
                isDisplay: true, // true== form is displayfield
9622
            }, {
9623
                xtype: 'minovaform',
9624
                name: "MinovaGridFormEdit",
9625
                tableName: tableName, // nama tabel /dataset
9626
                isLookup: '', // 1 or 'Y' for lookup
9627
                isDisplay: false, // true== form is displayfield
9628
            }
9629
            ]
9630
        });
9631
        me.callParent(arguments);
9632
    }
9633
});
9634

    
9635
Ext.define('MinovaUtil.MinovaES.MinovaCustomization', {
9636
    extend: 'Ext.form.Panel',
9637
    alias: ['widget.minovacustomization', 'widget.MinovaCustomization'],
9638
    controller: 'treeCustomization',
9639
    tableName: undefined, //nama tabel
9640
    param: undefined, //param query
9641
    pagesize: undefined,
9642
    storename: undefined,
9643
    titleform: undefined,
9644
    titlegrid: undefined,
9645
    heightgrid: undefined,
9646
    heightform: undefined,
9647
    iseditform: undefined,
9648
    lastheightform: undefined,
9649
    layoutType: undefined,
9650
    lastpage: undefined,
9651
    lastTitle: undefined,
9652
    collapsibleForm: undefined,
9653
    getLastTitle: function () {
9654
        return this.lastTitle;
9655
    },
9656
    setLastTitle: function (value) {
9657
        var me = this;
9658
        me.lastTitle = value;
9659
        return me;
9660
    },
9661
    getLastpage: function () {
9662
        return this.lastpage;
9663
    },
9664
    setLastpage: function (value) {
9665
        var me = this;
9666
        me.lastpage = value;
9667
        return me;
9668
    },
9669
    getLayoutType: function () {
9670
        return this.layoutType;
9671
    },
9672
    setLayoutType: function (value) {
9673
        var me = this;
9674
        me.layoutType = value;
9675
        return me;
9676
    },
9677
    getLastheightform: function () {
9678
        return this.lastheightform;
9679
    },
9680
    setLastheightform: function (value) {
9681
        var me = this;
9682
        me.lastheightform = value;
9683
        return me;
9684
    },
9685

    
9686
    getIsEditform: function () {
9687
        return this.iseditform;
9688
    },
9689
    setIsEditform: function (value) {
9690
        var me = this;
9691
        me.iseditform = value;
9692
        return me;
9693
    },
9694
    initComponent: function () {
9695
        var me = this;
9696
        var storename = me.storename;
9697
        if (storename == "" || storename == undefined) {
9698
            storename = "store" + me.tableName;
9699
        }
9700
        var tableName = me.tableName;
9701
        var collapsibleForm_ = me.collapsibleForm;
9702
        // if (!collapsibleForm_) {
9703
        //  collapsibleForm_ = false;
9704
        //}
9705
        Ext.applyIf(me, {
9706
            items: [{
9707
                layoutType: "MinovaGridForm",
9708
                title: me.titlegrid,
9709
                xtype: "minovagrid1",
9710
                tableName: tableName, // nama tebel/dataset
9711
                name: "MinovaGridFormGrid",
9712
                param: me.param, // parameter filteran
9713
                pagesize: me.pagesize, // jumlah record yang muncul per page
9714
                storename: storename, //nama store bebas
9715
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
9716
                height: 480,
9717
                bodyPadding: 0,
9718
                tbar: [{
9719
                    xtype: 'button',
9720
                    text: 'Action',
9721
                    name: 'actionGrid',
9722
                    menu: [{
9723
                        text: 'Add',
9724
                        name: 'addGrid',
9725
                        action: 'CRUDaddNewRecord',
9726
                        style: 'font-family: FontAwesome',
9727
                        itemId: 'AddData',
9728
                        iconCls: 'fa-plus-circle',
9729

    
9730
                    }, {
9731
                        text: 'Copy',
9732
                        name: 'CopyGrid',
9733
                        iconCls: 'fa-copy',
9734
                        style: 'font-family: FontAwesome',
9735
                    }, {
9736
                        text: 'Edit',
9737
                        name: 'EditGrid',
9738
                        iconCls: 'fa-edit',
9739
                        style: 'font-family: FontAwesome',
9740
                    }, {
9741
                        text: 'Delete',
9742
                        name: 'DeleteGrid',
9743
                        hidden: true,
9744
                        iconCls: 'fa-trash-o',
9745
                        style: 'font-family: FontAwesome',
9746
                    }
9747
                    ]
9748
                }, {
9749
                    xtype: 'tbfill'
9750
                }, {
9751
                    text: 'Search',
9752
                    tooltip: 'Search',
9753
                    tableName: tableName,
9754
                    name: 'btnSearchCust',
9755
                    handler: function () {
9756
                        //var tolbar = this.up()
9757
                        //var grid_ = tolbar.up()
9758
                        //alert(this.tableName)
9759

    
9760
                    }
9761

    
9762
                }, {
9763
                    text: 'Import/Export',
9764
                    tooltip: 'Import/Export',
9765
                    name: 'Import/Exportbtn',
9766

    
9767
                }, {
9768
                    text: 'Clear Filters',
9769
                    tooltip: 'Clear all filters',
9770
                    name: 'clearbtn',
9771
                    handler: function () {
9772
                        var tolbar = this.up()
9773
                        var grid_ = tolbar.up()
9774
                        grid_.filters.clearFilters()
9775
                    }
9776
                }
9777
                ],
9778

    
9779
                dockedItems: [{
9780
                    xtype: 'pagingtoolbar',
9781
                    store: storename, // harus sama dengan naa store diatas
9782
                    dock: 'bottom', //posisi paging
9783
                    pageSize: me.pagesize,
9784
                    displayInfo: true
9785
                }
9786
                ],
9787

    
9788
            }, {
9789
                xtype: 'minovaform',
9790
                //layout: 'anchor',
9791
                height: '200',
9792
                collapsible: collapsibleForm_,
9793
                name: "MinovaGridFormDisplay",
9794
                tableName: tableName, // nama tabel /dataset
9795
                isLookup: '', // 1 or 'Y' for lookup
9796
                isDisplay: true, // true== form is displayfield
9797
            }, {
9798
                xtype: 'minovaform',
9799
                //layout:'anchor',
9800
                collapsible: collapsibleForm_,
9801
                name: "MinovaGridFormEdit",
9802
                tableName: tableName, // nama tabel /dataset
9803
                isLookup: '', // 1 or 'Y' for lookup
9804
                isDisplay: false, // true== form is displayfield
9805
            }
9806
            ]
9807
        });
9808
        me.callParent(arguments);
9809
    }
9810
});
9811

    
9812
Ext.define('MinovaUtil.view.override.Panel', {
9813
    override: 'Ext.panel.Panel',
9814

    
9815
    print: function (pnl) {
9816

    
9817
        if (!pnl) {
9818
            pnl = this;
9819
        }
9820

    
9821
        // instantiate hidden iframe
9822

    
9823
        var iFrameId = "printerFrame";
9824
        var printFrame = Ext.get(iFrameId);
9825

    
9826
        if (printFrame == null) {
9827
            printFrame = Ext.getBody().appendChild({
9828
                id: iFrameId,
9829
                tag: 'iframe',
9830
                cls: 'x-hidden',
9831
                style: {
9832
                    display: "none"
9833
                }
9834
            });
9835
        }
9836

    
9837
        var cw = printFrame.dom.contentWindow;
9838

    
9839
        // instantiate application stylesheets in the hidden iframe
9840

    
9841
        var stylesheets = "";
9842
        for (var i = 0; i < document.styleSheets.length; i++) {
9843
            stylesheets += Ext.String.format('<link rel="stylesheet" href="{0}" />', document.styleSheets[i].href);
9844
        }
9845

    
9846
        // various style overrides
9847
        stylesheets += ''.concat(
9848
			"<style>",
9849
			".x-panel-body {overflow: visible !important;}",
9850
			// experimental - page break after embedded panels
9851
			// .x-panel {page-break-after: always; margin-top: 10px}",
9852
			"</style>");
9853

    
9854
        // get the contents of the panel and remove hardcoded overflow properties
9855
        var markup = pnl.getEl().dom.innerHTML;
9856
        while (markup.indexOf('overflow: auto;') >= 0) {
9857
            markup = markup.replace('overflow: auto;', '');
9858
        }
9859

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

    
9862
        // output to the iframe
9863
        cw.document.open();
9864
        cw.document.write(str);
9865
        cw.document.close();
9866

    
9867
        // remove style attrib that has hardcoded height property
9868
        cw.document.getElementsByTagName('DIV')[0].removeAttribute('style');
9869

    
9870
        // print the iframe
9871
        cw.print();
9872

    
9873
        // destroy the iframe
9874
        Ext.fly(iFrameId).destroy();
9875

    
9876
    }
9877
});
9878

    
9879
Ext.define('MinovaUtil.MinovaES.MinovaRptForm', {
9880
    extend: 'Ext.form.Panel',
9881
    alias: ['widget.MinovaRptForm', 'widget.minovarptform'],
9882
    ReportID: undefined,
9883
    SelectionType: undefined,
9884
    layout: 'column',
9885
    //frame : true,
9886
    defaults: {
9887
        layout: 'form',
9888
        xtype: 'container',
9889
        defaultType: 'textfield',
9890
        style: 'width: 50%',
9891
        //height: 1000
9892
    },
9893
    initComponent: function () {
9894
        var col1 = [];
9895
        var col2 = [];
9896
        var me = this;
9897
        var hasil = null;
9898
        var hideButton_ = me.hideButton;
9899
        Ext.Ajax.request({
9900
            async: false,
9901
            method: 'POST',
9902
            url: '/UserControl/GetStore',
9903
            params: {
9904
                tableName: 'PDSBS0006',
9905
                //param : "ReportID='" + me.ReportID + "' and SelectionType='" + me.SelectionType + "' and LangId='" + localStorage.LangId + "'"
9906
                param: "ReportID='" + me.ReportID + "',SelectionType='" + me.SelectionType + "',LangId='" + localStorage.LangId + "'"
9907
            },
9908
            success: function (response) {
9909
                var results = Ext.decode(response.responseText);
9910
                hasil = results.data;
9911
                //count = hasil.length
9912
            }
9913
        });
9914
        if (hasil.length > 0) {
9915
            hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
9916
            var me = this;
9917
            Ext.each(hasil, function (rec) {
9918
                var null_ = true;
9919
                if (rec.IsRequired == '1') {
9920
                    null_ = false;
9921
                } else {
9922
                    null_ = true;
9923
                }
9924
                var formfield = MinovaUtil.FieldGenerator.Form(me.name, rec, null_, false, me.tableName, me.isLookup);
9925
                if (isDesk) {
9926
                    if (rec.ColumnNo == 1) {
9927
                        col1.push(formfield);
9928
                    } else {
9929
                        col2.push(formfield);
9930
                    }
9931
                } else {
9932
                    col1.push(formfield);
9933
                }
9934
            });
9935

    
9936
        }
9937
        Ext.applyIf(me, {
9938
            items: [{
9939
                style: 'width: 50%',
9940
                items: col1
9941
            }, {
9942
                style: 'width: 50%',
9943
                items: col2
9944
            }
9945
            ],
9946
        });
9947
        this.callParent();
9948
    }
9949
});
9950

    
9951
Ext.define('MinovaUtil.MinovaES.MinovaRptSimple', {
9952
    extend: 'Ext.form.Panel',
9953
    alias: ['widget.MinovaRptSimple', 'widget.minovarptsimple'],
9954
    //layout: 'column',
9955
    controller: 'basereports-controller',
9956
    ReportID: undefined,
9957
    hideButton: undefined,
9958
    reportLayout: 'simple',
9959
    getReportLayout: function () {
9960
        return this.reportLayout;
9961
    },
9962
    setReportLayout: function (value) {
9963
        var me = this;
9964
        me.reportLayout = value;
9965
        return me;
9966
    },
9967

    
9968
    initComponent: function () {
9969
        var me = this;
9970
        var ReportID = me.ReportID;
9971
        var hideButton_ = me.hideButton;
9972
        var hide_ = false;
9973
        if (hideButton_) {
9974
            hide_ = true;
9975
        }
9976
        Ext.applyIf(me, {
9977
            items: [{
9978
                //title: 'Report Selection',
9979
                xtype: 'minovarptform',
9980
                hideButton: hide_,
9981
                name: 'minovarptsimple',
9982
                ReportID: ReportID,
9983
                SelectionType: '1',
9984
                bodyPadding: 10,
9985
                buttons: [{
9986
                    text: 'Search',
9987
                    name: 'SearchRpt',
9988
                    hidden: hide_
9989
                }, {
9990
                    text: 'Variant',
9991
                    style: 'font-family: FontAwesome',
9992
                    hidden: hide_,
9993
                    menu: [{
9994
                        text: 'Load Variant',
9995
                        name: 'loadvariant',
9996

    
9997
                    }, {
9998
                        text: 'Save Variant',
9999
                        name: 'savevariant',
10000

    
10001
                    }
10002
                    ],
10003

    
10004
                }
10005
                ],
10006

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

    
10022
Ext.define('MinovaUtil.MinovaES.MinovaRptAdvance', {
10023
    extend: 'Ext.form.Panel',
10024
    alias: ['widget.MinovaRptAdvance', 'widget.minovarptadvance'],
10025
    //layout: 'column',
10026
    controller: 'basereports-controller',
10027
    ReportID: undefined,
10028
    reportLayout: 'advance',
10029
    hideButton: undefined,
10030
    getReportLayout: function () {
10031
        return this.reportLayout;
10032
    },
10033
    setReportLayout: function (value) {
10034
        var me = this;
10035
        me.reportLayout = value;
10036
        return me;
10037
    },
10038

    
10039
    initComponent: function () {
10040
        var me = this;
10041
        var ReportID = me.ReportID;
10042
        var hideButton_ = me.hideButton;
10043
        var hide_ = false;
10044
        if (hideButton_) {
10045
            hide_ = true;
10046
        }
10047
        Ext.applyIf(me, {
10048
            items: [{
10049
                //title: 'Report Selection',
10050
                xtype: 'minovarptform',
10051
                hideButton: hide_,
10052
                name: 'minovarptadvance',
10053
                ReportID: ReportID,
10054
                SelectionType: '2',
10055
                bodyPadding: 10,
10056
                buttons: [{
10057
                    text: 'Search',
10058
                    name: 'SearchRpt',
10059
                    hidden: hide_
10060
                }, {
10061
                    text: 'Variant',
10062
                    hidden: hide_,
10063
                    style: 'font-family: FontAwesome',
10064
                    menu: [{
10065
                        text: 'Load Variant',
10066
                        name: 'loadvariant',
10067

    
10068
                    }, {
10069
                        text: 'Save Variant',
10070
                        name: 'savevariant',
10071

    
10072
                    }
10073
                    ],
10074

    
10075
                }
10076
                ],
10077

    
10078
            },
10079
				//{
10080
				//    title: 'Result',
10081
				//    height: 530,
10082
				//    collapsible: false,
10083
				//    name: 'resultPanel',
10084
				//    layout: 'fit',
10085
				//    html: '<div  id="formMdDiv"></div>',
10086
				//}
10087
            ],
10088
        });
10089
        this.callParent();
10090
    }
10091
});
10092

    
10093
Ext.define('MinovaUtil.MinovaES.MinovaRptAll', {
10094
    extend: 'Ext.form.Panel',
10095
    alias: ['widget.MinovaRptAll', 'widget.minovarptall'],
10096
    //layout: 'column',
10097
    controller: 'basereports-controller',
10098
    ReportID: undefined,
10099
    titleSimle: undefined,
10100
    titleAdvance: undefined,
10101
    reportLayout: 'all',
10102
    hideButton: undefined,
10103
    getReportLayout: function () {
10104
        return this.reportLayout;
10105
    },
10106
    setReportLayout: function (value) {
10107
        var me = this;
10108
        me.reportLayout = value;
10109
        return me;
10110
    },
10111

    
10112
    initComponent: function () {
10113
        var me = this;
10114
        var ReportID = me.ReportID;
10115
        var hideButton_ = me.hideButton;
10116
        var hide_ = false;
10117
        if (hideButton_) {
10118
            hide_ = true;
10119
        }
10120
        Ext.applyIf(me, {
10121
            items: [{
10122
                xtype: 'tabpanel',
10123
                name: 'mainTab',
10124
                buttons: [{
10125
                    text: 'Search',
10126
                    name: 'SearchRpt',
10127
                    hidden: hide_,
10128
                }, {
10129
                    text: 'Variant',
10130
                    hidden: hide_,
10131
                    style: 'font-family: FontAwesome',
10132
                    menu: [{
10133
                        text: 'Load Variant',
10134
                        name: 'loadvariant',
10135

    
10136
                    }, {
10137
                        text: 'Save Variant',
10138
                        name: 'savevariant',
10139

    
10140
                    }
10141
                    ],
10142

    
10143
                }
10144
                ],
10145

    
10146
                items: [{
10147
                    title: 'Simple',
10148
                    xtype: 'minovarptform',
10149
                    hideButton: hide_,
10150
                    name: 'simpleForm',
10151
                    ReportID: ReportID,
10152
                    SelectionType: '1',
10153
                    bodyPadding: 10,
10154

    
10155
                }, {
10156
                    title: 'Advance',
10157
                    xtype: 'minovarptform',
10158
                    hideButton: hide_,
10159
                    name: 'advanceForm',
10160
                    ReportID: ReportID,
10161
                    SelectionType: '2',
10162
                    bodyPadding: 10,
10163

    
10164
                }
10165
                ]
10166
            },
10167
				//{
10168
				//    title: 'Result',
10169
				//    height: 530,
10170
				//    collapsible: false,
10171
				//    name: 'resultPanel',
10172
				//    layout: 'fit',
10173
				//    html: '<div  id="formMdDiv"></div>',
10174
				//}
10175

    
10176
            ],
10177
        });
10178
        this.callParent();
10179
    }
10180
});
10181

    
10182
Ext.define('MinovaUtil.MinovaES.MinovaGridRpt', {
10183
    extend: 'Ext.grid.Panel',
10184
    requires: ['Ext.grid.RowNumberer'],
10185
    alias: 'widget.minovagridrpt',
10186
    alternateClassName: 'Ext.grid.MinovaGridRpt',
10187
    features: [{ftype:'grouping'}],
10188
    tableName: undefined,
10189
    param: undefined,
10190
    //pagesize: undefined,
10191
    storename: undefined,
10192
    //layoutType: undefined,
10193
    enableLocking: true,
10194
    tbar: [{
10195
        xtype: 'tbfill'
10196
    }, {
10197
        text: 'Clear Filters',
10198
        tooltip: 'Clear all filters',
10199
        name: 'clearbtn',
10200
        handler: function () {
10201
            var tolbar = this.up()
10202
            var grid_ = tolbar.up()
10203
            grid_.filters.clearFilters()
10204
        }
10205
    }, ],
10206
    getTableName: function () {
10207
        return this.tableName;
10208
    },
10209

    
10210
    initComponent: function () {
10211
        var me = this;
10212
        var cols_ = [];
10213
        var fieldeditor = {};
10214
        var hasil = null;
10215
        var autoLoad = true;
10216
        var _url = 'GetAllField';
10217

    
10218
        Ext.Ajax.request({
10219
            async: false,
10220
            method: 'POST',
10221
            url: '/Devt/' + _url + '?tableName=' + me.tableName,
10222
            success: function (response) {
10223
                var results = Ext.decode(response.responseText);
10224
                hasil = results.data;
10225
            }
10226
        });
10227
        var structure = undefined;
10228
        Ext.Ajax.request({
10229
            async: false,
10230
            method: 'POST',
10231
            url: '/UserControl/GetStore',
10232
            params: {
10233
                tableName: 'SDATATABLEFIELD',
10234
                param: 'TableName[equal]' + me.tableName
10235

    
10236
            },
10237
            success: function (response) {
10238
                var results = Ext.decode(response.responseText);
10239
                data_ = results.data;
10240
                if (data_ != undefined) {
10241
                    structure = data_;
10242
                }
10243
            }
10244
        });
10245
        if (hasil.length > 0) {
10246
            Ext.each(hasil, function (rec) {
10247
                // get field will be summary
10248

    
10249
                var summaryType = undefined;
10250
                if (structure != undefined) {
10251
                    _field = $.grep(structure, function (r) {
10252
                        return r.FieldName == rec.FieldName
10253
                    });
10254
                    summaryType = _field[0].SummaryType
10255
                }
10256

    
10257
                var null_ = null;
10258
                if (rec.IsPrimaryKey == true) {
10259
                    null_ = false;
10260
                }
10261
                if (rec.IsRequired == true) {
10262
                    null_ = false;
10263
                } else {
10264
                    null_ = true;
10265
                }
10266
                if (rec.GridView == 1) {
10267
                    switch (rec.FormatRef) {
10268
                        case "date":
10269
                            cols_.push({
10270
                                xtype: 'minovadatecolumn',
10271
                                text: rec.HeaderTitle,
10272
                                dataIndex: rec.FieldName,
10273
                                summaryType: summaryType,
10274
                                width: 100,
10275
                                filter: {
10276
                                    type: 'date',
10277
                                    itemDefaults: {
10278
                                        emptyText: 'Search for...'
10279
                                    }
10280
                                }
10281
                            });
10282
                            break
10283
                        case "amount":
10284
                            cols_.push({
10285
                                xtype: 'minovacurrancycolumn',
10286
                                align: 'right',
10287
                                text: rec.HeaderTitle,
10288
                                dataIndex: rec.FieldName,
10289
                                summaryType: summaryType,
10290
                                width: 100,
10291
                                filter: {
10292
                                    type: 'number',
10293
                                    itemDefaults: {
10294
                                        emptyText: 'Search for...'
10295
                                    }
10296
                                }
10297
                            });
10298
                            break
10299
                        case "datetime":
10300
                            cols_.push({
10301
                                xtype: 'minovadatetimecolumn',
10302
                                text: rec.HeaderTitle,
10303
                                dataIndex: rec.FieldName,
10304
                                summaryType: summaryType,
10305
                                width: 140,
10306
                                filter: {
10307
                                    type: 'string',
10308
                                    itemDefaults: {
10309
                                        emptyText: 'Search for...'
10310
                                    }
10311
                                }
10312
                            });
10313
                            break
10314
                        default:
10315
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
10316
                                cols_.push({
10317
                                    text: rec.HeaderTitle,
10318
                                    dataIndex: rec.FieldName,
10319
                                    summaryType: summaryType,
10320
                                    width: 100,
10321
                                    filter: {
10322
                                        type: 'string',
10323
                                        itemDefaults: {
10324
                                            emptyText: 'Search for...'
10325
                                        }
10326
                                    }
10327
                                });
10328
                            } else if (rec.TableRef != "") {
10329
                                if (rec.TableRef != null) {
10330
                                    var valueField = null;
10331
                                    var displayValue = null;
10332
                                    Ext.Ajax.request({
10333
                                        async: false,
10334
                                        method: 'POST',
10335
                                        url: '/UserControl/GetStore',
10336
                                        params: {
10337
                                            tableName: 'SDATATABLEFIELD',
10338
                                            param: 'TableName[equal]' + rec.TableRef
10339
                                        },
10340
                                        success: function (response) {
10341
                                            var results = Ext.decode(response.responseText);
10342
                                            data_ = results.data;
10343
                                            if (data_ != undefined) {
10344
                                                valueField_ = $.grep(data_, function (r) {
10345
                                                    return r.ValueField == '1'
10346
                                                });
10347
                                                valueField = valueField_[0].FieldName
10348
                                                displayValue_ = $.grep(data_, function (r) {
10349
                                                    return r.DisplayValue == '1'
10350
                                                });
10351
                                                displayValue = displayValue_[0].FieldName
10352

    
10353
                                            }
10354
                                        }
10355
                                    });
10356
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
10357
                                    var count_ = 0;
10358
                                    if (store_) {
10359
                                        count_ = store_.count();
10360
                                    }
10361
                                    if (count_ == 0) {
10362
                                        Ext.create('Ext.data.Store', {
10363
                                            storeId: 'store_' + rec.FieldName,
10364
                                            autoLoad: true,
10365
                                            proxy: {
10366
                                                method: 'POST',
10367
                                                type: 'ajax',
10368
                                                url: '/UserControl/GetStore',
10369
                                                extraParams: {
10370
                                                    tableName: rec.TableRef,
10371
                                                    param: rec.ParamCombo
10372
                                                },
10373
                                                reader: {
10374
                                                    type: 'json',
10375
                                                    root: 'data',
10376
                                                    totalProperty: 'data[0].TotalCount'
10377
                                                }
10378
                                            }
10379
                                        })
10380
                                    }
10381
                                    cols_.push({
10382
                                        xtype: 'minovacombocolumn',
10383
                                        TableRef: rec.TableRef,
10384
                                        text: rec.HeaderTitle,
10385
                                        summaryType: summaryType,
10386
                                        dataIndex: rec.FieldName,
10387
                                        valueField: valueField,
10388
                                        displayField: displayValue,
10389
                                        store: 'store_' + rec.FieldName,
10390
										renderer: function(value, metaData, record, rowIndex, colIndex, store, view) {
10391
											if(value != undefined || value!=null){
10392
												return '<a href="' + value + '" target = "_blank">' + value + '</a>';
10393
											}
10394
										},											
10395
                                        filter: {
10396
                                            type: 'list',
10397
                                            itemDefaults: {
10398
                                                emptyText: 'Search for...'
10399
                                            }
10400
                                        }
10401
                                    });
10402
                                }
10403

    
10404
                            } else {
10405
                                cols_.push({
10406
                                    text: rec.HeaderTitle,
10407
                                    dataIndex: rec.FieldName,
10408
                                    summaryType: summaryType,
10409
									renderer: function(value, metaData, record, rowIndex, colIndex, store, view) {
10410
										if(value != undefined || value!=null){
10411
											return '<a href="' + value + '" target = "_blank">' + value + '</a>';
10412
										}
10413
									},									
10414
                                    filter: {
10415
                                        itemDefaults: {
10416
                                            emptyText: 'Search for...'
10417
                                        }
10418
                                    }
10419
                                });
10420
                            }
10421
                            break
10422
                    }
10423
                } else {
10424
                    cols_.push({
10425
                        text: rec.HeaderTitle,
10426
                        dataIndex: rec.FieldName,
10427
                        hidden: true,
10428
                        filter: {
10429
                            itemDefaults: {
10430
                                emptyText: 'Search for...'
10431
                            }
10432
                        }
10433
                    });
10434
                }
10435
            });
10436
        };
10437
        var param_ = me.param;
10438
        if (param_ == undefined) {
10439
            param_ = ''
10440
        }
10441
        var jsStoreGrid = new Ext.data.Store({
10442
            storeId: me.storename,
10443
            autoLoad: false,
10444
            //pageSize: me.pagesize,
10445
            proxy: {
10446
                method: 'POST',
10447
                type: 'ajax',
10448
                url: '/UserControl/GetStore',
10449
                //extraParams: {
10450
                //    tableName: me.tableName,
10451
                //    param: param_
10452
                //},
10453
                reader: {
10454
                    type: 'json',
10455
                    root: 'data',
10456
                    totalProperty: 'totalRecords'
10457
                }
10458
            }
10459
        });
10460
        Ext.applyIf(me, {
10461
            autoScroll: true,
10462
            enableLocking: true,
10463
            lockedGridConfig: {
10464
                header: false,
10465
                collapsible: true,
10466
                width: 250,
10467
                forceFit: true,
10468
                listeners: {
10469
                    render: function (grid) {
10470
                        var pagingToolbar = grid.child('pagingtoolbar');
10471
                        if (pagingToolbar) {
10472
                            grid.remove(pagingToolbar, true);
10473
                        }
10474
                    }
10475
                }
10476
            },
10477
            listeners: {
10478
                viewready: function () {
10479
                    if (autoLoad == true) {
10480
                        this.getStore().loadPage(1);
10481
                    }
10482

    
10483
                },
10484
                beforeedit: function () {
10485
                    return false;
10486
                }
10487
            },
10488
            lockedViewConfig: {
10489
                scroll: 'horizontal'
10490
            },
10491
            viewConfig: {
10492
                emptyText: 'No Data Display',
10493
                deferEmptyText: false
10494
            },
10495
            //features: [{
10496
            //    ftype: 'summary'
10497
            //}],
10498
            columns: cols_,
10499

    
10500
            store: jsStoreGrid,
10501

    
10502
            plugins: [{
10503
                ptype: 'gridfilters'
10504
            },
10505

    
10506
            ],
10507

    
10508
        });
10509
        me.callParent(arguments);
10510
    }
10511

    
10512
});
10513

    
10514
Ext.define('MinovaUtil.MinovaES.MinovaEditAbleGrid', {
10515
    extend: 'Ext.form.Panel',
10516
    alias: ['widget.MinovaEditAbleGrid', 'widget.Minovaeditablegrid', 'widget.minovaeditablegrid'],
10517
    requires: [
10518
		'Ext.grid.plugin.CellEditing',
10519
		'Ext.grid.RowNumberer',
10520
		'Ext.grid.Panel',
10521
    ],
10522

    
10523
    //renderTo: 'panel-extjs',
10524
    anchor: '100%',
10525
    tableName: undefined,
10526
    hideButton: undefined,
10527
    multiSelect: undefined,
10528
    initComponent: function () {
10529
        var me = this;
10530
        var isLookup = me.isLookup;
10531
        var hide_ = false;
10532
        var widthLock = 250;
10533
        var checkSelection = '';
10534

    
10535
        if (me.hideButton == true) {
10536
            hide_ = true;
10537
        }
10538
        if (me.multiSelect) {
10539
            locking = false;
10540
            checkSelection = 'checkboxmodel';
10541
            widthLock = 40;
10542
        }
10543
        var tableName = me.tableName;
10544
        var cols = [];
10545
        var fieldStore = [];
10546
        var _url = 'GetAllField';
10547
        var hasil = null;
10548
        var height = me.height;
10549
        var storeID = 'store' + me.tableName;
10550
        var gridName = 'grid' + me.name;
10551
        if (me.storeName) {
10552
            storeID = me.storeName;
10553
        }
10554
        var LangID = MinovaUtil.GetLangID();
10555
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
10556
        Ext.Ajax.request({
10557
            async: false,
10558
            method: 'POST',
10559
            url: '/UserControl/GetStore',
10560
            params: {
10561
                tableName: 'PDSBS0007',
10562
                param: parameter
10563
            },
10564
            success: function (response) {
10565
                var results = Ext.decode(response.responseText);
10566
                hasil = results.data;
10567
            }
10568
        });
10569
        cols.push({
10570
            xtype: 'rownumberer'
10571
        });
10572
        var addData = 'var data={';
10573
        if (hasil.length > 0) {
10574
            Ext.each(hasil, function (rec) {
10575
                fieldStore.push(rec.FieldName);
10576
                if (rec.FieldName != 'Sequence') {
10577
                    addData = addData + rec.FieldName + ":" + "'',";
10578
                }
10579

    
10580
                var null_ = null;
10581
                var ReadOnly_ = false;
10582
                if (rec.IsPrimaryKey == true) {
10583
                    null_ = false;
10584
                }
10585
                if (rec.IsRequired == true) {
10586
                    null_ = false;
10587
                } else {
10588
                    null_ = true;
10589
                }
10590
                if (rec.ReadOnly == '1') {
10591
                    ReadOnly_ = true;
10592
                }
10593
                var Hidden_ = false;
10594
                if (rec.ReadOnly == '1') {
10595
                    ReadOnly_ = true;
10596
                }
10597

    
10598
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
10599
                    Hidden_ = true;
10600
                    null_ = true;
10601
                }
10602

    
10603
                if (rec.GridView == 1) {
10604
                    switch (rec.FormatRef) {
10605
                        case "date":
10606
                            cols.push({
10607
                                xtype: 'minovadatecolumn',
10608
                                hidden: Hidden_,
10609
                                text: rec.HeaderTitle,
10610
                                dataIndex: rec.FieldName,
10611
                                filter: {
10612
                                    itemDefaults: {
10613
                                        emptyText: 'Search for...',
10614

    
10615
                                    }
10616
                                },
10617
                                editor: {
10618
                                    allowBlank: null_,
10619
                                    xtype: 'datefield',
10620
                                    hideMode: 'visibility',
10621
                                    readOnly: ReadOnly_,
10622
                                    id: tableName + rec.FieldName,
10623
                                    fieldGrid: rec.FieldName,
10624
                                    nameTable: rec.TableName,
10625
                                }
10626
                            });
10627
                            break
10628
                        case "amount":
10629
                            cols.push({
10630
                                xtype: 'minovacurrancycolumn',
10631
                                //renderer: Ext.util.Format.numberRenderer("0,0"),
10632
                                text: rec.HeaderTitle,
10633
                                align: 'right',
10634
                                dataIndex: rec.FieldName,
10635
                                hidden: Hidden_,
10636
                                filter: {
10637
                                    itemDefaults: {
10638
                                        emptyText: 'Search for...'
10639
                                    }
10640
                                },
10641
                                editor: {
10642
                                    allowBlank: null_,
10643
                                    xtype: 'minovacurrencyfield',
10644
                                    //renderer: Ext.util.Format.numberRenderer("0,0"),
10645
                                    //vtype: 'validateDecimal',
10646
                                    readOnly: ReadOnly_,
10647
                                    id: tableName + rec.FieldName,
10648
                                    nameTable: rec.TableName,
10649
                                    fieldGrid: rec.FieldName,
10650
                                    fieldStyle: 'text-align:right;',
10651
                                    value: '0',
10652
									listeners: { //// add by Tri nwh 20220711
10653
										change: function (val, recs) {
10654
											var fvalue = val.getValue();
10655
											var custumFunc = rec.SelectFunction;
10656
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
10657
												Ext.Ajax.request({
10658
													async: false,
10659
													method: 'POST',
10660
													url: '/UserControl/GetStore',
10661
													params: {
10662
														tableName: 'PCMFUNC',
10663
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
10664
													},
10665
													success: function (response) {
10666
														var results = Ext.decode(response.responseText);
10667
														var dt = results.data[0];
10668
														if (dt != undefined) {
10669
															custumFunc = dt.FunctionCode;
10670
														}
10671
													}
10672
												});
10673
											}
10674
											if (custumFunc) {
10675
												eval(custumFunc)
10676
											}
10677
										}
10678
									}
10679
                                }
10680
                            });
10681
                            break
10682
                        case "time":
10683
                            var DefaultValue = rec.DefaultValue;
10684
                            if (DefaultValue == '') {
10685
                                defaultValue = '00:00';
10686
                            }
10687
                            cols.push({
10688
                                //xtype: 'minovatimecolumn',
10689
                                xtype: 'timefield',
10690
                                format: 'H:i',
10691
                                submitFormat: 'Hi',
10692
                                text: rec.HeaderTitle,
10693
                                dataIndex: rec.FieldName,
10694
                                hidden: Hidden_,
10695
                                //renderer: Ext.util.Format.dateRenderer('G:i'),
10696
                                filter: {
10697
                                    itemDefaults: {
10698
                                        emptyText: 'Search for...'
10699
                                    }
10700
                                },
10701
                                editor: {
10702
                                    allowBlank: null_,
10703
                                    xtype: 'timefield',
10704
                                    readOnly: ReadOnly_,
10705
                                    id: tableName + rec.FieldName,
10706
                                    format: 'H:i',
10707
                                    submitFormat: 'Hi',
10708
                                    increment: 5,
10709
                                    value: DefaultValue,
10710
                                    anchor: '100%',
10711
                                    listeners: {}
10712
                                    //renderer: Ext.util.Format.dateRenderer('G:i'),
10713
                                }
10714
                            });
10715
                            break
10716
                            //case "datetime":
10717
                            //    if (rec.DataRef != 'CREATEDT' && rec.DataRef != 'CHANGEDT') {
10718
                            //        cols.push({
10719
                            //            xtype: 'minovadatetimecolumn',
10720
                            //            text: rec.HeaderTitle,
10721
                            //            dataIndex: rec.FieldName,
10722
                            //            filter: {
10723
                            //                itemDefaults: {
10724
                            //                    emptyText: 'Search for...'
10725
                            //                }
10726
                            //            },
10727
                            //            editor: {
10728
                            //                allowBlank: null_,
10729
                            //                xtype: 'textfield',
10730
                            //            }
10731
                            //        });
10732
                            //    }
10733
                            //    break
10734
                        default:
10735
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
10736
                                cols.push({
10737
                                    text: rec.HeaderTitle,
10738
                                    dataIndex: rec.FieldName,
10739
                                    width: 100,
10740
                                    filter: {
10741
                                        type: 'string',
10742
                                        itemDefaults: {
10743
                                            emptyText: 'Search for...'
10744
                                        }
10745
                                    }
10746
                                });
10747
                            } else if (rec.SearchType == '0') {
10748
                                var valueField = null;
10749
                                var displayValue = null;
10750
                                var TableRef = undefined;
10751
                                if (rec.TableRef != '') {
10752
                                    TableRef = rec.TableRef;
10753

    
10754
                                    Ext.Ajax.request({
10755
                                        async: false,
10756
                                        method: 'POST',
10757
                                        url: '/UserControl/GetStore',
10758
                                        params: {
10759
                                            tableName: 'SDATATABLEFIELD',
10760
                                            param: 'TableName[equal]' + rec.TableRef
10761
                                        },
10762
                                        success: function (response) {
10763
                                            var results = Ext.decode(response.responseText);
10764
                                            data_ = results.data;
10765
                                            if (data_ != undefined) {
10766
                                                valueField_ = $.grep(data_, function (r) {
10767
                                                    return r.ValueField == '1'
10768
                                                });
10769
                                                valueField = valueField_[0].FieldName
10770
                                                displayValue_ = $.grep(data_, function (r) {
10771
                                                    return r.DisplayValue == '1'
10772
                                                });
10773
                                                displayValue = displayValue_[0].FieldName
10774
                                            }
10775
                                        }
10776
                                    });
10777

    
10778
                                    //create Store
10779
                                    Ext.create('Ext.data.Store', {
10780
                                        storeId: 'store_' + me.tableName + rec.FieldName,
10781
                                        autoLoad: true,
10782
                                        proxy: {
10783
                                            method: 'POST',
10784
                                            type: 'ajax',
10785
                                            url: '/UserControl/GetStoreAuth',
10786
                                            extraParams: {
10787
                                                tableName: TableRef,
10788
                                                param: rec.ParamCombo,
10789
                                                menuId: MinovaUtil.GetMenuID()
10790
                                            },
10791
                                            reader: {
10792
                                                type: 'json',
10793
                                                root: 'data',
10794
                                                totalProperty: 'data[0].TotalCount'
10795
                                            }
10796
                                        }
10797
                                    });
10798
                                } else if (rec.FixedValue != '') {
10799
                                    var storeData = [];
10800
                                    var str = rec.FixedValue;
10801
                                    var hasil = str.split('||');
10802
                                    hasil.forEach(function (h) {
10803
                                        store_ = h.split('=')
10804
                                        storeData.push({
10805
                                            code: store_[0],
10806
                                            desc: store_[1],
10807

    
10808
                                        });
10809
                                    });
10810

    
10811
                                    valueField = 'code';
10812
                                    displayValue = 'desc';
10813

    
10814
                                    Ext.create('Ext.data.Store', {
10815
                                        storeId: 'store_' + me.tableName + rec.FieldName,
10816
                                        autoLoad: true,
10817
                                        data: storeData
10818
                                    })
10819
                                }
10820

    
10821
                                cols.push({
10822
                                    xtype: 'minovacombocolumn',
10823
                                    hidden: Hidden_,
10824
                                    text: rec.HeaderTitle,
10825
                                    dataIndex: rec.FieldName,
10826
                                    valueField: valueField,
10827
                                    displayField: displayValue,
10828
                                    store: 'store_' + me.tableName + rec.FieldName,
10829
                                    editor: {
10830
                                        allowBlank: null_,
10831
                                        xtype: 'combobox',
10832
                                        readOnly: ReadOnly_,
10833
                                        id: tableName + rec.FieldName,
10834
                                        nameTable: rec.TableName,
10835
                                        fieldGrid: rec.FieldName,
10836
                                        valueField: valueField,
10837
                                        displayField: displayValue,
10838
                                        vtype: 'validateCombobox',
10839
                                        store: 'store_' + me.tableName + rec.FieldName,
10840
                                    },
10841
                                    filter: {
10842
                                        type: 'list',
10843
                                        itemDefaults: {
10844
                                            emptyText: 'Search for...'
10845
                                        }
10846
                                    }
10847
                                });
10848

    
10849
                            } else if (rec.SearchType == '5') {							
10850
                                var valueField = null;
10851
                                var displayValue = null;
10852
                                var AdditionaldisplayValue = null;
10853
                                var TableRef = undefined;
10854
                                if (rec.TableRef != '') {
10855
                                    TableRef = rec.TableRef;
10856
                                    Ext.Ajax.request({
10857
                                        async: false,
10858
                                        method: 'POST',
10859
                                        url: '/UserControl/GetStore',
10860
                                        params: {
10861
                                            tableName: 'SDATATABLEFIELD',
10862
                                            param: 'TableName[equal]' + rec.TableRef
10863
                                        },
10864
                                        success: function (response) {
10865
                                            var results = Ext.decode(response.responseText);
10866
                                            data_ = results.data;
10867
                                            if (data_ != undefined) {
10868
                                                valueField_ = $.grep(data_, function (r) {
10869
                                                    return r.ValueField == '1'
10870
                                                });
10871
                                                if (valueField_.length > 0) {
10872
                                                    valueField = valueField_[0].FieldName
10873
                                                }
10874

    
10875
                                                displayValue_ = $.grep(data_, function (r) {
10876
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
10877
                                                });
10878
                                                if (displayValue_.length > 0) {
10879
                                                    displayValue = displayValue_[0].FieldName;
10880
                                                }
10881
                                                if (displayValue_.length >= 2) {
10882
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
10883
                                                }
10884
                                            }
10885
                                        }
10886
                                    });
10887
                                }
10888
                                Ext.create('Ext.data.Store', {
10889
                                    storeId: 'store_' + me.tableName + rec.FieldName,
10890
                                    autoLoad: true,
10891
                                    proxy: {
10892
                                        method: 'POST',
10893
                                        type: 'ajax',
10894
                                        url: '/UserControl/GetStoreAuth',
10895
                                        extraParams: {
10896
                                            tableName: TableRef,
10897
                                            param: rec.ParamCombo,
10898
                                            menuId: MinovaUtil.GetMenuID()
10899
                                        },
10900
                                        reader: {
10901
                                            type: 'json',
10902
                                            root: 'data',
10903
                                            totalProperty: 'data[0].TotalCount'
10904
                                        }
10905
                                    }
10906
                                });
10907
                                cols.push({
10908
                                    xtype : 'minovacombocolumn',
10909
                                    hidden: Hidden_,
10910
                                    text: rec.HeaderTitle,
10911
                                    dataIndex: rec.FieldName,
10912
                                    valueField : valueField,
10913
                                    displayField : displayValue,
10914
                                    store : 'store_' + me.tableName + rec.FieldName,
10915
                                    tpl: Ext.create('Ext.XTemplate',
10916
                                            '<ul class="x-list-plain"><tpl for=".">',
10917
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
10918
                                            '</tpl></ul>'),
10919
                                    displayTpl: Ext.create('Ext.XTemplate',
10920
                                        '<tpl for=".">',
10921
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
10922
                                        '</tpl>'),
10923
                                    editor: {
10924
                                        allowBlank: null_,
10925
                                        xtype: 'combobox',
10926
                                        readOnly: ReadOnly_,
10927
                                        id: rec.TableName + rec.FieldName,
10928
                                        nameTable: rec.TableName,
10929
                                        fieldGrid: rec.FieldName,
10930
                                        valueField: valueField,
10931
                                        displayField: displayValue,
10932
                                        store: 'store_' + me.tableName + rec.FieldName,
10933
                                        value: rec.DefaultValue,
10934
                                        tpl: Ext.create('Ext.XTemplate',
10935
                                            '<ul class="x-list-plain"><tpl for=".">',
10936
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
10937
                                            '</tpl></ul>'),
10938
                                        displayTpl: Ext.create('Ext.XTemplate',
10939
                                            '<tpl for=".">',
10940
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
10941
                                            '</tpl>')
10942
                                    },
10943
                                    renderer: function (value) {
10944
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
10945
                                        var index = store.find(valueField, value);
10946
                                        var val = "";
10947
                                        if (index != -1) {
10948
                                            var rc = store.getAt(index);
10949
                                            //val = rc.get(displayValue);
10950
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
10951
                                        } else {
10952
                                            val = value;
10953
                                        }
10954
                                        return val;
10955
                                    },
10956
                                    filter: {
10957
                                        type: 'list',
10958
                                        itemDefaults: {
10959
                                            emptyText: 'Search for...'
10960
                                        }
10961
                                    }
10962
                                });
10963
                            } else if (rec.SearchType == '2') {
10964
                                var triger = (rec.TriggerCombo).split('$');
10965
                                var targetField_ = triger[0];
10966
                                var fieldValue_ = triger[1];
10967
                                cols.push({
10968
                                    text: rec.HeaderTitle,
10969
                                    hidden: Hidden_,
10970
                                    dataIndex: rec.FieldName,
10971
                                    filter: {
10972
                                        itemDefaults: {
10973
                                            emptyText: 'Search for...'
10974
                                        }
10975
                                    },
10976
                                    editor: {
10977
                                        allowBlank: null_,
10978
                                        xtype: 'minovalookupgrid',
10979
                                        readOnly: ReadOnly_,
10980
                                        isGrid: true,
10981
                                        fieldTarget: targetField_,
10982
                                        fieldValue: fieldValue_,
10983
                                        isGrid: true,
10984
                                        id: tableName + rec.FieldName,
10985
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
10986
                                        triggerCls: 'x-form-search-trigger',
10987
                                        vtype: 'alphanum', // disable space
10988
                                        nameTable: rec.TableName,
10989
                                        fieldGrid: rec.FieldName,
10990
                                        LookupFunction: rec.LookupFunction,
10991
                                        listeners: {
10992
                                            change: function (val) {
10993
                                                var custumFunc = rec.SelectFunction;
10994
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
10995
                                                    Ext.Ajax.request({
10996
                                                        async: false,
10997
                                                        method: 'POST',
10998
                                                        url: '/UserControl/GetStore',
10999
                                                        params: {
11000
                                                            tableName: 'PCMFUNC',
11001
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11002
                                                        },
11003
                                                        success: function (response) {
11004
                                                            var results = Ext.decode(response.responseText);
11005
                                                            data_ = results.data[0];
11006
                                                            if (data_ != undefined) {
11007
                                                                custumFunc = data_.FunctionCode;
11008
                                                            }
11009
                                                        }
11010
                                                    });
11011
                                                }
11012
                                                if (custumFunc) {
11013
                                                    eval(custumFunc)
11014
                                                }
11015
                                            }
11016
                                        }
11017
                                    }
11018
                                });
11019
                            } else if (rec.SearchType == '3') {
11020
                                cols.push({
11021
                                    text: rec.HeaderTitle,
11022
                                    hidden: Hidden_,
11023
                                    dataIndex: rec.FieldName,
11024
                                    filter: {
11025
                                        itemDefaults: {
11026
                                            emptyText: 'Search for...'
11027
                                        }
11028
                                    },
11029
                                    editor: {
11030
                                        allowBlank: null_,
11031
										formname: gridName, //YN 220718
11032
                                        // xtype: 'minovalookuptreePopup',
11033
                                        xtype: 'MinovaLookupTree',
11034
                                        readOnly: ReadOnly_,
11035
                                        id: tableName + rec.FieldName,
11036
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11037
                                        triggerCls: 'x-form-search-trigger',
11038
                                        //vtype: 'alphanum', // disable space
11039
                                        treeSructure: rec.SearchFunction, //'O-O-P',
11040
                                        objClassValue: rec.ParamCombo, //'O',
11041
                                        nameTable: rec.TableName,
11042
                                        fieldGrid: rec.FieldName,
11043
                                        listeners: {
11044
                                            change: function (val) {
11045
                                                var custumFunc = rec.SelectFunction;
11046
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11047
                                                    Ext.Ajax.request({
11048
                                                        async: false,
11049
                                                        method: 'POST',
11050
                                                        url: '/UserControl/GetStore',
11051
                                                        params: {
11052
                                                            tableName: 'PCMFUNC',
11053
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11054
                                                        },
11055
                                                        success: function (response) {
11056
                                                            var results = Ext.decode(response.responseText);
11057
                                                            data_ = results.data[0];
11058
                                                            if (data_ != undefined) {
11059
                                                                custumFunc = data_.FunctionCode;
11060
                                                            }
11061
                                                        }
11062
                                                    });
11063
                                                }
11064
                                                if (custumFunc) {
11065
                                                    eval(custumFunc)
11066
                                                }
11067
                                            }
11068
                                        }
11069
                                    }
11070
                                });
11071
                            } 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) {
11072
                                var triger = (rec.TriggerCombo).split('&');
11073
                                var targetField_ = triger[0];
11074
                                var fieldValue_ = triger[0];
11075
                                cols.push({
11076
                                    text: rec.HeaderTitle,
11077
                                    hidden: Hidden_,
11078
                                    dataIndex: rec.FieldName,
11079
                                    filter: {
11080
                                        itemDefaults: {
11081
                                            emptyText: 'Search for...'
11082
                                        }
11083
                                    },
11084
                                    editor: {
11085
                                        allowBlank: null_,
11086
                                        xtype: 'lookupemployee',
11087
                                        readOnly: ReadOnly_,
11088
                                        isGrid: true,
11089
                                        fieldTarget: targetField_,
11090
                                        fieldValue: fieldValue_,
11091
                                        isGrid: true,
11092
                                        id: tableName + rec.FieldName,
11093
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11094
                                        triggerCls: 'x-form-search-trigger',
11095
                                        vtype: 'alphanum', // disable space
11096
                                        nameTable: rec.TableName,
11097
                                        fieldGrid: rec.FieldName,
11098
                                        listeners: {
11099
                                            change: function (val) {
11100
                                                var custumFunc = rec.SelectFunction;
11101
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11102
                                                    Ext.Ajax.request({
11103
                                                        async: false,
11104
                                                        method: 'POST',
11105
                                                        url: '/UserControl/GetStore',
11106
                                                        params: {
11107
                                                            tableName: 'PCMFUNC',
11108
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11109
                                                        },
11110
                                                        success: function (response) {
11111
                                                            var results = Ext.decode(response.responseText);
11112
                                                            data_ = results.data[0];
11113
                                                            if (data_ != undefined) {
11114
                                                                custumFunc = data_.FunctionCode;
11115
                                                            }
11116
                                                        }
11117
                                                    });
11118
                                                }
11119
                                                if (custumFunc) {
11120
                                                    eval(custumFunc)
11121
                                                }
11122
                                            }
11123
                                        }
11124
                                    }
11125
                                });
11126
                            } else if (rec.SearchType == '4' && isLookup != true) {
11127
                                cols.push({
11128

    
11129
                                    text: rec.HeaderTitle,
11130
                                    hidden: Hidden_,
11131
                                    dataIndex: rec.FieldName,
11132
                                    filter: {
11133
                                        itemDefaults: {
11134
                                            emptyText: 'Search for...'
11135
                                        }
11136
                                    },
11137
                                    editor: {
11138
                                        allowBlank: null_,
11139
                                        xtype: 'lookupemployee',
11140
                                        readOnly: ReadOnly_,
11141
                                        isGrid: true,
11142
                                        fieldTarget: targetField_,
11143
                                        fieldValue: fieldValue_,
11144
                                        isGrid: true,
11145
                                        id: tableName + rec.FieldName,
11146
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11147
                                        triggerCls: 'x-form-search-trigger',
11148
                                        vtype: 'alphanum', // disable space
11149
                                        nameTable: rec.TableName,
11150
                                        fieldGrid: rec.FieldName,
11151
                                        listeners: {
11152
                                            change: function (val) {
11153
                                                var custumFunc = rec.SelectFunction;
11154
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11155
                                                    Ext.Ajax.request({
11156
                                                        async: false,
11157
                                                        method: 'POST',
11158
                                                        url: '/UserControl/GetStore',
11159
                                                        params: {
11160
                                                            tableName: 'PCMFUNC',
11161
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11162
                                                        },
11163
                                                        success: function (response) {
11164
                                                            var results = Ext.decode(response.responseText);
11165
                                                            data_ = results.data[0];
11166
                                                            if (data_ != undefined) {
11167
                                                                custumFunc = data_.FunctionCode;
11168
                                                            }
11169
                                                        }
11170
                                                    });
11171
                                                }
11172
                                                if (custumFunc) {
11173
                                                    eval(custumFunc)
11174
                                                }
11175
                                            }
11176
                                        }
11177
                                    }
11178
                                });
11179
                            } else {
11180
                                if (rec.FieldDataType == 3) { //add by taufan
11181
                                    cols.push({
11182
                                        text: rec.HeaderTitle,
11183
                                        hidden: Hidden_,
11184
                                        dataIndex: rec.FieldName,
11185
                                        filter: {
11186
                                            itemDefaults: {
11187
                                                emptyText: 'Search for...'
11188
                                            }
11189
                                        },
11190
                                        editor: {
11191
                                            allowBlank: null_,
11192
                                            xtype: 'textfield',
11193
                                            readOnly: ReadOnly_,
11194
                                            id: tableName + rec.FieldName,
11195
                                            nameTable: rec.TableName,
11196
                                            fieldGrid: rec.FieldName,
11197
                                            vtype: 'validateDecimal',
11198
                                            maxLength: rec.Length,
11199
                                            precision: rec.Prec,
11200
                                            fieldStyle: 'text-align:right;',
11201
                                            listeners: {
11202
                                                change: function (val) {
11203
                                                    var custumFunc = null;
11204
                                                    Ext.Ajax.request({
11205
                                                        async: false,
11206
                                                        method: 'POST',
11207
                                                        url: '/UserControl/GetStore',
11208
                                                        params: {
11209
                                                            tableName: 'SDATATABLEFIELD',
11210
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
11211
                                                        },
11212
                                                        success: function (response) {
11213
                                                            var results = Ext.decode(response.responseText);
11214
                                                            data_ = results.data[0];
11215
                                                            if (data_ != undefined) {
11216
                                                                custumFunc = data_.SelectFunction;
11217
                                                                //console.log(data_)
11218
                                                            }
11219
                                                        }
11220
                                                    });
11221

    
11222
                                                    if (custumFunc) {
11223
                                                        eval(custumFunc)
11224
                                                    }
11225
                                                }
11226
                                            }
11227
                                        }
11228
                                    });
11229
                                } else {
11230
                                    cols.push({
11231
                                        text: rec.HeaderTitle,
11232
                                        hidden: Hidden_,
11233
                                        dataIndex: rec.FieldName,
11234
                                        filter: {
11235
                                            itemDefaults: {
11236
                                                emptyText: 'Search for...'
11237
                                            }
11238
                                        },
11239
                                        editor: {
11240
                                            allowBlank: null_,
11241
                                            xtype: 'textfield',
11242
                                            readOnly: ReadOnly_,
11243
                                            id: tableName + rec.FieldName,
11244
                                            nameTable: rec.TableName,
11245
                                            fieldGrid: rec.FieldName,
11246
                                            listeners: {
11247
                                                change: function (val) {
11248
                                                    var custumFunc = null;
11249
                                                    Ext.Ajax.request({
11250
                                                        async: false,
11251
                                                        method: 'POST',
11252
                                                        url: '/UserControl/GetStore',
11253
                                                        params: {
11254
                                                            tableName: 'SDATATABLEFIELD',
11255
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
11256
                                                        },
11257
                                                        success: function (response) {
11258
                                                            var results = Ext.decode(response.responseText);
11259
                                                            data_ = results.data[0];
11260
                                                            if (data_ != undefined) {
11261
                                                                custumFunc = data_.SelectFunction;
11262
                                                                //console.log(data_)
11263
                                                            }
11264
                                                        }
11265
                                                    });
11266

    
11267
                                                    if (custumFunc) {
11268
                                                        eval(custumFunc)
11269
                                                    }
11270
                                                }
11271
                                            }
11272
                                        }
11273
                                    });
11274
                                }
11275
                            }
11276

    
11277
                            break
11278

    
11279
                    }
11280
                } else {
11281
                    cols.push({
11282
                        text: rec.HeaderTitle,
11283
                        hidden: Hidden_,
11284
                        dataIndex: rec.FieldName,
11285
                        hidden: true,
11286
                        editor: {
11287
                            allowBlank: true,
11288
                            xtype: 'textfield',
11289
                            readOnly: ReadOnly_,
11290
                            id: tableName + rec.FieldName,
11291
                            nameTable: rec.TableName,
11292
                            fieldGrid: rec.FieldName,
11293
                        },
11294
                        filter: {
11295
                            itemDefaults: {
11296
                                emptyText: 'Search for...'
11297
                            }
11298
                        }
11299
                    });
11300
                }
11301
            });
11302

    
11303
        };
11304
        addData = addData + "}";
11305
        Ext.applyIf(me, {
11306
            items: [{
11307
                xtype: 'grid',
11308
                id: gridName,
11309
                name: gridName,
11310
                height: height,
11311
                viewConfig: {
11312
                    emptyText: 'No Data Display',
11313
                    deferEmptyText: false,
11314
                    //Add Nana For Autosize Column Mode
11315
                    listeners: {
11316
                        refresh: function (dataview) {
11317
                            Ext.each(dataview.panel.columns, function (column) {
11318
                                //if (column.autoSizeColumn == false)
11319
                                //	column.autoSizeColumn = true;
11320
                                column.autoSize();
11321
                                //dataview.store.reload();
11322
                            })
11323
                        }
11324
                    },
11325
                    render: function (comp) {
11326
                        comp.getStore().reload();
11327
                        console.log(comp);
11328
                    }
11329
                },
11330
                //store: 'gridStore',
11331
                store: Ext.create('Ext.data.Store', {
11332
                    storeId: storeID,
11333
                    fields: fieldStore,
11334
                    proxy: {
11335
                        method: 'POST',
11336
                        type: 'ajax',
11337
                        url: '',
11338
                        reader: {
11339
                            type: 'json',
11340
                            root: 'data'
11341
                        }
11342
                    }
11343
                }),
11344
                dockedItems: [{
11345
                    xtype: 'toolbar',
11346
                    items: [{
11347
                        text: 'Add',
11348
                        hidden: hide_,
11349
                        name: tableName + 'Add',
11350
                        iconCls: 'fa-plus-circle',
11351
                        style: 'font-family: FontAwesome',
11352
                        handler: function () {
11353
                            var store = Ext.StoreMgr.lookup(storeID)
11354
                            idx = store.getCount();
11355
                            var action = getParam('action');
11356
                            var data = '';
11357
                            var Sequence = 0;
11358
                            if (idx == 0) {
11359
                                Sequence = 1;
11360
                            } else {
11361
                                Sequence = 1 + idx;
11362
                            }
11363
                            //data = {
11364
                            //    Sequence: Sequence
11365
                            //};
11366

    
11367
                            var seq = 'Sequence';
11368
                            var SequenceValue = Sequence;
11369
                            eval(addData);
11370
                            data[seq] = SequenceValue;
11371

    
11372
                            store.insert(idx, data);
11373
                        }
11374

    
11375
                    }, {
11376
                        text: 'Delete',
11377
                        hidden: hide_,
11378
                        name: tableName + 'DeleteText',
11379
                        iconCls: 'fa-trash-o',
11380
                        style: 'font-family: FontAwesome',
11381
                        //disabled: true
11382
                        handler: function () {
11383
                            var me = this,
11384
                            store = Ext.StoreMgr.lookup(storeID)
11385

    
11386
                            var grid = Ext.getCmp(gridName);
11387

    
11388
                            Ext.MessageBox.show({
11389
                                title: 'Remove tab',
11390
                                msg: "This will remove. Do you want to continue?",
11391
                                buttons: Ext.MessageBox.YESNO,
11392
                                fn: function (choice) {
11393
                                    console.log(choice);
11394
                                    if (choice === 'yes') {
11395
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
11396
                                        if (selection) {
11397
                                            store.remove(selection);
11398
                                        }
11399
                                    }
11400
                                    //delete panel.pendingClose;
11401
                                }
11402
                            });
11403
                        }
11404

    
11405
                    }
11406
                    ]
11407
                }
11408
                ],
11409
                columns: cols,
11410
                selType: checkSelection,
11411
                //selType: 'rowmodel',
11412
                plugins: {
11413
                    ptype: 'rowediting',
11414
                    pluginId: 'rowEditing',
11415
                    clicksToEdit: 0,
11416
                    listeners: {
11417
                        //edit: 'onGridEditorEdit'
11418
                    }
11419
                }
11420
            }, ]
11421

    
11422
        });
11423

    
11424
        me.callParent(arguments);
11425
    }
11426
});
11427

    
11428
Ext.define('MinovaUtil.MinovaES.MinovaCellEditGrid', {
11429
    extend: 'Ext.form.Panel',
11430
    alias: ['widget.MinovaCellEditGrid', 'widget.minovacelleditgrid'],
11431
    requires: [
11432
		'Ext.grid.plugin.CellEditing',
11433
		'Ext.grid.Panel',
11434
    ],
11435

    
11436
    //renderTo: 'panel-extjs',
11437
    anchor: '100%',
11438
    tableName: undefined,
11439
    hideButton: undefined,
11440
    multiSelect: undefined,
11441
    initComponent: function () {
11442
        var me = this;
11443
        var isLookup = me.isLookup;
11444
        var hide_ = false;
11445
        var widthLock = 250;
11446
        var checkSelection = '';
11447

    
11448
        if (me.hideButton == true) {
11449
            hide_ = true;
11450
        }
11451
        if (me.multiSelect) {
11452
            locking = false;
11453
            checkSelection = 'checkboxmodel';
11454
            widthLock = 40;
11455
        }
11456
        var tableName = me.tableName;
11457
        var cols = [];
11458
        var fieldStore = [];
11459
        var _url = 'GetAllField';
11460
        var hasil = null;
11461
        var height = me.height;
11462
        var storeID = 'store' + me.tableName;
11463
        var gridName = 'grid' + me.name;
11464
        if (me.storeName) {
11465
            storeID = me.storeName;
11466
        }
11467
        var LangID = MinovaUtil.GetLangID();
11468
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
11469
        Ext.Ajax.request({
11470
            async: false,
11471
            method: 'POST',
11472
            url: '/UserControl/GetStore',
11473
            params: {
11474
                tableName: 'PDSBS0007',
11475
                param: parameter
11476
            },
11477
            success: function (response) {
11478
                var results = Ext.decode(response.responseText);
11479
                hasil = results.data;
11480
            }
11481
        });
11482
        if (hasil.length > 0) {
11483
            Ext.each(hasil, function (rec) {
11484
                fieldStore.push(rec.FieldName)
11485

    
11486
                var null_ = null;
11487
                var ReadOnly_ = false;
11488
                if (rec.IsPrimaryKey == true) {
11489
                    null_ = false;
11490
                }
11491
                if (rec.IsRequired == true) {
11492
                    null_ = false;
11493
                } else {
11494
                    null_ = true;
11495
                }
11496
                if (rec.ReadOnly == '1') {
11497
                    ReadOnly_ = true;
11498
                }
11499
                var Hidden_ = false;
11500
                if (rec.ReadOnly == '1') {
11501
                    ReadOnly_ = true;
11502
                }
11503

    
11504
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
11505
                    Hidden_ = true;
11506
                    null_ = true;
11507
                }
11508

    
11509
                if (rec.GridView == 1) {
11510
                    switch (rec.FormatRef) {
11511
                        case "date":
11512
                            cols.push({
11513
                                xtype: 'minovadatecolumn',
11514
                                hidden: Hidden_,
11515
                                text: rec.HeaderTitle,
11516
                                dataIndex: rec.FieldName,
11517
                                filter: {
11518
                                    itemDefaults: {
11519
                                        emptyText: 'Search for...',
11520

    
11521
                                    }
11522
                                },
11523
                                editor: {
11524
                                    allowBlank: null_,
11525
                                    xtype: 'datefield',
11526
                                    hideMode: 'visibility',
11527
                                    readOnly: ReadOnly_,
11528
                                    id: tableName + rec.FieldName,
11529
                                }
11530
                            });
11531
                            break
11532
                        case "amount":
11533
                            cols.push({
11534
                                xtype: 'minovacurrancycolumn',
11535
                                text: rec.HeaderTitle,
11536
                                align: 'right',
11537
                                dataIndex: rec.FieldName,
11538
                                hidden: Hidden_,
11539
                                filter: {
11540
                                    itemDefaults: {
11541
                                        emptyText: 'Search for...'
11542
                                    }
11543
                                },
11544
                                editor: {
11545
                                    allowBlank: null_,
11546
                                    xtype: 'textfield',
11547
                                    readOnly: ReadOnly_,
11548
                                    id: tableName + rec.FieldName,
11549
                                }
11550
                            });
11551
                            break
11552
                            //case "datetime":
11553
                            //    if (rec.DataRef != 'CREATEDT' && rec.DataRef != 'CHANGEDT') {
11554
                            //        cols.push({
11555
                            //            xtype: 'minovadatetimecolumn',
11556
                            //            text: rec.HeaderTitle,
11557
                            //            dataIndex: rec.FieldName,
11558
                            //            filter: {
11559
                            //                itemDefaults: {
11560
                            //                    emptyText: 'Search for...'
11561
                            //                }
11562
                            //            },
11563
                            //            editor: {
11564
                            //                allowBlank: null_,
11565
                            //                xtype: 'textfield',
11566
                            //            }
11567
                            //        });
11568
                            //    }
11569
                            //    break
11570
                        default:
11571
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
11572
                                cols.push({
11573
                                    text: rec.HeaderTitle,
11574
                                    dataIndex: rec.FieldName,
11575
                                    width: 100,
11576
                                    filter: {
11577
                                        type: 'string',
11578
                                        itemDefaults: {
11579
                                            emptyText: 'Search for...'
11580
                                        }
11581
                                    }
11582
                                });
11583
                            } else if (rec.SearchType == '0') {
11584
                                var valueField = null;
11585
                                var displayValue = null;
11586
                                var TableRef = undefined;
11587
                                if (rec.TableRef != '') {
11588
                                    TableRef = rec.TableRef;
11589

    
11590
                                    Ext.Ajax.request({
11591
                                        async: false,
11592
                                        method: 'POST',
11593
                                        url: '/UserControl/GetStore',
11594
                                        params: {
11595
                                            tableName: 'SDATATABLEFIELD',
11596
                                            param: 'TableName[equal]' + rec.TableRef
11597
                                        },
11598
                                        success: function (response) {
11599
                                            var results = Ext.decode(response.responseText);
11600
                                            data_ = results.data;
11601
                                            if (data_ != undefined) {
11602
                                                valueField_ = $.grep(data_, function (r) {
11603
                                                    return r.ValueField == '1'
11604
                                                });
11605
                                                valueField = valueField_[0].FieldName
11606
                                                displayValue_ = $.grep(data_, function (r) {
11607
                                                    return r.DisplayValue == '1'
11608
                                                });
11609
                                                displayValue = displayValue_[0].FieldName
11610
                                            }
11611
                                        }
11612
                                    });
11613

    
11614
                                    //create Store
11615
                                    Ext.create('Ext.data.Store', {
11616
                                        storeId: 'store_' + me.tableName + rec.FieldName,
11617
                                        autoLoad: true,
11618
                                        proxy: {
11619
                                            method: 'POST',
11620
                                            type: 'ajax',
11621
                                            url: '/UserControl/GetStoreAuth',
11622
                                            extraParams: {
11623
                                                tableName: TableRef,
11624
                                                param: rec.ParamCombo,
11625
                                                menuId: MinovaUtil.GetMenuID()
11626
                                            },
11627
                                            reader: {
11628
                                                type: 'json',
11629
                                                root: 'data',
11630
                                                totalProperty: 'data[0].TotalCount'
11631
                                            }
11632
                                        }
11633
                                    });
11634

    
11635
                                } else if (rec.FixedValue != '') {
11636
                                    var storeData = [];
11637
                                    var str = rec.FixedValue;
11638
                                    var hasil = str.split('||');
11639
                                    hasil.forEach(function (h) {
11640
                                        store_ = h.split('=')
11641
                                        storeData.push({
11642
                                            code: store_[0],
11643
                                            desc: store_[1],
11644

    
11645
                                        });
11646
                                    });
11647

    
11648
                                    valueField = 'code';
11649
                                    displayValue = 'desc';
11650

    
11651
                                    Ext.create('Ext.data.Store', {
11652
                                        storeId: 'store_' + me.tableName + rec.FieldName,
11653
                                        autoLoad: true,
11654
                                        data: storeData
11655
                                    })
11656
                                }
11657

    
11658
                                cols.push({
11659
                                    xtype: 'minovacombocolumn',
11660
                                    hidden: Hidden_,
11661
                                    text: rec.HeaderTitle,
11662
                                    dataIndex: rec.FieldName,
11663
                                    valueField: valueField,
11664
                                    displayField: displayValue,
11665
                                    store: 'store_' + me.tableName + rec.FieldName,
11666
                                    editor: {
11667
                                        allowBlank: null_,
11668
                                        xtype: 'combobox',
11669
                                        readOnly: ReadOnly_,
11670
                                        id: tableName + rec.FieldName,
11671
                                        valueField: valueField,
11672
                                        displayField: displayValue,
11673
                                        store: 'store_' + me.tableName + rec.FieldName,
11674
                                    },
11675
                                    filter: {
11676
                                        type: 'list',
11677
                                        itemDefaults: {
11678
                                            emptyText: 'Search for...'
11679
                                        }
11680
                                    }
11681
                                });
11682

    
11683
                            } else if (rec.SearchType == '5') {							
11684
                                var valueField = null;
11685
                                var displayValue = null;
11686
                                var AdditionaldisplayValue = null;
11687
                                var TableRef = undefined;
11688
                                if (rec.TableRef != '') {
11689
                                    TableRef = rec.TableRef;
11690
                                    Ext.Ajax.request({
11691
                                        async: false,
11692
                                        method: 'POST',
11693
                                        url: '/UserControl/GetStore',
11694
                                        params: {
11695
                                            tableName: 'SDATATABLEFIELD',
11696
                                            param: 'TableName[equal]' + rec.TableRef
11697
                                        },
11698
                                        success: function (response) {
11699
                                            var results = Ext.decode(response.responseText);
11700
                                            data_ = results.data;
11701
                                            if (data_ != undefined) {
11702
                                                valueField_ = $.grep(data_, function (r) {
11703
                                                    return r.ValueField == '1'
11704
                                                });
11705
                                                if (valueField_.length > 0) {
11706
                                                    valueField = valueField_[0].FieldName
11707
                                                }
11708

    
11709
                                                displayValue_ = $.grep(data_, function (r) {
11710
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
11711
                                                });
11712
                                                if (displayValue_.length > 0) {
11713
                                                    displayValue = displayValue_[0].FieldName;
11714
                                                }
11715
                                                if (displayValue_.length >= 2) {
11716
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
11717
                                                }
11718
                                            }
11719
                                        }
11720
                                    });
11721
                                }
11722
                                Ext.create('Ext.data.Store', {
11723
                                    storeId: 'store_' + me.tableName + rec.FieldName,
11724
                                    autoLoad: true,
11725
                                    proxy: {
11726
                                        method: 'POST',
11727
                                        type: 'ajax',
11728
                                        url: '/UserControl/GetStoreAuth',
11729
                                        extraParams: {
11730
                                            tableName: TableRef,
11731
                                            param: rec.ParamCombo,
11732
                                            menuId: MinovaUtil.GetMenuID()
11733
                                        },
11734
                                        reader: {
11735
                                            type: 'json',
11736
                                            root: 'data',
11737
                                            totalProperty: 'data[0].TotalCount'
11738
                                        }
11739
                                    }
11740
                                });
11741
                                cols.push({
11742
                                    xtype : 'minovacombocolumn',
11743
                                    hidden: Hidden_,
11744
                                    text: rec.HeaderTitle,
11745
                                    dataIndex: rec.FieldName,
11746
                                    valueField : valueField,
11747
                                    displayField : displayValue,
11748
                                    store : 'store_' + me.tableName + rec.FieldName,
11749
                                    tpl: Ext.create('Ext.XTemplate',
11750
                                            '<ul class="x-list-plain"><tpl for=".">',
11751
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
11752
                                            '</tpl></ul>'),
11753
                                    displayTpl: Ext.create('Ext.XTemplate',
11754
                                        '<tpl for=".">',
11755
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
11756
                                        '</tpl>'),
11757
                                    editor: {
11758
                                        allowBlank: null_,
11759
                                        xtype: 'combobox',
11760
                                        readOnly: ReadOnly_,
11761
                                        id: rec.TableName + rec.FieldName,
11762
                                        nameTable: rec.TableName,
11763
                                        fieldGrid: rec.FieldName,
11764
                                        valueField: valueField,
11765
                                        displayField: displayValue,
11766
                                        store: 'store_' + me.tableName + rec.FieldName,
11767
                                        value: rec.DefaultValue,
11768
                                        tpl: Ext.create('Ext.XTemplate',
11769
                                            '<ul class="x-list-plain"><tpl for=".">',
11770
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
11771
                                            '</tpl></ul>'),
11772
                                        displayTpl: Ext.create('Ext.XTemplate',
11773
                                            '<tpl for=".">',
11774
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
11775
                                            '</tpl>')
11776
                                    },
11777
                                    renderer: function (value) {
11778
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
11779
                                        var index = store.find(valueField, value);
11780
                                        var val = "";
11781
                                        if (index != -1) {
11782
                                            var rc = store.getAt(index);
11783
                                            //val = rc.get(displayValue);
11784
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
11785
                                        } else {
11786
                                            val = value;
11787
                                        }
11788
                                        return val;
11789
                                    },
11790
                                    filter: {
11791
                                        type: 'list',
11792
                                        itemDefaults: {
11793
                                            emptyText: 'Search for...'
11794
                                        }
11795
                                    }
11796
                                });
11797
                            } else if (rec.SearchType == '2') {
11798
                                var triger = (rec.TriggerCombo).split('$');
11799
                                var targetField_ = triger[0];
11800
                                var fieldValue_ = triger[1];
11801
                                cols.push({
11802
                                    text: rec.HeaderTitle,
11803
                                    hidden: Hidden_,
11804
                                    dataIndex: rec.FieldName,
11805
                                    filter: {
11806
                                        itemDefaults: {
11807
                                            emptyText: 'Search for...'
11808
                                        }
11809
                                    },
11810
                                    editor: {
11811
                                        allowBlank: null_,
11812
                                        xtype: 'minovalookupgrid',
11813
                                        readOnly: ReadOnly_,
11814
                                        isGrid: true,
11815
                                        fieldTarget: targetField_,
11816
                                        fieldValue: fieldValue_,
11817
                                        isGrid: true,
11818
                                        id: tableName + rec.FieldName,
11819
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11820
                                        triggerCls: 'x-form-search-trigger',
11821
                                        vtype: 'alphanum', // disable space
11822

    
11823
                                        listeners: {
11824
                                            change: function (val) {
11825
                                                var custumFunc = rec.SelectFunction;
11826
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11827
                                                    Ext.Ajax.request({
11828
                                                        async: false,
11829
                                                        method: 'POST',
11830
                                                        url: '/UserControl/GetStore',
11831
                                                        params: {
11832
                                                            tableName: 'PCMFUNC',
11833
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11834
                                                        },
11835
                                                        success: function (response) {
11836
                                                            var results = Ext.decode(response.responseText);
11837
                                                            data_ = results.data[0];
11838
                                                            if (data_ != undefined) {
11839
                                                                custumFunc = data_.FunctionCode;
11840
                                                            }
11841
                                                        }
11842
                                                    });
11843
                                                }
11844
                                                if (custumFunc) {
11845
                                                    eval(custumFunc)
11846
                                                }
11847
                                            }
11848
                                        }
11849
                                    }
11850
                                });
11851
                            } else if (rec.SearchType == '3') {
11852
                                cols.push({
11853
                                    text: rec.HeaderTitle,
11854
                                    hidden: Hidden_,
11855
                                    dataIndex: rec.FieldName,
11856
                                    filter: {
11857
                                        itemDefaults: {
11858
                                            emptyText: 'Search for...'
11859
                                        }
11860
                                    },
11861
                                    editor: {
11862
                                        allowBlank: null_,
11863
                                        // xtype: 'minovalookuptreePopup',
11864
                                        xtype: 'MinovaLookupTree',
11865
                                        readOnly: ReadOnly_,
11866
                                        id: tableName + rec.FieldName,
11867
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11868
                                        triggerCls: 'x-form-search-trigger',
11869
                                        vtype: 'alphanum', // disable space
11870
                                        treeSructure: rec.SearchFunction, //'O-O-P',
11871
                                        objClassValue: rec.ParamCombo, //'O',
11872
                                        listeners: {
11873
                                            change: function (val) {
11874
                                                var custumFunc = rec.SelectFunction;
11875
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11876
                                                    Ext.Ajax.request({
11877
                                                        async: false,
11878
                                                        method: 'POST',
11879
                                                        url: '/UserControl/GetStore',
11880
                                                        params: {
11881
                                                            tableName: 'PCMFUNC',
11882
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11883
                                                        },
11884
                                                        success: function (response) {
11885
                                                            var results = Ext.decode(response.responseText);
11886
                                                            data_ = results.data[0];
11887
                                                            if (data_ != undefined) {
11888
                                                                custumFunc = data_.FunctionCode;
11889
                                                            }
11890
                                                        }
11891
                                                    });
11892
                                                }
11893
                                                if (custumFunc) {
11894
                                                    eval(custumFunc)
11895
                                                }
11896
                                            }
11897
                                        }
11898
                                    }
11899
                                });
11900
                            } 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) {
11901
                                var triger = (rec.TriggerCombo).split('&');
11902
                                var targetField_ = triger[0];
11903
                                var fieldValue_ = triger[0];
11904
                                cols.push({
11905
                                    text: rec.HeaderTitle,
11906
                                    hidden: Hidden_,
11907
                                    dataIndex: rec.FieldName,
11908
                                    filter: {
11909
                                        itemDefaults: {
11910
                                            emptyText: 'Search for...'
11911
                                        }
11912
                                    },
11913
                                    editor: {
11914
                                        allowBlank: null_,
11915
                                        xtype: 'lookupemployee',
11916
                                        readOnly: ReadOnly_,
11917
                                        isGrid: true,
11918
                                        fieldTarget: targetField_,
11919
                                        fieldValue: fieldValue_,
11920
                                        isGrid: true,
11921
                                        id: tableName + rec.FieldName,
11922
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11923
                                        triggerCls: 'x-form-search-trigger',
11924
                                        vtype: 'alphanum', // disable space
11925
                                        listeners: {
11926
                                            change: function (val) {
11927
                                                var custumFunc = rec.SelectFunction;
11928
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11929
                                                    Ext.Ajax.request({
11930
                                                        async: false,
11931
                                                        method: 'POST',
11932
                                                        url: '/UserControl/GetStore',
11933
                                                        params: {
11934
                                                            tableName: 'PCMFUNC',
11935
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11936
                                                        },
11937
                                                        success: function (response) {
11938
                                                            var results = Ext.decode(response.responseText);
11939
                                                            data_ = results.data[0];
11940
                                                            if (data_ != undefined) {
11941
                                                                custumFunc = data_.FunctionCode;
11942
                                                            }
11943
                                                        }
11944
                                                    });
11945
                                                }
11946
                                                if (custumFunc) {
11947
                                                    eval(custumFunc)
11948
                                                }
11949
                                            }
11950
                                        }
11951
                                    }
11952
                                });
11953
                            } else if (rec.SearchType == '4' && isLookup != true) {
11954
                                cols.push({
11955

    
11956
                                    text: rec.HeaderTitle,
11957
                                    hidden: Hidden_,
11958
                                    dataIndex: rec.FieldName,
11959
                                    filter: {
11960
                                        itemDefaults: {
11961
                                            emptyText: 'Search for...'
11962
                                        }
11963
                                    },
11964
                                    editor: {
11965
                                        allowBlank: null_,
11966
                                        xtype: 'lookupemployee',
11967
                                        readOnly: ReadOnly_,
11968
                                        isGrid: true,
11969
                                        fieldTarget: targetField_,
11970
                                        fieldValue: fieldValue_,
11971
                                        isGrid: true,
11972
                                        id: tableName + rec.FieldName,
11973
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11974
                                        triggerCls: 'x-form-search-trigger',
11975
                                        vtype: 'alphanum', // disable space
11976
                                        listeners: {
11977
                                            change: function (val) {
11978
                                                var custumFunc = rec.SelectFunction;
11979
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11980
                                                    Ext.Ajax.request({
11981
                                                        async: false,
11982
                                                        method: 'POST',
11983
                                                        url: '/UserControl/GetStore',
11984
                                                        params: {
11985
                                                            tableName: 'PCMFUNC',
11986
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11987
                                                        },
11988
                                                        success: function (response) {
11989
                                                            var results = Ext.decode(response.responseText);
11990
                                                            data_ = results.data[0];
11991
                                                            if (data_ != undefined) {
11992
                                                                custumFunc = data_.FunctionCode;
11993
                                                            }
11994
                                                        }
11995
                                                    });
11996
                                                }
11997
                                                if (custumFunc) {
11998
                                                    eval(custumFunc)
11999
                                                }
12000
                                            }
12001
                                        }
12002
                                    }
12003
                                });
12004
                            } else {
12005
                                cols.push({
12006
                                    text: rec.HeaderTitle,
12007
                                    hidden: Hidden_,
12008
                                    dataIndex: rec.FieldName,
12009
                                    filter: {
12010
                                        itemDefaults: {
12011
                                            emptyText: 'Search for...'
12012
                                        }
12013
                                    },
12014
                                    editor: {
12015
                                        allowBlank: null_,
12016
                                        xtype: 'textfield',
12017
                                        readOnly: ReadOnly_,
12018
                                        id: tableName + rec.FieldName,
12019
                                        listeners: {
12020
                                            change: function (val) {
12021
                                                var custumFunc = null;
12022
                                                Ext.Ajax.request({
12023
                                                    async: false,
12024
                                                    method: 'POST',
12025
                                                    url: '/UserControl/GetStore',
12026
                                                    params: {
12027
                                                        tableName: 'SDATATABLEFIELD',
12028
                                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
12029
                                                    },
12030
                                                    success: function (response) {
12031
                                                        var results = Ext.decode(response.responseText);
12032
                                                        data_ = results.data[0];
12033
                                                        if (data_ != undefined) {
12034
                                                            custumFunc = data_.SelectFunction;
12035
                                                            //console.log(data_)
12036
                                                        }
12037
                                                    }
12038
                                                });
12039

    
12040
                                                if (custumFunc) {
12041
                                                    eval(custumFunc)
12042
                                                }
12043
                                            }
12044
                                        }
12045
                                    }
12046
                                });
12047
                            }
12048

    
12049
                            break
12050

    
12051
                    }
12052
                } else {
12053
                    cols.push({
12054
                        text: rec.HeaderTitle,
12055
                        hidden: Hidden_,
12056
                        dataIndex: rec.FieldName,
12057
                        hidden: true,
12058
                        editor: {
12059
                            allowBlank: true,
12060
                            xtype: 'textfield',
12061
                            readOnly: ReadOnly_,
12062
                            id: tableName + rec.FieldName,
12063
                        },
12064
                        filter: {
12065
                            itemDefaults: {
12066
                                emptyText: 'Search for...'
12067
                            }
12068
                        }
12069
                    });
12070
                }
12071
            });
12072
        };
12073

    
12074
        this.cellEditing = new Ext.grid.plugin.CellEditing({
12075
            clicksToEdit: 1
12076
        });
12077
        Ext.applyIf(me, {
12078
            items: [{
12079
                xtype: 'grid',
12080
                id: gridName,
12081
                name: gridName,
12082
                height: height,
12083
                //store: 'gridStore',
12084
                store: Ext.create('Ext.data.Store', {
12085
                    storeId: storeID,
12086
                    fields: fieldStore,
12087
                    proxy: {
12088
                        method: 'POST',
12089
                        type: 'ajax',
12090
                        url: '',
12091
                        reader: {
12092
                            type: 'json',
12093
                            root: 'data'
12094
                        }
12095
                    }
12096
                }),
12097
                viewConfig: {
12098
                    emptyText: 'No Data Display',
12099
                    deferEmptyText: false,
12100
                    //Add Nana For Autosize Column Mode
12101
                    listeners: {
12102
                        refresh: function (dataview) {
12103
                            Ext.each(dataview.panel.columns, function (column) {
12104
                                if (column.autoSizeColumn == false)
12105
                                    column.autoSizeColumn = true;
12106
                                column.autoSize();
12107
                                //dataview.store.reload();
12108
                            })
12109
                        }
12110
                    },
12111
                    render: function (comp) {
12112
                        comp.getStore().reload();
12113
                        console.log(comp);
12114
                    }
12115
                },
12116
                dockedItems: [{
12117
                    xtype: 'toolbar',
12118
                    items: [{
12119
                        text: 'Add',
12120
                        hidden: hide_,
12121
                        name: tableName + 'Add',
12122
                        iconCls: 'fa-plus-circle',
12123
                        style: 'font-family: FontAwesome',
12124
                        handler: function () {
12125
                            var store = Ext.StoreMgr.lookup(storeID)
12126
                            idx = store.getCount();
12127
                            var action = getParam('action');
12128
                            var data = '';
12129
                            var Sequence = 0;
12130
                            if (idx == 0) {
12131
                                Sequence = 1;
12132
                            } else {
12133
                                Sequence = 1 + idx;
12134
                            }
12135
                            data = {
12136
                                Sequence: Sequence
12137
                            };
12138

    
12139
                            store.insert(idx, data);
12140
                        }
12141

    
12142
                    }, {
12143
                        text: 'Delete',
12144
                        hidden: hide_,
12145
                        name: tableName + 'DeleteText',
12146
                        iconCls: 'fa-trash-o',
12147
                        style: 'font-family: FontAwesome',
12148
                        //disabled: true
12149
                        handler: function () {
12150
                            var me = this,
12151
                            store = Ext.StoreMgr.lookup(storeID)
12152

    
12153
                            var grid = Ext.getCmp(gridName);
12154

    
12155
                            Ext.MessageBox.show({
12156
                                title: 'Remove tab',
12157
                                msg: "This will remove. Do you want to continue?",
12158
                                buttons: Ext.MessageBox.YESNO,
12159
                                fn: function (choice) {
12160
                                    console.log(choice);
12161
                                    if (choice === 'yes') {
12162
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
12163
                                        if (selection) {
12164
                                            store.remove(selection);
12165
                                        }
12166
                                    }
12167
                                    //delete panel.pendingClose;
12168
                                }
12169
                            });
12170
                        }
12171

    
12172
                    }
12173
                    ]
12174
                }
12175
                ],
12176
                columns: cols,
12177
                selModel: {
12178
                    type: 'cellmodel'
12179
                },
12180
                plugins: [this.cellEditing],
12181
            }, ]
12182

    
12183
        });
12184

    
12185
        me.callParent(arguments);
12186
    }
12187
});
12188
//hamid200916
12189
Ext.define('MinovaUtil.MinovaES.MinovaLookupEmployeelama', {
12190
    extend: 'Ext.panel.Panel',
12191
    alias: 'widget.lookupemployeelama',
12192
    requires: [
12193
		'Ext.data.*',
12194
		'Ext.grid.*',
12195
		'Ext.tree.*',
12196
		'Ext.ux.CheckColumn',
12197
		//'MinovaES.View.sample.samplepopupEMPID'
12198

    
12199
    ],
12200
    formname: undefined,
12201
    fieldname: undefined,
12202
    allowBlank: undefined,
12203
    width: undefined,
12204
    tableName: undefined,
12205
    //bodyStyle: 'padding-left: -20px; padding-bottom: -20px; padding-top: -20px; padding-right: -20px;',
12206
    //padding: '-40px',
12207
    //bodyStyle: 'margin:-20px;',
12208
    //margin: '-20 -20 -20 -20',
12209
    //fieldLabel: undefined,
12210
    //name: undefined,
12211
    //pnl: this.name,
12212
    initComponent: function () {
12213
        var me = this;
12214
        targetField_ = me.fieldname;
12215
        //var nameField_ = me.name;
12216
        //var panelform = this.pnl;
12217
        var nameField_ = me.fieldname;
12218
        var blank = me.allowBlank;
12219
        var width_ = me.width;
12220
        var tableName_ = me.tableName;
12221
        var panelform = "form" + me.name;
12222
        //var fieldLabel_ = me.fieldLabel;
12223
        Ext.applyIf(me, {
12224
            items: [{
12225
                xtype: 'form',
12226
                name: panelform,
12227
                items: [{
12228
                    xtype: 'fieldcontainer',
12229
                    layout: 'hbox',
12230
                    fieldLabel: me.fieldLabel,
12231
                    items: [{
12232
                        xtype: "triggerfield",
12233
                        name: nameField_,
12234
                        width: width_,
12235
                        //anchor: '50%',
12236
                        //editable: true,
12237
                        allowBlank: blank,
12238
                        triggerCls: 'x-form-search-trigger',
12239
                        onTriggerClick: function (e) {
12240
                            //var tableName_ = this.tableName;
12241
                            var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
12242
                            var lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0];
12243
                            var EmployeeID = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
12244
                            var EmployeeID_ = EmployeeID.getValue();
12245
                            //var params = "EmployeeID[=]" + EmployeeID.getValue();
12246
                            //var Url = "sample?EmployeeID=" + EmployeeID.getValue();
12247
                            //window.open(Url, "_self");
12248
                            //var selection_ = selection.getValue();
12249
                            //var EmployeeSearch = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12250
                            //var lokup = EmployeeSearch.setValue(selection_);
12251

    
12252
                            var popup_lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
12253
                            if (count_lookup == 1) {
12254
                                Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField = this.name;
12255
                                Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].show();
12256
                            } else {
12257
                                //var _popUploadView = Ext.create("MinovaUtil.MinovaES.LookupEmployeeQuickSearch");
12258
                                Ext.create('MinovaUtil.MinovaES.LookupEmployeeQuickSearch', {
12259
                                    //    tableName: tableName_,
12260

    
12261
                                    //}).show()
12262
                                    //_popUploadView.tableName = tableName_;
12263
                                    tableName: tableName_,
12264
                                    targetField: this.name,
12265
                                }).show()
12266
                            }
12267

    
12268
                            //var _popUploadView = Ext.create("MinovaES.view.sample.samplepopupEMPID");
12269
                            //var a = _popUploadView.show();
12270
                            var text = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12271
                            text.setValue(EmployeeID_);
12272

    
12273
                            if (EmployeeID_ !== "") {
12274
                                var store = Ext.data.StoreManager.lookup('lookupEMPID');
12275
                                var grid = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
12276
                                store.proxy.extraParams = {
12277
                                    tableName: tableName_, //'PDSEMP0002',
12278
                                    param: 'EmpID_ExternalID_FullName[like]' + EmployeeID_
12279
                                };
12280
                                store.reload();
12281
                            }
12282
                        },
12283
                        listeners: {
12284
                            specialkey: function (f, e) {
12285
                                if (e.getKey() == e.ENTER) {
12286
                                    //alert("about to submit");
12287
                                    var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
12288
                                    var lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0];
12289
                                    var EmployeeID = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
12290
                                    var EmployeeID_ = EmployeeID.getValue();
12291

    
12292
                                    var popup_lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
12293
                                    if (count_lookup == 1) {
12294
                                        Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField = this.name;
12295
                                        Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].show();
12296
                                    } else {
12297
                                        Ext.create('MinovaUtil.MinovaES.LookupEmployeeQuickSearch', {
12298
                                            tableName: tableName_,
12299
                                            targetField: this.name,
12300
                                        }).show()
12301
                                        //var _popUploadView = Ext.create("MinovaUtil.MinovaES.LookupEmployeeQuickSearch");
12302
                                        //_popUploadView.targetField = this.name;
12303
                                        //_popUploadView.show();
12304

    
12305
                                    }
12306
                                    //var _popUploadView = Ext.create("MinovaES.view.sample.samplepopupEMPID");
12307
                                    //var a = _popUploadView.show();
12308
                                    var text = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12309
                                    text.setValue(EmployeeID_);
12310

    
12311
                                    if (EmployeeID_ !== "") {
12312
                                        var store = Ext.data.StoreManager.lookup('lookupEMPID');
12313
                                        var grid = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
12314
                                        store.proxy.extraParams = {
12315
                                            tableName: tableName_, //'PDSEMP0002',
12316
                                            param: 'EmpID_ExternalID_FullName[like]' + EmployeeID_
12317
                                        };
12318
                                        store.reload();
12319
                                    }
12320
                                    //myform.getForm().submit();
12321
                                }
12322
                            }
12323
                        }
12324

    
12325
                    }, {
12326
                        xtype: 'tbspacer',
12327
                        width: 5
12328
                    }, {
12329
                        xtype: 'button',
12330
                        name: nameField_,
12331
                        anchor: '50%',
12332
                        text: 'Advance',
12333
                        listeners: {
12334
                            click: function () {
12335
                                var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEmployee]').length;
12336
                                if (count_lookup == 1) {
12337
                                    Ext.ComponentQuery.query('[name=popup_lookupEmployee]')[0].targetField = this.name;
12338
                                    Ext.ComponentQuery.query('[name=popup_lookupEmployee]')[0].show();
12339
                                } else {
12340
                                    Ext.create('MinovaUtil.MinovaES.LookupEmployeeAdvance', {
12341
                                        tableName: tableName_,
12342
                                        targetField: this.name,
12343
                                    }).show()
12344
                                    //var _popUploadView = Ext.create("MinovaUtil.MinovaES.LookupEmployeeAdvance");
12345
                                    //_popUploadView.targetField = this.name;
12346
                                    //_popUploadView.show();
12347

    
12348
                                }
12349
                            }
12350
                        },
12351
                    }
12352
                    ]
12353
                }
12354
                ]
12355
            }
12356
            ]
12357
        });
12358
        me.callParent(arguments);
12359
    }
12360
});
12361

    
12362
Ext.define('MinovaUtil.MinovaES.LookupEmployeeQuickSearch', {
12363
    extend: 'Ext.window.Window',
12364
    alias: 'widget.popup_employeequicksearch',
12365
    requires: [
12366
		// 'MinovaES.controller.sample.ctrlsample',
12367
		//'MinovaES.store.data.TableType',
12368
    ],
12369
    //controller: 'ctrlsample',
12370
    height: '85%',
12371
    width: '42%',
12372
    minWidth: '50%',
12373
    maxWidth: '100%',
12374
    bodyPadding: 0,
12375
    formname: undefined,
12376
    //modal: true,
12377
    title: 'Lookup - EmployeeID',
12378
    name: 'popup_lookupEMPID',
12379
    test: undefined,
12380
    targetField: undefined,
12381
    tableName: undefined,
12382
    afterender: function () {
12383
        test = nameform;
12384
    },
12385
    initComponent: function () {
12386

    
12387
        var me = this;
12388
        var targetField_ = me.targetField;
12389
        var form = me.test;
12390
        var tableName_ = me.tableName;
12391
        Ext.applyIf(me, {
12392
            items: [{
12393
                xtype: 'form',
12394
                name: 'frmSearch',
12395
                width: '100%',
12396
                height: 'auto',
12397
                dockedItems: [{
12398
                    xtype: 'toolbar',
12399
                    dock: 'top',
12400
                    layout: 'vbox',
12401
                    bodyPadding: 10,
12402
                    border: 0,
12403
                    items: [{
12404
                        xtype: 'fieldset',
12405
                        layout: 'hbox',
12406
                        width: '100%',
12407
                        border: 0,
12408
                        padding: 0,
12409
                        items: [{
12410
                            xtype: 'textfield',
12411
                            name: 'EmployeeSearch',
12412
                            fieldLabel: 'Emp ID/ External ID/ Full Name',
12413
                            width: 475,
12414
                            labelWidth: 185,
12415
                            enableKeyEvents: true,
12416
                            listeners: {
12417
                                specialkey: function (f, e) {
12418
                                    if (e.getKey() == e.ENTER) {
12419
                                        var emp = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12420
                                        var emp_ = emp.getValue();
12421
                                        var store = Ext.data.StoreManager.lookup('lookupEMPID');
12422
                                        var grid = Ext.ComponentQuery.query('[name=EmployeeID]')[0];
12423
                                        store.proxy.extraParams = {
12424
                                            tableName: tableName_, //'PDSEMP0002',
12425
                                            param: 'EmpID_ExternalID_FullName[like]' + emp_
12426
                                        };
12427
                                        store.reload();
12428
                                    }
12429
                                }
12430
                            }
12431
                        }, {
12432
                            xtype: 'tbspacer',
12433
                            width: 5
12434
                        }, {
12435
                            xtype: 'button',
12436
                            name: 'Search',
12437
                            text: 'Search',
12438
                            handler: function () {
12439
                                var emp = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12440
                                var emp_ = emp.getValue();
12441
                                var store = Ext.data.StoreManager.lookup('lookupEMPID');
12442
                                var grid = Ext.ComponentQuery.query('[name=EmployeeID]')[0];
12443
                                store.proxy.extraParams = {
12444
                                    tableName: tableName_, //'PDSEMP0002',
12445
                                    param: 'EmpID_ExternalID_FullName[like]' + emp_
12446
                                };
12447
                                store.reload();
12448
                            },
12449

    
12450
                        }
12451
                        ]
12452
                    }
12453
                    ]
12454
                }
12455
                ],
12456
            }, {
12457
                items: [{
12458
                    xtype: "minovagrid1",
12459
                    name: "GridEmployeeID",
12460
                    storename: 'lookupEMPID',
12461
                    tableName: tableName_, //'PDSEMP0002',
12462
                    param: '',
12463
                    isLookup: true,
12464
                    pagesize: 25,
12465
                    height: 425,
12466
                    listeners: {
12467
                        beforeedit: function () {
12468
                            return false;
12469
                        },
12470
                        itemdblclick: function () {
12471
                            var grid = Ext.ComponentQuery.query('[name=GridEmployeeID]')[0];
12472
                            var selection = grid.getView().getSelectionModel().getSelection()[0];
12473
                            var Emp_ = selection.data.EmployeeID;
12474
                            //var formSelection = Ext.ComponentQuery.query('[name=' + form + ']')[0];
12475
                            //formSelection.getForm().setValues(grid.getSelectionModel().getSelection()[0].data);
12476

    
12477
                            var target = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField;
12478
                            Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(Emp_);
12479
                            //Ext.ComponentQuery.query('[name=EmployeeiD]')[0].setValue(selection.data.EmployeeID);;
12480
                            Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].hide();
12481
                        }
12482
                    },
12483
                }, {
12484
                    xtype: 'pagingtoolbar',
12485
                    store: 'lookupEMPID',
12486
                    dock: 'bottom',
12487
                    displayInfo: true
12488
                }
12489
                ]
12490
            }
12491
            ]
12492
        });
12493
        me.callParent(arguments);
12494
    }
12495
});
12496
Ext.define('MinovaUtil.MinovaES.LookupEmployeeAdvance', {
12497
    extend: 'Ext.window.Window',
12498
    alias: 'widget.popup_employeeadvance',
12499
    requires: [
12500
		//'MinovaES.controller.sample.ctrlsample',
12501
		//'MinovaES.store.data.TableType',
12502
    ],
12503
    //controller: 'ctrlsample',
12504
    height: '85%',
12505
    width: '42%',
12506
    minWidth: '50%',
12507
    maxWidth: '100%',
12508
    bodyPadding: 10,
12509
    anchor: '50%',
12510
    formname: undefined,
12511
    //modal: true,
12512
    title: 'Lookup - EmployeeID',
12513
    name: 'popup_lookupEmployee',
12514
    test: undefined,
12515
    targetField: undefined,
12516
    tableName: undefined,
12517
    initComponent: function () {
12518
        var me = this;
12519
        var targetField_ = me.targetField;
12520
        var form = me.test;
12521
        var tableName_ = me.tableName;
12522
        Ext.applyIf(me, {
12523
            items: [{
12524
                xtype: 'form',
12525
                name: 'formlookup',
12526
                items: [{
12527
                    xtype: 'minovaform',
12528
                    name: 'frmlookup',
12529
                    tableName: tableName_, //'PDSEMP0001',
12530
                    param: '',
12531
                    isLookup: true,
12532
                    listeners: {
12533
                        onStockFormKeyPress: function (textfield, event, options) {
12534
                            if (event.getKey() == event.ENTER) {
12535
                                alert("test");
12536
                                //Ext.Msg.alert('Keys', 'You pressed the Enter key');
12537
                            }
12538
                        }
12539
                    },
12540
                    buttons: [{
12541
                        text: 'Search',
12542
                        //iconCls : 'fa-edit',
12543
                        //style : 'font-family: FontAwesome',
12544
                        listeners: {
12545
                            click: function () {
12546
                                var store = Ext.data.StoreManager.lookup('lookupStore');
12547
                                var form = Ext.ComponentQuery.query('[name=formlookup]')[0].getForm();
12548
                                grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
12549
                                var values_ = form.getValues();
12550
                                var fields_ = form.getFields().items;
12551
                                var param_ = '';
12552
                                for (var i = 0; i < fields_.length; i++) {
12553
                                    var val_ = form.getFields().items[i].getValue();
12554
                                    var xtype_ = form.getFields().items[i].xtype;
12555
                                    var oprator_ = '[like]';
12556
                                    if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
12557
                                        oprator_ = '[Equal]';
12558
                                    }
12559
                                    if (xtype_ == 'datefield') {
12560
                                        if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
12561
                                            oprator_ = '[LessThanEqual]';
12562
                                        } else {
12563
                                            oprator_ = '[GreaterThanEqual]';
12564
                                        }
12565
                                    }
12566
                                    if (val_ != 'undefined' && val_ != "" && val_ != null) {
12567
                                        param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
12568
                                    }
12569
                                }
12570
                                store.proxy.extraParams = {
12571
                                    tableName: grid.tableName,
12572
                                    param: param_
12573
                                };
12574
                                store.removeAll();
12575
                                store.reload();
12576
                                store.loadPage(1);
12577
                            },
12578

    
12579
                        }
12580
                    }
12581
                    ]
12582
                }, {
12583
                    xtype: 'minovagrid',
12584
                    name: 'gridlookup',
12585
                    minHeight: 320,
12586
                    height: 250,
12587
                    tableName: tableName_, //'PDSEMP0001',
12588
                    param: '',
12589
                    isLookup: true,
12590
                    storename: 'lookupStore',
12591
                    pagesize: 25,
12592
                    listeners: {
12593
                        beforeedit: function () {
12594
                            return false;
12595
                        },
12596
                        itemdblclick: function () {
12597
                            var grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
12598
                            var selection = grid.getView().getSelectionModel().getSelection()[0];
12599
                            var Emp_ = selection.data.EmployeeID;
12600
                            //var formSelection = Ext.ComponentQuery.query('[name=EmployeeSelection]')[0];
12601
                            //formSelection.getForm().setValues(grid.getSelectionModel().getSelection()[0].data);
12602
                            var target = Ext.ComponentQuery.query('[name=popup_lookupEmployee]')[0].targetField;
12603
                            Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(Emp_);
12604
                            Ext.ComponentQuery.query('[name=popup_lookupEmployee]')[0].hide();
12605

    
12606
                        }
12607
                    },
12608
                    dockedItems: [{
12609
                        xtype: 'pagingtoolbar',
12610
                        store: 'lookupStore',
12611
                        dock: 'bottom',
12612
                        displayInfo: true
12613
                    }
12614
                    ]
12615
                }
12616
                ]
12617
            }
12618
            ]
12619
        });
12620
        me.callParent(arguments);
12621
    }
12622
});
12623
//end hamid
12624

    
12625

    
12626
// lookup tree
12627
Ext.define('MinovaES.view.orm.lookup.minovalookuptreePopup', {
12628
    extend: 'Ext.window.Window',
12629
    alias: 'widget.minovalookuptreePopup',
12630
    requires: [
12631

    
12632
    ],
12633
    //height: '50%',
12634
    width: '40%',
12635
    minWidth: '50%',
12636
    maxWidth: '100%',
12637
    bodyPadding: 5,
12638
    modal: true,
12639
    name: 'mainlookupTree',
12640
    objFilter: undefined,
12641
    treeSructure: undefined, // object relationship
12642
    objClassValue: undefined, // object yang akan di input ke field
12643
    formname: undefined, // nama form
12644
    targetField: undefined, // nama field yang akan diset value
12645
    //title:'judul',
12646
    bodyPadding: 0,
12647
    initComponent: function () {
12648
        var me = this;
12649
        var objFilter_ = me.objFilter;
12650
        var treeSructure_ = me.treeSructure;
12651
        var formname_ = me.formname;
12652
        var objClassValue_ = me.objClassValue;
12653
        var targetField_ = me.targetField;
12654
        var AllObjectClass = treeSructure_.split('-');
12655
        var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0];
12656
        var StartDate_ = MinovaUtil.GetNowDate();
12657
        if (form_) {
12658
		  if(form_.getForm=='undefined'){
12659
            if (form_.getForm().findField('StartDate')) {
12660
                StartDate_ = form_.getForm().findField('StartDate').getValue();
12661
            } 
12662
		  }
12663
        }
12664

    
12665
        Ext.applyIf(me, {
12666
            items: [{
12667
                //xtype : 'panel',
12668
                items: [{
12669
                    xtype: 'tabpanel',
12670
                    items: [{
12671

    
12672
                        xtype: 'form',
12673
                        title: 'Structured Search',
12674
                        //height: '70%',
12675
                        tabConfig: {
12676
                            tooltip: 'Search by tree'
12677
                        },
12678
                        items: [{
12679
                            xtype: 'form',
12680
                            items: [{
12681

    
12682
                                xtype: 'treepanel',
12683
                                rootVisible: false,
12684
                                //height: 400,
12685

    
12686
                                name: 'searchByTreePopUp',
12687
                                useArrows: true,
12688
                                animate: false,
12689
                                targetField: targetField_,
12690
                                formname: formname_,
12691
                                root: {
12692
                                    expanded: true,
12693
                                    nodeType: 'async',
12694
                                    ext: 'Favorites',
12695
                                    id: 'null'
12696
                                },
12697
                                listeners: {
12698
                                    afterrender: function (me_) {
12699
                                        me_.mask();
12700
                                        if (treeSructure_ != 'O-O-P') {
12701
                                            var countCol = me_.columns.length;
12702
                                            me_.columns[countCol - 1].setHidden(true);
12703

    
12704
                                        }
12705
                                        if (StartDate_ != '') {
12706
                                            var node = "root";
12707
                                            var ObjectClass_ = treeSructure_.split('-');
12708
                                            //Ext.Ajax.request({
12709
                                            //    method: 'POST',
12710
                                            //    async: false,
12711
                                            //    url: '/UserControl/GetStoreAuth',
12712
                                            //    params: {
12713
                                            //        tableName: "PHROM0001",
12714
                                            //        param: "ObjectClass[=]" + ObjectClass_[0],
12715
                                            //        menuId: MinovaUtil.GetMenuID()
12716
                                            //    },
12717
                                            //    success: function (response) {
12718
                                            //        var results = Ext.decode(response.responseText);
12719
                                            //        var data_ = results.data;
12720
                                            //        if (data_.length > 0 && data_.length == 1) {
12721
                                            //            node = ObjectClass_[0] + data_[0].ObjectID;
12722
                                            //        }
12723

    
12724
                                            //    }
12725
                                            //});
12726

    
12727
                                            Ext.Ajax.request({
12728
                                                async: false,
12729
                                                //url: '/ORM/GetRelObjectTreeAsync?node=' + node + '&tree_struct_code=' + treeSructure_ + '&keyDate=' + StartDate_,
12730
                                                url: '/ORM/GetRelObjectTreeAsyncAuth?node=' + 'root' + '&tree_struct_code=' + treeSructure_ + '&keyDate=' + StartDate_ + '&ObjectClass=' + ObjectClass_[0] + '&MenuID=' + /*MinovaUtil.GetMenuID()*/'PM01',
12731
                                                success: function (response) {
12732
                                                    var results = Ext.decode(response.responseText);
12733
                                                    var data_ = results.results;
12734
                                                    //console.log(data_)
12735
                                                    var pnl = Ext.ComponentQuery.query('[name=searchByTreePopUp]')[0];
12736
                                                    pnl.store.setRootNode({
12737
                                                        expanded: true,
12738
                                                        nodetype: 'async',
12739
                                                        children: data_
12740
                                                        //[]
12741
                                                    });
12742
                                                }
12743
                                            });
12744

    
12745
                                        }
12746
                                        me_.unmask();
12747
                                    },
12748
                                    afteritemexpand: function (node, index, item, eOpts) {
12749
                                        var me = this;
12750
                                        var data_ = null;
12751
                                        var idx = 0;
12752
                                        var tree_ = Ext.ComponentQuery.query('treepanel[name=searchByTreePopUp]')[0];
12753
                                        var v = tree_.getView();
12754
                                        tree_.mask('Expanding tree...');
12755
                                        var main_ = Ext.ComponentQuery.query('[name=ORMMain]')[0];
12756
                                        Ext.Ajax.request({
12757
                                            async: false,
12758
                                            url: '/ORM/GetRelObjectTreeAsync?node=' + node.get('Id') + '&tree_struct_code=' + treeSructure_ + '&keyDate=' + StartDate_,
12759
                                            success: function (response) {
12760
                                                var results = Ext.decode(response.responseText);
12761
                                                data_ = results.results;
12762
                                                console.log(data_)
12763
                                            }
12764
                                        });
12765

    
12766
                                        if (data_.length > 0) {
12767
                                            data_.forEach(function (rec) {
12768

    
12769
                                                console.log(rec.Id)
12770
                                                if (v.store.data.find('Id', rec.Id) == null) {
12771
                                                    node.appendChild(data_[idx])
12772
                                                }
12773
                                                idx++;
12774
                                            })
12775
                                        }
12776

    
12777
                                        setTimeout(function () {
12778

    
12779
                                            tree_.unmask();
12780
                                        }, 200);
12781

    
12782
                                    },
12783
                                    itemdblclick: function (this_, record, item, index, e, eOpts) {
12784
                                        var cek = false;
12785
                                        var class_ = objClassValue_;
12786
                                        var classDt = class_.split(']');
12787
                                        var classVal = "";
12788
                                        if (classDt.length == 1) {
12789
                                            classVal = classDt[0];
12790
                                        }
12791
                                        if (classDt.length > 1) {
12792
                                            classVal = classDt[1];
12793
                                        }
12794
                                        if (classVal == record.data.ObjectType) {
12795
											
12796
											if(formname_ != undefined && formname_.substring(0,4)!='grid')
12797
											{
12798
												var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0].getForm();
12799
												var type = 'rc';
12800
												if (form_.findField(targetField_).nameTable) {
12801
													type = form_.findField(targetField_).nameTable.substr(3, 2).toLowerCase();
12802
												}
12803
												if (type != "rc") {
12804
													if (classVal == 'P' && (MinovaUtil.GetMenuID() == 'PA02' || MinovaUtil.GetMenuID() == 'ESS_MUTATION' || MinovaUtil.GetMenuID() == 'ESS_PROMOTION')) {
12805
														// cek apakah posisis sudah di assign
12806
														var hasil = null;
12807
														Ext.Ajax.request({
12808
															async: false,
12809
															method: 'POST',
12810
															url: '/UserControl/GetStore',
12811
															params: {
12812
																tableName: 'PHROM0002',
12813
																param: 'ObjectClass[=]P,RelationshipDirectory[=]A,RelationshipClass[=]E,StartDate[LessThanEqual]' + StartDate_ + ',EndDate[GreaterThanEqual]' + StartDate_ + ',ObjectID[=]' + record.data.ObjectId
12814
															},
12815
															success: function (response) {
12816
																var results = Ext.decode(response.responseText);
12817
																//hasil = results.data[0].RelationshipObject;
12818
																hasil = results.data.length;
12819
																if (hasil == 0) {
12820
																	cek = true;
12821
																} else {
12822
																	//Ext.Msg.show({
12823
																	//    title: 'Warning',
12824
																	//    message: MinovaMessageData('OM0001', ''),
12825
																	//    buttons: Ext.Msg.OK,
12826
																	//     fn: function (choice) {
12827
																	//        console.log(choice);
12828
																	//        if (choice === 'ok') {
12829
																	//        }
12830

    
12831
																	//    }
12832
																	//});
12833
																	//alert(MinovaMessageData('OM0001', ''))
12834
																	MinovaMessageError("Position Occupied", "OM0001", "");
12835
																}
12836
																//count = hasil.length
12837
															}
12838
														});
12839
													} else {
12840
														cek = true;
12841
													}
12842
												} else {
12843
													cek = true;
12844
												}
12845
												if (cek) {
12846
													// set value to form
12847
													var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0].getForm();
12848
													form_.findField(targetField_).setValue('a');
12849
													form_.findField(targetField_).valData = 'a';
12850
													form_.findField(targetField_).setValue(record.data.Text);
12851
													form_.findField(targetField_).valData = record.data.ObjectId;
12852
													form_.findField(targetField_).focus();
12853
													if (form_.findField(targetField_).nextSibling()) {
12854
														form_.findField(targetField_).nextSibling().focus();
12855
													} else {
12856
														form_.findField(targetField_).blur();
12857
													}
12858
													Ext.ComponentQuery.query('[name=' + targetField_ + 'lookUp' + ']')[0].destroy();
12859
												}												
12860
											}else{
12861
												Ext.ComponentQuery.query('[name=' + targetField_ + 'lookUp' + ']')[0].destroy();
12862
												Ext.ComponentQuery.query('[name=' + targetField_ + ']')[0].setValue(record.data.Text);
12863
												
12864
												// for (var i = 0; i < 5; ++i) {
12865
													// task(i);
12866
												// }
12867
												// function task(i) {
12868
												// var task = new Ext.util.DelayedTask(function(){
12869
												// Ext.ComponentQuery.query('[name=maingeneralbgt]')[0].items.items[0].items.map.gridPHRBU0004.getSelectionModel().getSelection()[0].set('CostElement',record.data.ObjectId);	
12870
												// });
12871
												// task.delay(1000*i);												
12872
												// }
12873
											}
12874
                                        }
12875
                                    }
12876
                                },
12877

    
12878
                                columns: [{
12879
                                    xtype: 'treecolumn',
12880
                                    text: 'Organization Structure',
12881
                                    flex: 2,
12882
                                    sortable: true,
12883
                                    dataIndex: 'TextObject'
12884
                                }, {
12885
                                    text: 'Object ID',
12886
                                    flex: 1,
12887
                                    sortable: true,
12888
                                    dataIndex: 'ObjectId',
12889
                                }, {
12890
                                    text: 'Object Class',
12891
                                    flex: 1,
12892
                                    sortable: true,
12893
                                    dataIndex: 'ObjectType',
12894
                                }, {
12895
                                    text: 'Object Abbr',
12896
                                    flex: 1,
12897
                                    sortable: true,
12898
                                    dataIndex: 'TextObject',
12899
                                }, {
12900
                                    text: 'Start Date',
12901
                                    flex: 1,
12902
                                    sortable: true,
12903
                                    dataIndex: 'StartDate',
12904
                                }, {
12905
                                    text: 'End Date',
12906
                                    flex: 1,
12907
                                    sortable: true,
12908
                                    dataIndex: 'EndDate',
12909
                                }, {
12910
                                    xtype: 'actioncolumn',
12911
                                    text: 'Vacant Status',
12912
                                    flex: 1,
12913
                                    dataIndex: 'IsVacant',
12914
                                    sortable: true,
12915
                                    iconCls: 'fa-child',
12916
                                    renderer: function (value, metadata, record) {
12917
                                        if (record.data.ObjectType == "P") {
12918
                                            var Vacant = record.data.IsVacant;
12919
                                            if (!Vacant) {
12920
                                                metadata.tdStyle = 'font-family: FontAwesome';
12921
                                            }
12922

    
12923
                                        }
12924

    
12925
                                    },
12926
                                }
12927
                                ]
12928

    
12929
                            }
12930
                            ]
12931
                        }
12932
                        ]
12933
                    }, {
12934
                        title: 'Search by Object',
12935
                        //height: 400,
12936
                        autoScroll: true,
12937
                        items: [{
12938
                            xtype: 'form',
12939
                            name: 'filterbyObj',
12940
                            margin: '5 5 5 5',
12941
                            buttons: [{
12942
                                text: 'Search',
12943
                                name: 'SearchAssign',
12944
                                handler: function () {
12945
                                    var storeGrid = Ext.StoreMgr.lookup("gridObj");
12946
                                    var form = Ext.ComponentQuery.query('[name=filterbyObj]')[0].getForm();
12947
                                    if (form.isValid()) {
12948
                                        var values_ = form.getValues();
12949
                                        storeGrid.proxy.url = '/ORM/SearchByObject?StartDate=' + values_.StartDate + "&EndDate=99991231" + "&ObjectID=" + values_.ObjectID + "&ObjectClass=" + values_.ObjectClass +
12950
                                            "&ObjectClassTarget=" + values_.ObjectClassTarget + "&ObjectDescription=" + values_.ObjectDescription +
12951
                                            "&Abbreviation=" + values_.Abbreviation + "&MenuID=" + MinovaUtil.GetMenuID() +
12952
                                            "&TreeStructCode=" + values_.TreeStructCode;
12953
                                        storeGrid.load({});
12954
                                        storeGrid.loadPage(1);
12955

    
12956
                                    }
12957

    
12958
                                }
12959
                            }
12960
                            ],
12961
                            items: [{
12962
                                xtype: "datefield",
12963
                                fieldLabel: "Date",
12964
                                name: 'StartDate',
12965
                                submitFormat: 'Ymd',
12966
                                format: 'd/m/Y',
12967
                                value: new Date(),
12968
                                anchor: '50%',
12969
                            }, {
12970
                                xtype: "hidden",
12971
                                fieldLabel: "Date",
12972
                                name: 'ObjectClass',
12973
                                value: AllObjectClass[0],
12974
                                anchor: '50%',
12975
                            }, {
12976
                                xtype: "hidden",
12977
                                fieldLabel: "Date",
12978
                                name: 'EndDate',
12979
                                value: '99991231',
12980
                                anchor: '50%',
12981
                            }, {
12982
                                xtype: "combobox",
12983
                                fieldLabel: "Object Class",
12984
                                name: 'ObjectClassTarget',
12985
                                allowBlank: false,
12986
                                anchor: '50%',
12987
                                displayField: 'desc',
12988
                                valueField: 'code',
12989
                                store: Ext.create('Ext.data.Store', {
12990
                                    storeId: 'storeYesNo',
12991
                                    fields: ['code', 'desc'],
12992
                                    data: [{
12993
                                        "desc": AllObjectClass[0],
12994
                                        "code": AllObjectClass[0]
12995
                                    }, {
12996
                                        "desc": AllObjectClass[2],
12997
                                        "code": AllObjectClass[2]
12998
                                    }
12999
                                    ]
13000
                                }),
13001
                                queryMode: 'local',
13002
                            }, {
13003
                                xtype: "textfield",
13004
                                fieldLabel: "Object ID",
13005
                                name: 'ObjectID',
13006
                                anchor: '50%',
13007
                            }, {
13008
                                xtype: "textfield",
13009
                                fieldLabel: "Object Description",
13010
                                name: 'ObjectDescription',
13011
                                anchor: '50%',
13012
                            }, {
13013
                                xtype: "textfield",
13014
                                fieldLabel: "Abbreviation",
13015
                                name: 'Abbreviation',
13016
                                anchor: '50%',
13017
                            }, {
13018
                                xtype: "hidden",
13019
                                fieldLabel: "MenuID",
13020
                                name: 'MenuID',
13021
                                anchor: '50%',
13022
                                value: MinovaUtil.GetMenuID()
13023
                            }, {
13024
                                xtype: "hidden",
13025
                                fieldLabel: "TreeStructCode",
13026
                                name: 'TreeStructCode',
13027
                                anchor: '50%',
13028
                                value: treeSructure_
13029
                            },
13030
                            ],
13031
                        }, {
13032
                            xtype: "minovagrid1",
13033
                            tableName: 'PDSBS0008',
13034
                            name: "gridbyObject",
13035
                            param: '',
13036
                            autoLoad: false,
13037
                            pagesize: 5,
13038
                            storename: 'gridObj',
13039
                            isLookup: true,
13040
                            //height: 250,
13041
                            targetField: targetField_,
13042
                            formname: formname_,
13043
                            bodyPadding: 0,
13044
                            listeners: {
13045
                                afterrender: function (me_) {
13046
                                    if (treeSructure_ != 'O-O-P') {
13047
                                        var countCol = me_.columns.length;
13048
                                        me_.columns[countCol - 1].setHidden(true);
13049

    
13050
                                    }
13051
                                },
13052
                                itemdblclick: function (this_, record, item, index, e, eOpts) {
13053
                                    console.log(record.data);
13054
                                    var cek = false;
13055
                                    if (objClassValue_ == record.data.ObjectClass) {
13056
                                        var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0].getForm();
13057
                                        if (form_.findField(targetField_).nameTable.substr(3, 2).toLowerCase() != "rc") {
13058
                                            if (objClassValue_ == 'P') {
13059
                                                // cek apakah posisis sudah di assign
13060
                                                var hasil = null;
13061
                                                Ext.Ajax.request({
13062
                                                    async: false,
13063
                                                    method: 'POST',
13064
                                                    url: '/UserControl/GetStore',
13065
                                                    params: {
13066
                                                        tableName: 'PHROM0002',
13067
                                                        param: 'ObjectClass[=]P,RelationshipDirectory[=]A,RelationshipClass[=]E,StartDate[GreaterThanEqual]' + StartDate_ + ',ObjectID[=]' + record.data.ObjectID
13068
                                                    },
13069
                                                    success: function (response) {
13070
                                                        var results = Ext.decode(response.responseText);
13071
                                                        //hasil = results.data[0].RelationshipObject;
13072
                                                        hasil = results.data.length;
13073
                                                        if (hasil == 0) {
13074
                                                            cek = true;
13075
                                                        }
13076
                                                        //count = hasil.length
13077
                                                    }
13078
                                                });
13079

    
13080
                                            } else {
13081
                                                cek = true;
13082
                                            }
13083
                                        } else {
13084
                                            cek = true;
13085
                                        }
13086
                                    }
13087
                                    if (cek) {
13088
                                        var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0].getForm();
13089
                                        //form_.findField(targetField_).setValue(record.data.ObjectID);
13090
                                        //form_.findField(targetField_).valData = record.data.ObjectID + ' - ' + record.data.ObjectDescription;
13091
                                        form_.findField(targetField_).setValue('-');
13092
                                        form_.findField(targetField_).valData = '-';
13093
                                        form_.findField(targetField_).setValue(record.data.ObjectID);
13094
                                        form_.findField(targetField_).valData = record.data.ObjectID;
13095
                                        form_.findField(targetField_).setRawValue(record.data.ObjectID + ' - ' + record.data.ObjectDescription);
13096
                                        Ext.ComponentQuery.query('[name=' + targetField_ + 'lookUp' + ']')[0].destroy();
13097
                                    } else {
13098
                                        alert(MinovaMessageData('OM0001', ''))
13099
                                    }
13100
                                },
13101
                                beforeclick: function () {
13102
                                    return false;
13103
                                }
13104

    
13105
                            },
13106
                            dockedItems: [{
13107
                                xtype: 'pagingtoolbar',
13108
                                store: 'gridObj',
13109
                                dock: 'bottom',
13110
                                displayInfo: true
13111
                            }
13112

    
13113
                            ]
13114
                        },
13115
                        ]
13116

    
13117
                    }
13118
                    ]
13119

    
13120
                }
13121
                ]
13122
            },
13123
            ]
13124

    
13125
        });
13126
        me.callParent(arguments);
13127
    }
13128
});
13129

    
13130

    
13131
Ext.define('MinovaUtil.MinovaES.MinovaLookupTree', {
13132
    extend: 'Ext.form.field.Trigger',
13133
    alias: ['widget.minovalookuptree', 'widget.MinovaLookupTree'],
13134
    treeSructure: undefined, // object relationship
13135
    objClassValue: undefined, // object yang akan di input ke field
13136
    formname: undefined, // nama form
13137
    targetField: undefined, // nama field yang akan diset value
13138
    initComponent: function () {
13139

    
13140
        this.callParent();
13141
    },
13142
    getValue: function () {
13143
        var me = this;
13144
        var hasil = '';
13145
        if (this.valData) {
13146
            hasil = this.valData.split('-')[0].replace(' ', '');
13147

    
13148
        } else {
13149
            if (me.rawValue != '' && me.rawValue != undefined) {
13150
                hasil = me.rawValue.split('-')[0].replace(' ', '');
13151
            }
13152
        }
13153

    
13154
        return hasil;
13155
    },
13156
    getSubmitValue: function () {
13157
        var me = this;
13158
        var hasil = '';
13159
        if (this.valData) {
13160
            hasil = this.valData.split('-')[0].replace(' ', '');
13161
        } else {
13162
            if (me.rawValue != '' && me.rawValue != undefined) {
13163
                hasil = me.rawValue.split('-')[0].replace(' ', '');
13164
            }
13165
        }
13166

    
13167
        return hasil;
13168
    },
13169
    onTriggerClick: function () {
13170
        var _treeSructure = this.treeSructure;
13171
        var _objClassValue = this.objClassValue;
13172
        var _formname = this.formname;
13173
        var _targetField = this.name;
13174
        var _fieldLabel = this.fieldLabel;
13175
        var _objFilter = this.objFilter;
13176
        var Mainform = Ext.ComponentQuery.query('[name=' + _formname + ']')[0];
13177
        var _StartDate = MinovaUtil.GetNowDate();
13178
        if (Mainform) {
13179
			if(Mainform.getForm=='undefined'){
13180
            if (Mainform.getForm().findField('StartDate')) {
13181
                _StartDate = Mainform.getForm().findField('StartDate').getValue();
13182
            }				
13183
			}
13184
        }
13185
        //alert(treeSructure_ + ',' + objClassValue_ + ',' + formname_ + ',' + targetField_)
13186
        if (_StartDate != "") {
13187
            Ext.create('MinovaES.view.orm.lookup.minovalookuptreePopup', {
13188
                name: _targetField + 'lookUp',
13189
                treeSructure: _treeSructure, // object relationship
13190
                objClassValue: _objClassValue, // object yang akan di input ke field
13191
                formname: _formname, // nama form
13192
                targetField: _targetField,
13193
                objFilter: _objFilter,
13194
                title: 'Lookup ' + _fieldLabel
13195
            }).show()
13196
        } else {
13197
            MinovaMessage('', 'BS0001', 'Start Date', 'E')
13198
        }
13199

    
13200
    },
13201
});
13202

    
13203
Ext.define('MinovaUtil.MinovaES.LookupEmployee', {
13204
    extend: 'Ext.window.Window',
13205
    alias: 'widget.minovalookupemployee',
13206
    requires: [],
13207
    height: '87%', //'60%'
13208
    width: '41%',
13209
    minWidth: '50%',
13210
    maxWidth: '100%',
13211
    bodyPadding: 0,
13212
    formname: undefined,
13213
    name: 'popup_lookupEMPID',
13214
    test: undefined,
13215
    vtype: 'validateMinovaXss',
13216
    targetField: undefined,
13217
    valueField: undefined,
13218
    tableName: undefined,
13219
    LookupFunction: undefined,
13220
    isGrid: undefined,
13221
    listeners: {
13222
        afterrender: function (f) {
13223
            f.setTitle('Lookup - ' + f.targetField);
13224
        }
13225
    },
13226
    initComponent: function () {
13227
        var me = this;
13228
        var targetField_ = me.targetField;
13229
        var valueField_ = me.valueField;
13230
        var form = me.test;
13231
        var tableName_ = me.tableName;
13232
        var isGrid = me.isGrid_;
13233
        var LookupFunction = me.LookupFunction;
13234
        param_ = null;
13235

    
13236
        var filterParam_ = me.filterParam;
13237
        if (tableName_ == "PDSRC0002") {
13238
            fieldLabel_ = 'App ID/ External ID/ Full Name';
13239
        } else if(tableName_ == 'PCMPROCNUMBER'){
13240
			fieldLabel_ = 'Process Number';
13241
		} else {
13242
            fieldLabel_ = 'Emp ID/ External ID/ Full Name';
13243
        }
13244
        Ext.applyIf(me, {
13245
            items: [{
13246
                items: [{
13247
                    xtype: 'tabpanel',
13248
                    items: [{
13249
                        xtype: 'form',
13250
                        title: 'Quick Search',
13251
                        height: '70%',
13252
                        items: [{
13253
                            xtype: 'form',
13254
                            name: 'frmSearch',
13255
                            width: '100%',
13256
                            height: 'auto',
13257
                            dockedItems: [{
13258
                                xtype: 'toolbar',
13259
                                dock: 'top',
13260
                                layout: 'vbox',
13261
                                bodyPadding: 10,
13262
                                border: 0,
13263
                                items: [{
13264
                                    xtype: 'fieldset',
13265
                                    layout: 'hbox',
13266
                                    width: '100%',
13267
                                    border: 0,
13268
                                    padding: 0,
13269
                                    items: [{
13270
                                        xtype: 'textfield',
13271
                                        name: 'EmployeeSearch',
13272
                                        fieldLabel: fieldLabel_,
13273
                                        width: 470,
13274
                                        labelWidth: 185,
13275
                                        enableKeyEvents: true,
13276
                                        filterParam: filterParam_,
13277
                                        listeners: {
13278
                                            specialkey: function (f, e) {
13279
                                                if (e.getKey() == e.ENTER) {
13280
                                                    var emp = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
13281
                                                    var emp_ = emp.getValue();
13282
                                                    var store = Ext.data.StoreManager.lookup('storeQC');
13283
                                                    var grid = Ext.ComponentQuery.query('[name=EmployeeID]')[0];
13284
                                                    if (tableName_ == 'PDSRC0002') {
13285
                                                        param_ = 'AppIDExternalIDFullName[like]' + emp_
13286
                                                    } else {
13287
                                                        param_ = 'EmpIDExternalIDFullName[like]' + emp_
13288
                                                    }
13289
                                                    if (this.filterParam) {
13290
                                                        param_ = param_ + ',' + this.filterParam_
13291
                                                    }
13292

    
13293
                                                    store.proxy.extraParams = {
13294
                                                        tableName: tableName_,
13295
                                                        param: param_,
13296
                                                        menuId: MinovaUtil.GetMenuID()
13297
                                                    };
13298
                                                    store.removeAll();
13299
                                                    store.reload();
13300
                                                    store.loadPage(1);
13301
                                                }
13302
                                            }
13303
                                        }
13304
                                    }, {
13305
                                        xtype: 'tbspacer',
13306
                                        width: 5
13307
                                    }, {
13308
                                        xtype: 'button',
13309
                                        name: 'Search',
13310
                                        text: 'Search',
13311
                                        filterParam: filterParam_,
13312
                                        handler: function () {
13313
                                            var emp = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
13314
                                            var emp_ = emp.getValue();
13315
                                            var store = Ext.data.StoreManager.lookup('storeQC');
13316
                                            var grid = Ext.ComponentQuery.query('[name=EmployeeID]')[0];
13317

    
13318
											
13319
                                            if (tableName_ == 'PDSRC0002') {
13320
                                                param_ = 'AppIDExternalIDFullName[like]' + emp_
13321
                                            }else {
13322
                                                param_ = 'EmpIDExternalIDFullName[like]' + emp_
13323
                                            }
13324
                                            if (this.filterParam) {
13325
                                                param_ = param_ + ',' + this.filterParam
13326
                                            }
13327
											if(tableName_ == 'PCMPROCNUMBER'){
13328
												var docno = Ext.ComponentQuery.query('[name=MainHeaderDocument]')[0].getForm().findField('DocNo').getValue();
13329
                                                param_ = 'DocNo[like]'+docno+',ProcessNumber[like]' + emp_;
13330
												store.proxy.extraParams = {
13331
													tableName: 'PTRPRODUCTIONPROCESSOVERVIEW',
13332
													param: param_,
13333
													menuId: MinovaUtil.GetMenuID()
13334
												};												
13335
                                            }else{
13336
												store.proxy.extraParams = {
13337
													tableName: tableName_,
13338
													param: param_,
13339
													menuId: MinovaUtil.GetMenuID()
13340
												};												
13341
											}										
13342

    
13343
                                            store.removeAll();
13344
                                            store.reload();
13345
                                            store.loadPage(1);
13346
                                        }
13347
                                    }
13348
                                    ]
13349
                                }
13350
                                ]
13351
                            }
13352
                            ]
13353
                        }, {
13354
                            items: [{
13355
                                xtype: "minovagrid1",
13356
                                name: "GridEmployeeID",
13357
                                storename: 'storeQC',
13358
                                tableName: tableName_,
13359
                                param: '',
13360
                                isLookup: true,
13361
                                pagesize: 25,
13362
                                height: 398,
13363
                                LookupFunction: LookupFunction,
13364
                                valueField: valueField_,
13365
                                targetField: targetField_,
13366
                                isGrid: true,
13367
                                listeners: {
13368
                                    beforeedit: function () {
13369
                                        return false;
13370
                                    },
13371
                                    itemdblclick: function () {
13372
                                        var grid = Ext.ComponentQuery.query('[name=GridEmployeeID]')[0];
13373
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
13374
                                        var Emp_ = '';
13375
										var gridPanel =undefined;
13376
										var gridPanelrows=0;
13377
										var tabtabelname = '';
13378
										if(tableName_ == 'PCMPROCNUMBER'){
13379
											tabtabelname = Ext.ComponentQuery.query('[name=panelTab]')[0].getActiveTab().initialConfig.tbl;
13380
											gridPanel =Ext.ComponentQuery.query('[name=gridCELLGRID'+tabtabelname+']')[0];
13381
											gridPanelrows=gridPanel.store.indexOf(gridPanel.getView().getSelection()[0]);
13382
											Emp_ = selection.data.ProcessNumber;
13383
										}else{
13384
											Emp_ = selection.data.EmployeeID;
13385
										}
13386
                                        LookupFunction = this.LookupFunction;
13387
                                        eval(LookupFunction);
13388
                                        var target = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField;
13389
                                        Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(Emp_);
13390
                                        Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].hide();
13391
										if(tableName_ == 'PCMPROCNUMBER'){
13392
											gridPanel.getStore().getRange()[gridPanelrows].set('ProcessNumber',Emp_);
13393
										}
13394
                                    }
13395
                                },
13396
                            }, {
13397
                                xtype: 'pagingtoolbar',
13398
                                store: 'storeQC',
13399
                                dock: 'bottom',
13400
                                displayInfo: true
13401
                            }
13402
                            ]
13403
                        }
13404
                        ]
13405
                    }, {
13406
                        title: 'Advance Search',
13407
                        items: [{
13408
                            xtype: 'form',
13409
                            name: 'formlookup',
13410
                            items: [{
13411
                                xtype: 'minovaform',
13412
                                name: 'frmlookup',
13413
                                tableName: tableName_,
13414
                                param: filterParam_,
13415
                                isLookup: true,
13416
                                listeners: {
13417
                                    onStockFormKeyPress: function (textfield, event, options) {
13418
                                        if (event.getKey() == event.ENTER) {
13419
                                            alert("test");
13420
                                        }
13421
                                    }
13422
                                },
13423
                                buttons: [{
13424
                                    text: 'Search',
13425
                                    filterParam: filterParam_,
13426
                                    listeners: {
13427
                                        click: function () {
13428
                                            var store = Ext.data.StoreManager.lookup('storeadvance');
13429
                                            var form = Ext.ComponentQuery.query('[name=formlookup]')[0].getForm();
13430
                                            grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
13431
                                            var values_ = form.getValues();
13432
                                            var fields_ = form.getFields().items;
13433
                                            var param_ = '';
13434
                                            for (var i = 0; i < fields_.length; i++) {
13435
                                                var val_ = form.getFields().items[i].getValue();
13436
                                                var xtype_ = form.getFields().items[i].xtype;
13437
                                                var oprator_ = '[like]';
13438
                                                if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
13439
                                                    oprator_ = '[Equal]';
13440
                                                }
13441
                                                if (xtype_ == 'datefield') {
13442
                                                    if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
13443
                                                        oprator_ = '[LessThanEqual]';
13444
                                                    } else {
13445
                                                        oprator_ = '[GreaterThanEqual]';
13446
                                                    }
13447
                                                }
13448
                                                if (val_ != 'undefined' && val_ != "" && val_ != null) {
13449
                                                    param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
13450
                                                }
13451
                                            }
13452
                                            if (this.filterParam_) {
13453
                                                param_ = param_ + ',' + this.filterParam_
13454
                                            }
13455
                                            store.proxy.extraParams = {
13456
                                                tableName: grid.tableName,
13457
                                                param: param_,
13458
                                                menuId: MinovaUtil.GetMenuID()
13459
                                            };
13460
                                            store.removeAll();
13461
                                            store.reload();
13462
                                            store.loadPage(1);
13463
                                        },
13464

    
13465
                                    }
13466
                                }
13467
                                ]
13468
                            }, {
13469
                                xtype: 'minovagrid1', // update by hamid 20170208
13470
                                name: 'gridlookup',
13471
                                minHeight: 312,
13472
                                height: 290,
13473
                                tableName: tableName_, //'PDSEMP0001',
13474
                                param: '',
13475
                                isLookup: true,
13476
                                storename: 'storeadvance',
13477
                                pagesize: 25,
13478
                                valueField: valueField_,
13479
                                targetField: targetField_,
13480
                                hidebutton: 0, // update by hamid 20170208
13481
                                isGrid: true,
13482
                                listeners: {
13483
                                    beforeedit: function () {
13484
                                        return false;
13485
                                    },
13486
                                    itemdblclick: function () {
13487
                                        var grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
13488
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
13489
                                        var Emp_ = selection.data.EmployeeID;
13490
                                        LookupFunction = this.LookupFunction;
13491
                                        eval(LookupFunction);
13492
                                        var target = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField;
13493
                                        Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(Emp_);
13494
                                        Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].hide();
13495
                                    }
13496
                                },
13497
                                dockedItems: [{
13498
                                    xtype: 'pagingtoolbar',
13499
                                    store: 'storeadvance',
13500
                                    dock: 'bottom',
13501
                                    displayInfo: true
13502
                                }
13503
                                ]
13504
                            }
13505
                            ]
13506

    
13507
                        }
13508
                        ]
13509

    
13510
                    }
13511
                    ]
13512

    
13513
                }
13514
                ]
13515
            }
13516
            ]
13517
        });
13518
        me.callParent(arguments);
13519
    }
13520
});
13521

    
13522
Ext.define('MinovaUtil.MinovaES.MinovaLookupEmployee', {
13523
    extend: 'Ext.form.field.Trigger',
13524
    alias: 'widget.lookupemployee',
13525

    
13526
    formname: undefined,
13527
    fieldname: undefined,
13528
    allowBlank: undefined,
13529
    width: undefined,
13530
    tableName: undefined,
13531
    LookupFunction: undefined,
13532
    targetField: undefined,
13533
    vtype: 'validateMinovaXss',
13534
    fieldValue: undefined,
13535
    initComponent: function () {
13536

    
13537
        this.callParent();
13538
    },
13539
    onTriggerClick: function () {
13540
        var nameField_ = this.fieldname;
13541
        var blank = this.allowBlank;
13542
        var width_ = this.width;
13543
        var tableName_ = this.tableName;
13544
        var panelform = "form" + this.name;
13545
        //add filer by atin
13546
        var filterParam_ = this.filterParam;
13547
        // and add by atin
13548
        var _targetField = this.name;
13549
        if (this.targetField) {
13550
            _targetField = targetField
13551
        }
13552
        var fieldValue_ = this.fieldValue;
13553
        var _fieldLabel = this.fieldLabel;
13554

    
13555
        //var tableName_ = this.tableName;
13556
        var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
13557
        var lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0];
13558
        var EmployeeID = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13559
        var EmployeeID_ = EmployeeID.getValue();
13560
        var LookupFunction = this.LookupFunction;
13561
        var popup_lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
13562
        if (count_lookup == 1) {
13563
            Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField = this.name;
13564
            Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].show();
13565
        } else {
13566
            Ext.create('MinovaUtil.MinovaES.LookupEmployee', {
13567
				height: '25%', //saswanto 31jan2022
13568
                tableName: tableName_,
13569
                targetField: this.name,
13570
                fieldValue: fieldValue_,
13571
                LookupFunction: LookupFunction,
13572
                filterParam: filterParam_,
13573
            }).show()
13574
        }
13575
        var text = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
13576
        text.setValue(EmployeeID_);
13577
        var store = Ext.data.StoreManager.lookup('storeQC');
13578
        if (EmployeeID_ !== "") {
13579

    
13580
            var grid = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13581
            if (tableName_ == 'PDSEMP0002') {
13582
                param_ = 'EmpIDExternalIDFullName[like]' + EmployeeID_
13583
            } else {
13584
                param_ = 'AppIDExternalIDFullName[like]' + EmployeeID_
13585
            }
13586
            if (filterParam_) {
13587
                param_ = param_ + ',' + filterParam_;
13588
            }
13589
            store.proxy.extraParams = {
13590
                tableName: tableName_, //'PDSEMP0002',
13591
                param: param_,
13592
                menuId: MinovaUtil.GetMenuID()
13593
            };
13594
            store.reload();
13595
        } else {
13596
            store.proxy.extraParams = {
13597
                tableName: tableName_, //'PDSEMP0002',
13598
                param: filterParam_,
13599
                menuId: MinovaUtil.GetMenuID()
13600
            };
13601
            store.reload();
13602
        }
13603

    
13604
    },
13605
    listeners: {
13606
        specialkey: function (f, e) {
13607
            if (e.getKey() == e.ENTER) {
13608
                //alert("about to submit");
13609
                var nameField_ = this.fieldname;
13610
                var blank = this.allowBlank;
13611
                var width_ = this.width;
13612
                var tableName_ = this.tableName;
13613
                var panelform = "form" + this.name;
13614
                //add filer by atin
13615
                var filterParam = this.filterParam;
13616
                // and add by atin
13617
                var _targetField = this.name;
13618
                var _fieldLabel = this.fieldLabel;
13619
                var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
13620
                var lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0];
13621
                var EmployeeID = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13622
                var EmployeeID_ = EmployeeID.getValue();
13623

    
13624
                var popup_lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
13625
                if (count_lookup == 1) {
13626
                    Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField = this.name;
13627
                    Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].show();
13628
                } else {
13629
                    Ext.create('MinovaUtil.MinovaES.LookupEmployee', {
13630
                        tableName: tableName_,
13631
                        targetField: this.name,
13632
                        fieldValue: this.fieldValue,
13633
                        LookupFunction: this.LookupFunction,
13634
                        filterParam: filterParam,
13635
                    }).show()
13636
                }
13637
                var text = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
13638
                text.setValue(EmployeeID_);
13639

    
13640
                if (EmployeeID_ !== "") {
13641
                    var store = Ext.data.StoreManager.lookup('storeQC');
13642
                    var grid = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13643
                    if (tableName_ == 'PDSEMP0002') {
13644
                        param_ = 'EmpIDExternalIDFullName[like]' + EmployeeID_
13645
                    } else {
13646
                        param_ = 'AppIDExternalIDFullName[like]' + EmployeeID_
13647
                    }
13648
                    if (filterParam_) {
13649
                        param_ = param_ + ',' + filterParam_;
13650
                    }
13651
                    store.proxy.extraParams = {
13652
                        tableName: tableName_, //'PDSEMP0002',
13653
                        param: param_,
13654
                        menuId: MinovaUtil.GetMenuID()
13655
                    };
13656
                    store.reload();
13657
                }
13658
            }
13659
        }
13660
    }
13661

    
13662
});
13663
Ext.define('MinovaUtil.MinovaES.UploadFile', {
13664
    extend: 'Ext.form.field.Trigger',
13665
    alias: 'widget.uploadfile',
13666

    
13667
    //fieldLabel: undefined,
13668
    uploadName: 'uploadName',
13669
    formname: undefined,
13670
    fieldname: undefined,
13671
    allowBlank: undefined,
13672
    width: undefined,
13673
    tableName: undefined,
13674
    initComponent: function () {
13675

    
13676
        this.callParent();
13677
    },
13678
    onTriggerClick: function () {
13679
        var nameField_ = this.fieldname;
13680
        var blank = this.allowBlank;
13681
        var width_ = this.width;
13682
        var tableName_ = this.tableName;
13683
        var panelform = "form" + this.name;
13684
        var val_ = this.value;
13685
        var _targetField = this.name;
13686
        var _fieldLabel = this.fieldLabel;
13687

    
13688
        //var tableName_ = this.tableName;
13689
        var count_lookup = Ext.ComponentQuery.query('[name=FormFileUpload]').length;
13690
        var lookupEMPID = Ext.ComponentQuery.query('[name=FormFileUpload]')[0];
13691
        var EmployeeID = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13692
        var EmployeeID_ = EmployeeID.getValue();
13693

    
13694
        var FormFileUpload = Ext.ComponentQuery.query('[name=FormFileUpload]').length;
13695
        Ext.create('MinovaES.view.uploadfile.fileupload', {
13696
            tableName: tableName_,
13697
            targetField: this.name,
13698
            valueFile: val_,
13699
            titleLookup: _fieldLabel,
13700
        }).show()
13701

    
13702
    }
13703

    
13704
});
13705

    
13706
//atien
13707
Ext.define('MinovaES.view.uploadfile.fileupload', {
13708
    extend: 'Ext.window.Window',
13709
    alias: 'widget.fileupload',
13710
    requires: [
13711

    
13712
    ],
13713
    //height: '67%',
13714
    width: '35%',
13715
    minWidth: '50%',
13716
    maxWidth: '100%',
13717
    bodyPadding: 0,
13718
    formname: undefined,
13719
    fieldname: undefined,
13720
    modal: true,
13721
    title: 'Upload ',
13722
    name: 'FormLookup',
13723
    test: undefined,
13724
    targetField: undefined,
13725
    tableName: undefined,
13726
    listeners: {
13727
        afterrender: function (f) {
13728
            f.setTitle('Upload ' + f.titleLookup);
13729
            var id_ = Ext.ComponentQuery.query('minovanumberfield[name=FileID]')[0];
13730
            if (id_) {
13731
                var valID = id_.getValue();
13732
                Ext.ComponentQuery.query('textfield[name=FileID_]')[0].setValue(valID);
13733
            }
13734
        },
13735
    },
13736
    initComponent: function () {
13737
        var me = this;
13738
        var targetField_ = me.targetField;
13739
        var titleLookup_ = me.titleLookup;
13740
        var maxFileSize = me.maxFileSize;
13741
        var fileName = me.valueFile;
13742
        Ext.applyIf(me, {
13743
            items: [{
13744
                xtype: 'form',
13745
                name: 'FormFileUpload',
13746
                valueFile: fileName,
13747
                buttons: [{
13748
                    xtype: 'button',
13749
                    iconCls: 'fa-upload',
13750
                    style: 'font-family: FontAwesome',
13751
                    text: 'Upload',
13752
                    action: 'Upload',
13753
                    name: 'Upload',
13754
                    handler: function () {
13755
                        maxFileSize = Ext.ComponentQuery.query('uploadfile[name=' + targetField_ + ']')[0].maxFileSize;
13756
                        Ext.ComponentQuery.query('[name=FileMax]')[0].setValue(maxFileSize);
13757
                        var form = Ext.ComponentQuery.query('form[name=FormFileUpload]')[0].getForm();
13758
                        pnl = Ext.ComponentQuery.query('[name=FormLookup]')[0]; // by hamid 20170206
13759
                        if (form.isValid()) {
13760
                            form.submit({
13761
                                url: '/Devt/UploadFile',
13762
                                waitMsg: 'Uploading your file...',
13763
                                success: function (fp, o) {
13764
                                    var result = o.result;
13765
                                    Ext.ComponentQuery.query('uploadfile[name=' + targetField_ + ']')[0].setValue(result.FileName);
13766
                                    Ext.ComponentQuery.query('[name=FormFileUpload]')[0].valueFile = result.FileName;
13767
                                    Ext.ComponentQuery.query('[name=download]')[0].fileName = result.FileName;
13768
                                    var fileID = Ext.ComponentQuery.query('minovanumberfield[name=FileID]')[0]
13769
                                    if (fileID) {
13770
                                        fileID.setValue(result.ID);
13771
                                    }
13772

    
13773
                                    if (result.msg === "") {
13774
                                        if (me.onSuccess !== undefined)
13775
                                            me.onSuccess(result.FileName, result.content_type);
13776
                                        pnl.destroy(); // by hamid 20170206
13777
                                    } else
13778
                                        alert(result.msg);
13779
										
13780
									//by Agung 20200428
13781
									Ext.ComponentQuery.query('[name=FORMPHRUPLOADFILE]')[0].getForm().findField('FileID').setValue(result.ID);
13782
									Ext.ComponentQuery.query('[name=FORMPHRUPLOADFILE]')[0].getForm().findField('FileName').setValue(result.FileName);
13783
                                }
13784
                            });
13785
                        }
13786
                    }
13787
                }, {
13788
                    xtype: 'button',
13789
                    text: 'Clear',
13790
                    width: 60,
13791
                    handler: function () {
13792
                        //Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0].setValue('');
13793
                        Ext.ComponentQuery.query('[name=' + targetField_ + ']')[0].setValue(''); // by hamid 20170206
13794
                    }
13795
                }, {
13796
                    xtype: 'button',
13797
                    text: 'Download',
13798
                    name: 'download',
13799
                    width: 60,
13800
                    fileName: fileName,
13801
                    handler: function (f) {
13802
                        var url = '/Devt/GetFileData?FileName=' + f.fileName + '&download=true';
13803
                        window.open(url, '_blank');
13804
                    }
13805
                    //href: '/Devt/GetFileData?FileName=' + me.valueFile + '&download=true',
13806

    
13807
                }
13808
                ],
13809
                items: [{
13810
                    xtype: 'filefield',
13811
                    name: 'File',
13812
                    fieldLabel: 'Select File',
13813
                    //allowBlank: false,
13814
                    //width: 270,
13815
                    //labelWidth: 85,
13816
                }, {
13817
                    xtype: 'textfield',
13818
                    name: 'FileID_',
13819
                    hidden: true,
13820
                }, {
13821
                    xtype: 'textfield',
13822
                    name: 'FileMax',
13823
                    hidden: true,
13824
                }
13825
                ]
13826
            }
13827
            ]
13828
        });
13829
        me.callParent(arguments);
13830
    }
13831
});
13832
//atien
13833

    
13834

    
13835
//update by hamid 12012017
13836
Ext.define('MinovaES.view.uploadfile.fileupload1', {
13837
    extend: 'Ext.window.Window',
13838
    alias: 'widget.fileupload1',
13839
    requires: [
13840

    
13841
    ],
13842
    height: '67%',
13843
    width: '21%',
13844
    minWidth: '50%',
13845
    maxWidth: '100%',
13846
    bodyPadding: 0,
13847
    formname: undefined,
13848
    fieldname: undefined,
13849
    //modal: true,
13850
    title: 'Lookup - Photo',
13851
    name: 'FormLookup',
13852
    test: undefined,
13853
    targetField: undefined,
13854
    tableName: undefined,
13855
    initComponent: function () {
13856
        var me = this;
13857
        var targetField_ = me.targetField;
13858
        var nameField_ = this.fieldname;
13859
        var form = me.test;
13860
        var tableName_ = me.tableName;
13861
        //var img_ = Ext.ComponentQuery.query('[name=Photo]')[0].getValue()
13862
        var img_ = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
13863
        Ext.applyIf(me, {
13864
            // items: [{
13865
            //xtype : 'panel',
13866
            items: [{
13867
                xtype: 'tabpanel',
13868
                //name: 'mainTab',
13869
                items: [{
13870
                    xtype: 'form',
13871
                    title: 'Upload File',
13872
                    height: '70%',
13873
                    name: 'FormFileUpload',
13874
                    buttons: [{
13875
                        xtype: 'button',
13876
                        iconCls: 'fa-upload',
13877
                        style: 'font-family: FontAwesome',
13878
                        text: 'Upload',
13879
                        action: 'Upload',
13880
                        name: 'Upload',
13881
                        handler: function () {
13882
                            //var Tab = Ext.ComponentQuery.query('[name=mainTab]')[0].getActiveTab();
13883
                            var form = Ext.ComponentQuery.query('form[name=FormFileUpload]')[0].getForm();
13884
                            pnl = Ext.ComponentQuery.query('[name=FormLookup]')[0];
13885
                            if (form.isValid()) {
13886
                                form.submit({
13887
                                    url: '/Devt/UploadFile',
13888
                                    waitMsg: 'Uploading your file...',
13889
                                    success: function (fp, o) {
13890
                                        var result = o.result;
13891
                                        Ext.ComponentQuery.query('[name=' + targetField_ + ']')[0].setValue(result.FileName)
13892
                                        //Ext.ComponentQuery.query('[name=Photo]')[0].setValue(result.FileName)
13893
                                        if (result.msg === "") {
13894
                                            //alert('success');
13895
                                            if (me.onSuccess !== undefined)
13896
                                                me.onSuccess(result.FileName, result.content_type);
13897
                                            pnl.destroy();
13898
                                        } else
13899
                                            alert(result.msg);
13900
                                    }
13901
                                });
13902
                            }
13903
                        }
13904
                    }, {
13905
                        xtype: 'button',
13906
                        text: 'Clear',
13907
                        width: 60,
13908
                        handler: function () {
13909
                            Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0].setValue('');
13910
                            //Ext.ComponentQuery.query('[name=Photo]')[0].setValue('');
13911

    
13912
                        }
13913
                    }
13914
                    ],
13915
                    items: [{
13916
                        xtype: 'fieldset',
13917
                        layout: 'hbox',
13918
                        width: '100%',
13919
                        bodyPadding: 10,
13920
                        border: 0,
13921
                        padding: 0,
13922
                        items: [{
13923
                            xtype: 'filefield',
13924
                            name: 'File',
13925
                            fieldLabel: 'Select File',
13926
                            //allowBlank: false,
13927
                            width: 270,
13928
                            labelWidth: 85,
13929
                        }
13930
                        ]
13931
                    }
13932
                    ]
13933
                    //items: [{
13934
                    //    xtype: 'form',
13935
                    //    name: 'Photo',
13936
                    //    width: '100%',
13937
                    //    height: 'auto',
13938
                    //    dockedItems: [{
13939
                    //        xtype: 'toolbar',
13940
                    //        dock: 'top',
13941
                    //        layout: 'vbox',
13942
                    //        bodyPadding: 10,
13943
                    //        border: 0,
13944
                    //        items: [{
13945
                    //            xtype: 'fieldset',
13946
                    //            layout: 'hbox',
13947
                    //            width: '100%',
13948
                    //            border: 0,
13949
                    //            padding: 0,
13950
                    //            items: [{
13951
                    //                xtype: 'filefield',
13952
                    //                name: 'SelectFile',
13953
                    //                fieldLabel: 'Select File',
13954
                    //                width: 270,
13955
                    //                labelWidth: 85,
13956
                    //                enableKeyEvents: true,
13957
                    //                buttonText: 'Browse',
13958
                    //            }]
13959

    
13960
                    //        }
13961
                    //        ]
13962
                    //    }
13963
                    //    ]
13964
                    //}]
13965
                }, {
13966
                    title: 'View Image',
13967
                    //height: 400,
13968
                    //autoScroll: true,
13969
                    items: [{
13970
                        xtype: 'form',
13971
                        name: 'ViewImage',
13972
                        //margin: '5 5 5 5',
13973
                        items: [{
13974
                            xtype: 'form',
13975
                            buttons: [{
13976
                                text: 'Download',
13977
                                handler: function () {},
13978
                                href: '/Devt/GetFileData?FileName=' + img_ + '&download=true'
13979

    
13980
                            }
13981
                            ],
13982
                            items: [{
13983
                                xtype: 'image',
13984
                                //id: 'imageuser',
13985
                                src: '/Devt/GetFileData?FileName=' + img_ + '&download=false'
13986
                            },
13987
                            ]
13988
                        }
13989
                        ]
13990

    
13991
                    }
13992
                    ]
13993

    
13994
                }
13995
                ]
13996

    
13997
            }
13998
            ]
13999

    
14000
        });
14001
        me.callParent(arguments);
14002
    }
14003
});
14004

    
14005
Ext.define('MinovaUtil.MinovaES.Column.MinovaPictureColumn', {
14006
    extend: 'Ext.grid.column.Column',
14007
    alias: ['widget.minovapicturecolumn'],
14008
    alternateClassName: 'Ext.grid.MinovaPictureColumn',
14009
    //undefinedText: '&#160;',
14010
    defaultRenderer: function (value) {
14011
        return '<img alt="" class="icon-imagecolumn" src = "/Devt/GetFileData?FileName=' + value + '&download=false"  id="">'
14012
    }
14013
});
14014

    
14015
Ext.define('MinovaUtil.MinovaES.MinovaFixValue', {
14016
    extend: 'Ext.form.field.ComboBox',
14017
    alias: ['widget.MinovaFixValue', 'widget.minovafixvalue'],
14018
    fixedValue: undefined,
14019
    anchor: '50%',
14020
    queryMode: 'local',
14021
    forceSelection: true, // cek data
14022
    getValue: function () {
14023
        var value = this.value;
14024

    
14025
        return value;
14026
    },
14027
    getSubmitValue: function () {
14028
        var value = this.value;
14029

    
14030
        return value;
14031
    },
14032
    initComponent: function () {
14033
        var me = this;
14034
        var storeData = [];
14035
        //var str= "y=yes|| n=no";
14036
        var str = me.fixedValue;
14037
        var hasil = str.split('||');
14038
        hasil.forEach(function (h) {
14039
            store_ = h.split('=')
14040
            storeData.push({
14041
                code: store_[0],
14042
                desc: store_[1],
14043

    
14044
            });
14045
        });
14046
        Ext.applyIf(me, {
14047

    
14048
            store: Ext.create('Ext.data.Store', {
14049
                storeId: 'store' + name,
14050
                autoLoad: true,
14051
                data: storeData
14052

    
14053
            }),
14054
        });
14055
        me.callParent(arguments);
14056
    }
14057
});
14058

    
14059
Ext.define('MinovaUtil.MinovaES.MinovaDecimal', {
14060
    extend: 'Ext.form.field.Text',
14061
    alias: ['widget.MinovaDecimal', 'widget.minovadecimal'],
14062
    fixedValue: undefined,
14063
    anchor: '50%',
14064
    getValue: function () {
14065
        var value = this.value;
14066

    
14067
        return value.replace(',', '.');
14068
    },
14069
    getSubmitValue: function () {
14070
        var value = this.value;
14071
        return value.replace(',', '.');
14072
    },
14073
    initComponent: function () {
14074
        var me = this;
14075
        Ext.applyIf(me, {});
14076
        me.callParent(arguments);
14077
    }
14078
});
14079

    
14080
Ext.define('MinovaUtil.com.xtype.MinovaWorflowEditor', {
14081
    extend: 'Ext.panel.Panel',
14082
    alias: ['widget.minovawfeditor', 'widget.minovafloweditor'],
14083
    title: undefined,
14084
    initComponent: function () {
14085
        // this.layout = 'fit';
14086
        this.readOnly = this.readOnly ? this.readOnly : false;
14087
        this.autoScroll = true;
14088
        this.height = 480;
14089
		var  mxBasePath = '/Scripts/mxgraph';
14090
        this.title = this.title ? this.title : 'Workflow editor';
14091
        this.html = '<div id="minovaGraphContainer" title="' + this.title
14092
			 + '" style="background:url(\'' + mxBasePath
14093
			 + '/editors/images/grid.gif\')"></div>';
14094
        this.tbar = [{
14095
            xtype: 'button',
14096
            hidden: true,
14097
            text: 'add Task',
14098
            handler: this.addTask
14099

    
14100
        }, {
14101
            xtype: 'button',
14102
            text: 'Remove',
14103
            hidden: true,
14104
            handler: this.removeCells
14105
        },
14106
			'->', {
14107
			    xtype: 'cycle',
14108
			    text: 'layout',
14109
			    menu: {
14110
			        // id : 'view-type-menu',
14111
			        items: [{
14112
			            text: 'mxCircleLayout'
14113
			        }, {
14114
			            text: 'mxCompactTreeLayout'
14115
			        }, {
14116
			            text: 'mxCompositeLayout'
14117
			        }, {
14118
			            text: 'mxEdgeLabelLayout'
14119
			        }, {
14120
			            text: 'mxFastOrganicLayout'
14121
			        }, {
14122
			            text: 'mxGraphLayout'
14123
			        }, {
14124
			            text: 'mxHierarchicalLayout'
14125
			        }
14126
						// , {
14127
						// text : 'mxParallelEdgeLayout'
14128
						// }
14129
						// , {
14130
						// text : 'mxPartitionLayout'
14131
						// },
14132
						// {
14133
						// text : 'mxStackLayout'
14134
						// }
14135
			        ]
14136
			    },
14137
			    changeHandler: function (cycleBtn, activeItem) {
14138
			        // Ext.Msg.alert('Change View', activeItem.text);
14139
			        try {
14140
			            switch (activeItem.text) {
14141
			                case 'mxCircleLayout':
14142
			                    var layout = new mxCircleLayout(graph);
14143
			                    layout.execute(graph.getDefaultParent());
14144
			                    break;
14145
			                case 'mxCompactTreeLayout':
14146
			                    var layout = new mxCompactTreeLayout(graph,
14147
                                        false);
14148
			                    layout.execute(graph.getDefaultParent());
14149
			                    break;
14150
			                case 'mxCompositeLayout':
14151
			                    var first = new mxFastOrganicLayout(graph);
14152
			                    var second = new mxParallelEdgeLayout(graph);
14153
			                    var layout = new mxCompositeLayout(graph, [
14154
                                            first, second], first);
14155
			                    layout.execute(graph.getDefaultParent());
14156
			                    break;
14157
			                case 'mxEdgeLabelLayout':
14158
			                    var layout = new mxEdgeLabelLayout(graph);
14159
			                    layout.execute(graph.getDefaultParent());
14160
			                    break;
14161
			                case 'mxFastOrganicLayout':
14162
			                    var layout = new mxCircleLayout(graph);
14163
			                    layout.execute(graph.getDefaultParent());
14164
			                    break;
14165
			                case 'mxGraphLayout':
14166
			                    var layout = new mxFastOrganicLayout(graph);
14167
			                    layout.execute(graph.getDefaultParent());
14168
			                    break;
14169
			                case 'mxParallelEdgeLayout':
14170
			                    var layout = new mxParallelEdgeLayout(graph);
14171
			                    layout.execute(graph.getDefaultParent());
14172
			                    break;
14173
			                case 'mxPartitionLayout':
14174
			                    var layout = new mxPartitionLayout(graph,
14175
                                        true, 10, 20);
14176
			                    layout.execute(graph.getDefaultParent());
14177
			                    break;
14178
			                case 'mxStackLayout':
14179
			                    var layout = new mxStackLayout(graph, false);
14180
			                    layout.execute(graph.getDefaultParent());
14181
			                    break;
14182
			                case 'mxHierarchicalLayout':
14183
			                    var layout = new mxHierarchicalLayout(graph);
14184
			                    layout.parallelEdgeSpacing = 100;
14185
			                    layout.moveParent = true;
14186
			                    layout.parentBorder = 100;
14187
			                    layout.intraCellSpacing = 100;
14188
			                    layout.interRankCellSpacing = 100;
14189
			                    layout.interHierarchySpacing = 0;
14190
			                    layout.orientation = mxConstants.DIRECTION_NORTH;
14191
			                    //layout.traverseAncestors = false;
14192
			                    layout.execute(parent);
14193
			                    break;
14194

    
14195
			            }
14196
			        } catch (e) {}
14197
			    }
14198
			}, {
14199
			    xtype: 'tbseparator'
14200
			}, {
14201
			    text: 'In',
14202
			    name: 'zoomin',
14203
			    handler: function () {
14204
			        graph.zoomIn();
14205
			        graph.fit();
14206
			    }
14207
			}, {
14208
			    text: 'Out',
14209
			    name: 'zoomout',
14210
			    handler: function () {
14211
			        graph.zoomOut();
14212
			        graph.fit();
14213
			    }
14214
			}
14215
			// , {
14216
			// text : 'Fit',
14217
			// name : 'zoomfit',
14218
			// handler : function() {
14219
			// graph.fit();
14220
			// }
14221
			// }
14222
		, {
14223
		    xtype: 'tbseparator'
14224
		}, {
14225
		    xtype: 'button',
14226
		    text: 'print',
14227
		    name: 'print',
14228
		    handler: this.printPreview
14229
		}
14230
        ]
14231

    
14232
        this.autoScroll = true;
14233
        this.listeners = {
14234
            afterrender: this.onAfterRender,
14235
            resize: this.onResize
14236
        }
14237

    
14238
        this.callParent(arguments);
14239
    },
14240
    printPreview: function () {
14241
        var preview = new mxPrintPreview(graph);
14242
        preview.print();
14243
    },
14244
    onAfterRender: function (_this) {
14245
        this.main(document.getElementById('minovaGraphContainer'));
14246
    },
14247
    removeCells: function () {
14248
        graph.removeCells();
14249
    },
14250
    onResize: function () {
14251
        try {
14252
            graph.sizeDidChange();
14253
        } catch (e) {}
14254
    },
14255
    addTask: function () {
14256
        graph.insertVertex(graph.getDefaultParent(), null, 'Task-' + Ext.id(),
14257
			0, 0, 80, 30);
14258
    },
14259
    main: function (container) {
14260
        // Checks if the browser is supported
14261
        if (!mxClient.isBrowserSupported()) {
14262
            // Displays an error message if the browser is not supported.
14263
            // mxUtils.error('Browser is not supported!', 200, false);
14264
            alert('Browser is not supported!');
14265
        } else {
14266
            // // Creates the graph inside the given container
14267
            // graph = new mxGraph(container);
14268
            // var keyHandler = new mxKeyHandler(graph);
14269
            // // keyHandler.bindKey(46, function(evt) {
14270
            // // if (graph.isEnabled()) {
14271
            // // graph.removeCells();
14272
            // // }
14273
            // // });
14274
            // wfEditor = new mxEditor();
14275
            //
14276
            // // Enables rubberband selection
14277
            //
14278
            // new mxRubberband(graph);
14279
            // graph.setPanning(true);
14280
            // graph.setTooltips(true);
14281
            //
14282
            // // graph.setConnectable(true);
14283
            // // graph.setDropEnabled(true);
14284
            // // graph.connectionHandler.setCreateTarget(true);
14285
            //
14286
            // // Gets the default parent for inserting new cells. This
14287
            // // is normally the first child of the root (ie. layer 0).
14288
            // var parent = graph.getDefaultParent();
14289

    
14290
            // Enables crisp rendering in SVG
14291
            // mxShape.prototype.crisp = true;
14292

    
14293
            // Enables guides
14294
            // mxGraphHandler.prototype.guidesEnabled = true;
14295

    
14296
            // Alt disables guides
14297
            // mxGuide.prototype.isEnabledForEvent = function(evt) {
14298
            // return !mxEvent.isAltDown(evt);
14299
            // };
14300

    
14301
            // Enables snapping waypoints to terminals
14302
            // mxEdgeHandler.prototype.snapToTerminals = true;
14303

    
14304
            // Enables orthogonal connect preview in IE
14305
            // mxConnectionHandler.prototype.movePreviewAway = true;
14306

    
14307
            // Creates the graph inside the given container
14308
            graph = new mxGraph(container);
14309
            // graph.disconnectOnMove = false;
14310
            // graph.foldingEnabled = false;
14311
            // graph.cellsResizable = false;
14312
            // graph.extendParents = false;
14313
            // graph.setConnectable(true);
14314
            graph.setAllowDanglingEdges(false);
14315

    
14316
            // Implements perimeter-less connection points as fixed points
14317
            // (computed before the edge style).
14318
            // graph.view.updateFixedTerminalPoint = function(edge, terminal,
14319
            // source, constraint) {
14320
            // mxGraphView.prototype.updateFixedTerminalPoint.apply(this,
14321
            // arguments);
14322
            //
14323
            // var pts = edge.absolutePoints;
14324
            // var pt = pts[(source) ? 0 : pts.length - 1];
14325
            //
14326
            // if (terminal != null && pt == null
14327
            // && this.getPerimeterFunction(terminal) == null) {
14328
            // edge.setAbsoluteTerminalPoint(new mxPoint(this
14329
            // .getRoutingCenterX(terminal), this
14330
            // .getRoutingCenterY(terminal)),
14331
            // source)
14332
            // }
14333
            // };
14334

    
14335
            // Changes the default edge style
14336
            graph.getStylesheet().getDefaultEdgeStyle()['edgeStyle'] = 'orthogonalEdgeStyle';
14337
            // delete graph.getStylesheet().getDefaultEdgeStyle()['endArrow'];
14338

    
14339
            // Implements the connect preview
14340
            graph.connectionHandler.createEdgeState = function (me) {
14341
                var edge = graph.createEdge(null, null, null, null, null);
14342

    
14343
                return new mxCellState(this.graph.view, edge, this.graph
14344
					.getCellStyle(edge));
14345
            };
14346

    
14347
            // Uncomment the following if you want the container
14348
            // to fit the size of the graph
14349
            // graph.setResizeContainer(true);
14350

    
14351
            // Enables rubberband selection
14352
            new mxRubberband(graph);
14353

    
14354
            // Disables basic selection and cell handling
14355
            graph.setEnabled(false);
14356

    
14357
            // Gets the default parent for inserting new cells. This
14358
            // is normally the first child of the root (ie. layer 0).
14359
            var parent = graph.getDefaultParent();
14360

    
14361
            // Enables HTML labels as wrapping is only available for those
14362
            graph.htmlLabels = true;
14363

    
14364
            // Disables in-place editing for edges
14365
            // graph.isCellEditable = function(cell) {
14366
            // return !this.model.isEdge(cell);
14367
            // };
14368

    
14369
            // Changes the default vertex style in-place
14370
            var style = graph.getStylesheet().getDefaultVertexStyle();
14371
            style[mxConstants.STYLE_PERIMETER] = mxPerimeter.RectanglePerimeter;
14372
            style[mxConstants.STYLE_GRADIENTCOLOR] = 'white';
14373
            style[mxConstants.STYLE_PERIMETER_SPACING] = 1; // 6;
14374
            style[mxConstants.STYLE_ROUNDED] = true;
14375
            style[mxConstants.STYLE_SHADOW] = true;
14376

    
14377
            style = graph.getStylesheet().getDefaultEdgeStyle();
14378
            style[mxConstants.STYLE_ROUNDED] = true;
14379
            style[mxConstants.STYLE_EDGE] = mxEdgeStyle.SegmentConnector;
14380

    
14381
            var style2 = new Object();
14382
            style2[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_RHOMBUS;
14383
            style2[mxConstants.STYLE_PERIMETER] = mxPerimeter.RhombusPerimeter;
14384
            style2[mxConstants.STYLE_GRADIENTCOLOR] = 'white';
14385
            style2[mxConstants.STYLE_PERIMETER_SPACING] = 1;
14386
            style2[mxConstants.STYLE_ROUNDED] = true;
14387
            style2[mxConstants.STYLE_SHADOW] = true;
14388
            style2[mxConstants.STYLE_STROKECOLOR] = '#B3BFD7';
14389
            style2[mxConstants.STYLE_FILLCOLOR] = '#C4DAFF';
14390
            style2[mxConstants.STYLE_ALIGN] = 'center';
14391
            style2[mxConstants.STYLE_VERTICALALIGN] = 'middle';
14392
            graph.getStylesheet().putCellStyle('RHOMBUS', style2);
14393

    
14394
            style2 = new Object();
14395
            style2[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_ELLIPSE;
14396
            style2[mxConstants.STYLE_PERIMETER] = mxPerimeter.EllipsePerimeter;
14397
            style2[mxConstants.STYLE_GRADIENTCOLOR] = 'white';
14398
            style2[mxConstants.STYLE_PERIMETER_SPACING] = 1;
14399
            style2[mxConstants.STYLE_ROUNDED] = true;
14400
            style2[mxConstants.STYLE_SHADOW] = true;
14401
            style2[mxConstants.STYLE_STROKECOLOR] = '#B3BFD7';
14402
            style2[mxConstants.STYLE_FILLCOLOR] = '#C4DAFF';
14403
            style2[mxConstants.STYLE_ALIGN] = 'center';
14404
            style2[mxConstants.STYLE_VERTICALALIGN] = 'middle';
14405
            graph.getStylesheet().putCellStyle('ELLIPSE', style2);
14406

    
14407
            style2 = new Object();
14408
            style2[mxConstants.STYLE_SHAPE] = 'label';
14409
            style2[mxConstants.STYLE_VERTICAL_ALIGN] = 'bottom';
14410
            style2[mxConstants.STYLE_INDICATOR_SHAPE] = 'ellipse';
14411
            style2[mxConstants.STYLE_INDICATOR_WIDTH] = 34;
14412
            style2[mxConstants.STYLE_INDICATOR_HEIGHT] = 34;
14413
            style2[mxConstants.STYLE_IMAGE_VERTICAL_ALIGN] = 'top'; // indicator v-alignment
14414
            style2[mxConstants.STYLE_IMAGE_ALIGN] = 'center';
14415
            graph.getStylesheet().putCellStyle('LABEL', style2);
14416

    
14417
            style2 = new Object();
14418
            style2[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_RECTANGLE;
14419
            style2[mxConstants.STYLE_PERIMETER] = mxPerimeter.RectanglePerimeter;
14420
            style2[mxConstants.STYLE_GRADIENTCOLOR] = 'white';
14421
            style2[mxConstants.STYLE_PERIMETER_SPACING] = 1;
14422
            style2[mxConstants.STYLE_ROUNDED] = false;
14423
            style2[mxConstants.STYLE_SHADOW] = true;
14424
            style2[mxConstants.STYLE_STROKECOLOR] = '#B3BFD7';
14425
            style2[mxConstants.STYLE_FILLCOLOR] = '#C4DAFF';
14426
            graph.getStylesheet().putCellStyle('RECTANGLE', style2);
14427
            // Adds cells to the model in a single step
14428
            graph.getModel().beginUpdate();
14429
            try {
14430
                // var v1 = graph.insertVertex(parent, null, '1', 20, 0, 150,
14431
                // 80);
14432
                // var v2 = graph.insertVertex(parent, null, '2', 20, 50, 150,
14433
                // 80);
14434
                // var v3 = graph
14435
                // .insertVertex(parent, null, '3', 20, 100, 150, 80);
14436
                // var v4 = graph
14437
                // .insertVertex(parent, null, '4', 120, 50, 150, 80);
14438
                // var v5 = graph.insertVertex(parent, null, '5', 120, 100, 150,
14439
                // 80);
14440
                //
14441
                // var e1 = graph.insertEdge(parent, null, '', v1, v2);
14442
                // var e2 = graph.insertEdge(parent, null, '', v2, v3);
14443
                // var e3 = graph.insertEdge(parent, null, '', v2, v4);
14444
                // var e4 = graph.insertEdge(parent, null, '', v4, v5);
14445
                // var e5 = graph.insertEdge(parent, null, '', v3, v5);
14446
            }
14447
            finally {
14448
                // Updates the display
14449
                graph.getModel().endUpdate();
14450
            }
14451

    
14452
        }
14453
    }
14454
});
14455

    
14456
Ext.define('MinovaUtil.MinovaES.MinovaMonthPicker', {
14457
    extend: 'Ext.form.field.Text',
14458
    alias: ['widget.minovamonthpicker', 'widget.minovamonthpicker'],
14459
    tableName: undefined,
14460
    param: undefined,
14461
    formtarget_: this.formtarget,
14462
    Sequence: this.Sequence,
14463
    anchor: '50%',
14464
    pagesize: undefined,
14465
    triggerCls: 'x-form-date-trigger',
14466
    getValue: function () {
14467
        var Sequence = this.Sequence;
14468
        var me = this;
14469
        var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14470
        var hasil = "";
14471
        if (_e != undefined) {
14472
            if (_e.value[0] >= 0) {
14473
                if (_e.value[0].toString() != '') {
14474
                    var _m = (_e.value[0] + 1).toString();
14475
                    if (_m.length == 1) {
14476
                        _m = '0' + _m;
14477
                    }
14478
                    hasil = _e.value[1].toString() + _m;
14479
                }
14480
            }
14481
        }
14482
        if (hasil == "") {
14483
            me.value = null;
14484
            me.submitValue = null;
14485
        } else {
14486
            me.submitValue = hasil;
14487
        }
14488
        return hasil;
14489
    },
14490
    clearValue: function () {
14491
        var Sequence = this.Sequence;
14492
        var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14493
        _e.value[0] = '';
14494
        _e.value[1] = '';
14495
        return this.setValue('');
14496
    },
14497
    getRawValue: function () {
14498
        var Sequence = this.Sequence;
14499
        var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14500
        var hasil = null;
14501
        if (_e != undefined) {
14502
            var _m = (_e.value[0] + 1).toString();
14503
            if (_m.length == 1) {
14504
                _m = '0' + _m;
14505
            }
14506
            hasil = _e.value[1].toString() + _m;
14507
        }
14508
        return hasil;
14509
    },
14510
    initComponent: function () {
14511
        var target = this.formtarget;
14512
        this.callParent();
14513
    },
14514
    onTriggerClick: function () {
14515
        var Sequence = this.Sequence;
14516
        var count_lookup = Ext.ComponentQuery.query('[name=' + Sequence + 'monthLookup]').length;
14517
        if (count_lookup == 1) {
14518
            Ext.ComponentQuery.query('[name=' + Sequence + 'monthLookup]')[0].show();
14519
        } else {
14520
            var target_ = this.formtarget;
14521
            var fieldtarget = this.name;
14522
            Ext.create('Ext.window.Window', {
14523
                title: 'Select Period',
14524
                name: Sequence + 'monthLookup',
14525
                layout: 'fit',
14526
                bodyPadding: 0,
14527
                border: false,
14528
                items: [{
14529
                    xtype: 'monthpicker',
14530
                    name: Sequence + 'monthselect',
14531
                    listeners: {
14532
                        afterrender: function () {
14533
                            var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14534

    
14535
                            _e.setValue(new Date());
14536
                        }
14537
                    },
14538
                    onOkClick: function () {
14539
                        var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14540
                        if (_e.value[0] == null || _e.value[1] == null) {
14541
                            alert('Pilih Tanggal!');
14542
                            return;
14543
                        }
14544

    
14545
                        var _m = (_e.value[0] + 1).toString();
14546
                        if (_m.length == 1) {
14547
                            _m = '0' + _m;
14548
                        }
14549
                        var _period = _m + ' - ' + _e.value[1].toString();
14550

    
14551
                        var _f = Ext.ComponentQuery.query('[name=' + fieldtarget + ']')[0];
14552
                        _f.setValue(_period);
14553

    
14554
                        Ext.ComponentQuery.query('[name=' + Sequence + 'monthLookup]')[0].hide();
14555
                    },
14556
                    onCancelClick: function () {
14557
                        Ext.ComponentQuery.query('[name=' + Sequence + 'monthLookup]')[0].hide();
14558
                    }
14559
                }
14560
                ]
14561
            }).show();
14562
        }
14563
    }
14564
});
14565

    
14566
Ext.define('MinovaUtil.MinovaES.Column.MinovaTimeColumn', {
14567
    extend: 'Ext.grid.column.Column',
14568
    alias: ['widget.minovatimecolumn'],
14569
    alternateClassName: 'Ext.grid.MinovaTimeColumn',
14570
    undefinedText: '&#160;',
14571
    defaultRenderer: function (value) {
14572
        if (value === "") {
14573
            return "";
14574
        }
14575
        return hasil;
14576
    }
14577
});
14578

    
14579
Ext.define('MinovaUtil.MinovaES.Column.MinovaCurrencyColumn', {
14580
    extend: 'Ext.grid.column.Column',
14581
    alias: ['widget.minovacurrancycolumn'],
14582
    undefinedText: '&#160;',
14583
    defaultRenderer: function (value) {
14584
        if (value === "" || value === undefined || value === null) {
14585
            return this.undefinedText;
14586
        }
14587

    
14588
        Ext.util.Format.thousandSeparator = ",";
14589
        Ext.util.Format.decimalSeparator = ".";
14590
        value = value.toString().replace(',', '.');
14591
        return Ext.util.Format.number(value, '0,000.00');
14592
    }
14593
});
14594

    
14595
Ext.define('MinovaUtil.MinovaES.Field.MinovaCurrencyField', {
14596
    extend: 'Ext.form.field.Text',
14597
    alias: ['widget.MinovaCurrencyField', 'widget.minovacurrencyfield'],
14598
    undefinedText: '&#160;',
14599
    defaultRenderer: function (value) {
14600
        if (value === "" || value === undefined || value === null) {
14601
            return this.undefinedText;
14602
        }
14603

    
14604
        Ext.util.Format.thousandSeparator = ",";
14605
        Ext.util.Format.decimalSeparator = ".";
14606
        value = value.toString().replace(',', '.');
14607
        return Ext.util.Format.number(value, '0000.00');
14608
    }
14609
});
14610

    
14611
Ext.define('MinovaUtil.MinovaES.MinovaGridMD', {
14612
    extend: 'Ext.grid.Panel',
14613
    requires: ['Ext.grid.RowNumberer'],
14614
    alias: 'widget.minovagridmd',
14615
    //alias: ['widget.minovagrid1', 'widget.minovagrid'],
14616
    //alias: ['widget.minovagrid1', 'widget.minovagrid'],
14617
    alternateClassName: 'Ext.grid.MinovaGrid',
14618
    //controller:'orm-manage2-controller',
14619
    tableName: undefined,
14620
    isLookup: undefined,
14621
    param: undefined,
14622
    pagesize: undefined,
14623
    storename: undefined,
14624
    layoutType: undefined,
14625
    enableLocking: true,
14626
    autoLoad: undefined,
14627
    multiSelect: undefined,
14628
    getTableName: function () {
14629
        return this.tableName;
14630
    },
14631

    
14632
    initComponent: function () {
14633
        var me = this;
14634
        var cols_ = [];
14635
        var fieldeditor = {};
14636
        var hasil = null;
14637
        var autoLoad = true;
14638
        var LangID = localStorage.LangId;
14639
        var fielGrid = 'rec.GridView == 1';
14640
        var locking = true;
14641
        var checkSelection = '';
14642
        var widthLock = 250;
14643
        if (me.multiSelect) {
14644
            locking = false;
14645
            checkSelection = 'checkboxmodel';
14646
            widthLock = 40;
14647
        }
14648
        //var _url = 'GetAllField';
14649
        if (me.autoLoad == false) {
14650
            autoLoad = false;
14651
        }
14652
        parameter = null;
14653
        if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
14654
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'";
14655
            fielGrid = 'rec.LookupGrid == 1';
14656
            locking = false;
14657

    
14658
        } else {
14659
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
14660
            //autoLoad = false;
14661
            //_url = 'GetAllFieldGridLookUp';
14662
        };
14663

    
14664
        //Ext.Ajax.request({
14665
        //	async : false,
14666
        //	method : 'POST',
14667
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
14668
        //	success : function (response) {
14669
        //		var results = Ext.decode(response.responseText);
14670
        //		hasil = results.data;
14671
        //	}
14672
        //});
14673
        //hamid03102016
14674

    
14675
        Ext.Ajax.request({
14676
            async: false,
14677
            method: 'POST',
14678
            url: '/UserControl/GetStore',
14679
            params: {
14680
                tableName: 'PDSBS0007',
14681
                param: parameter
14682
            },
14683
            success: function (response) {
14684
                var results = Ext.decode(response.responseText);
14685
                hasil = results.data;
14686
            }
14687
        });
14688
        //end
14689

    
14690
        if (hasil.length > 0) {
14691

    
14692
            Ext.each(hasil, function (rec) {
14693
                var null_ = null;
14694
                if (rec.IsPrimaryKey == true) {
14695
                    null_ = false;
14696
                }
14697
                if (rec.IsRequired == true) {
14698
                    null_ = false;
14699
                } else {
14700
                    null_ = true;
14701
                }
14702

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

    
14871
                                } else {
14872
                                    cols_.push({
14873
                                        text: rec.HeaderTitle,
14874
                                        dataIndex: rec.FieldName,
14875
                                        filter: {
14876
                                            itemDefaults: {
14877
                                                emptyText: 'Search for...'
14878
                                            }
14879
                                        }
14880
                                    });
14881
                                }
14882
                                break
14883
                        }
14884
                    } else {
14885
                        cols_.push({
14886
                            text: rec.HeaderTitle,
14887
                            dataIndex: rec.FieldName,
14888
                            hidden: true,
14889
                            filter: {
14890
                                itemDefaults: {
14891
                                    emptyText: 'Search for...'
14892
                                }
14893
                            }
14894
                        });
14895
                    }
14896

    
14897
                } else {
14898
                    if (rec.GridView == 1) {
14899
                        switch (rec.FormatRef) {
14900
                            case "file":
14901
                                cols_.push({
14902
                                    xtype: 'minovapicturecolumn',
14903
                                    text: rec.HeaderTitle,
14904
                                    dataIndex: rec.FieldName,
14905
                                    width: 100,
14906
                                    //filter: {
14907
                                    //    type: '',
14908
                                    //    itemDefaults: {
14909
                                    //        emptyText: 'Search for...'
14910
                                    //    }
14911
                                    //}
14912
                                });
14913
                                break
14914
                            case "date":
14915
                                cols_.push({
14916
                                    xtype: 'minovadatecolumn',
14917
                                    text: rec.HeaderTitle,
14918
                                    dataIndex: rec.FieldName,
14919
                                    width: 100,
14920
                                    filter: {
14921
                                        type: 'date',
14922
                                        itemDefaults: {
14923
                                            emptyText: 'Search for...'
14924
                                        }
14925
                                    }
14926
                                });
14927
                                break
14928
                            case "amountencrypt":
14929
                                cols_.push({
14930
                                    xtype: 'minovaamountcolumn',
14931
                                    align: 'right',
14932
                                    text: rec.HeaderTitle,
14933
                                    dataIndex: rec.FieldName,
14934
                                    width: 100,
14935
                                    filter: {
14936
                                        type: 'string',
14937
                                        itemDefaults: {
14938
                                            emptyText: 'Search for...'
14939
                                        }
14940
                                    }
14941
                                });
14942
                                break
14943
                            case "amount":
14944
                                cols_.push({
14945
                                    text: rec.HeaderTitle,
14946
                                    dataIndex: rec.FieldName,
14947
                                    width: 100,
14948
                                    filter: {
14949
                                        type: 'number',
14950
                                        itemDefaults: {
14951
                                            emptyText: 'Search for...'
14952
                                        }
14953
                                    }
14954
                                });
14955
                                break
14956
                            case "datetime":
14957
                                cols_.push({
14958
                                    xtype: 'minovadatetimecolumn',
14959
                                    text: rec.HeaderTitle,
14960
                                    dataIndex: rec.FieldName,
14961
                                    width: 140,
14962
                                    filter: {
14963
                                        type: 'string',
14964
                                        itemDefaults: {
14965
                                            emptyText: 'Search for...'
14966
                                        }
14967
                                    }
14968
                                });
14969
                                break
14970
                            default:
14971
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
14972
                                    cols_.push({
14973
                                        text: rec.HeaderTitle,
14974
                                        dataIndex: rec.FieldName,
14975
                                        width: 100,
14976
                                        filter: {
14977
                                            type: 'string',
14978
                                            itemDefaults: {
14979
                                                emptyText: 'Search for...'
14980
                                            }
14981
                                        }
14982
                                    });
14983
                                } else if (rec.SearchType == '2') {
14984
                                    cols_.push({
14985
                                        xtype: 'minovalookupcolumn',
14986
                                        text: rec.HeaderTitle,
14987
                                        tableName: rec.TableRef,
14988
                                        dataIndex: rec.FieldName,
14989
                                        filter: {
14990
                                            itemDefaults: {
14991
                                                emptyText: 'Search for...'
14992
                                            }
14993
                                        }
14994
                                    });
14995
                                } else if (rec.TableRef != "" && rec.SearchType != '2') {
14996
                                    if (rec.TableRef != null) {
14997
                                        var valueField = null;
14998
                                        var displayValue = null;
14999
                                        Ext.Ajax.request({
15000
                                            async: false,
15001
                                            method: 'POST',
15002
                                            url: '/UserControl/GetStore',
15003
                                            params: {
15004
                                                tableName: 'SDATATABLEFIELD',
15005
                                                param: 'TableName[equal]' + rec.TableRef
15006
                                            },
15007
                                            success: function (response) {
15008
                                                var results = Ext.decode(response.responseText);
15009
                                                data_ = results.data;
15010
                                                //if (data_ != undefined) {
15011
                                                if (data_.length > 0) {
15012
                                                    valueField_ = $.grep(data_, function (r) {
15013
                                                        return r.ValueField == '1'
15014
                                                    });
15015
                                                    valueField = valueField_[0].FieldName
15016
                                                    displayValue_ = $.grep(data_, function (r) {
15017
                                                        return r.DisplayValue == '1'
15018
                                                    });
15019
                                                    displayValue = displayValue_[0].FieldName
15020
                                                } else {
15021
                                                    MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
15022
                                                }
15023
                                            }
15024
                                        });
15025
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
15026
                                        var count_ = 0;
15027
                                        if (store_) {
15028
                                            count_ = store_.count();
15029
                                        }
15030
                                        if (count_ == 0) {
15031
                                            var paramFilter = rec.ParamCombo;
15032
                                            if (rec.TableRef.toLowerCase() == 'phrom0001' && rec.ParamCombo.length == 1) {
15033
                                                paramFilter = 'ObjectClass[=]' + paramFilter;
15034
                                            }
15035
											var storeRef = Ext.create('Ext.data.Store', {
15036
                                                storeId: 'store_' + rec.FieldName,
15037
                                                autoLoad: false,
15038
                                                proxy: {
15039
                                                    method: 'POST',
15040
                                                    type: 'ajax',
15041
                                                    url: '/UserControl/GetStore',
15042
                                                    extraParams: {
15043
                                                        tableName: rec.TableRef,
15044
                                                        param: rec.ParamCombo
15045
                                                    },
15046
                                                    reader: {
15047
                                                        type: 'json',
15048
                                                        root: 'data',
15049
                                                        totalProperty: 'data[0].TotalCount'
15050
                                                    }
15051
                                                }
15052
                                            });
15053
                                            storeRef.load();
15054
                                            /*
15055
											Ext.create('Ext.data.Store', {
15056
                                                storeId: 'store_' + rec.FieldName,
15057
                                                autoLoad: false,
15058
                                                proxy: {
15059
                                                    method: 'POST',
15060
                                                    type: 'ajax',
15061
                                                    url: '/UserControl/GetStore',
15062
                                                    extraParams: {
15063
                                                        tableName: rec.TableRef,
15064
                                                        param: paramFilter
15065
                                                    },
15066
                                                    reader: {
15067
                                                        type: 'json',
15068
                                                        root: 'data',
15069
                                                        totalProperty: 'data[0].TotalCount'
15070
                                                    }
15071
                                                }
15072
                                            })
15073
											*/
15074
                                        }
15075
                                        cols_.push({
15076
                                            xtype: 'minovacombocolumn',
15077
                                            text: rec.HeaderTitle,
15078
                                            dataIndex: rec.FieldName,
15079
                                            valueField: valueField,
15080
                                            displayField: displayValue,
15081
                                            store: 'store_' + rec.FieldName,
15082
                                            filter: {
15083
                                                type: 'list',
15084
                                                itemDefaults: {
15085
                                                    emptyText: 'Search for...'
15086
                                                }
15087
                                            }
15088
                                        });
15089
                                    }
15090

    
15091
                                } else if (rec.FixedValue != "") {
15092
                                    cols_.push({
15093
                                        xtype: 'minovacombocolumnfixvalue',
15094
                                        text: rec.HeaderTitle,
15095
                                        dataIndex: rec.FieldName,
15096
                                        fixedValue: rec.FixedValue,
15097
                                        filter: {
15098
                                            type: 'list',
15099
                                            itemDefaults: {
15100
                                                emptyText: 'Search for...'
15101
                                            }
15102
                                        }
15103
                                    });
15104
                                } else {
15105
                                    cols_.push({
15106
                                        text: rec.HeaderTitle,
15107
                                        dataIndex: rec.FieldName,
15108
                                        filter: {
15109
                                            itemDefaults: {
15110
                                                emptyText: 'Search for...'
15111
                                            }
15112
                                        }
15113
                                    });
15114
                                }
15115
                                break
15116
                        }
15117
                    } else {
15118
                        cols_.push({
15119
                            text: rec.HeaderTitle,
15120
                            dataIndex: rec.FieldName,
15121
                            hidden: true,
15122
                            filter: {
15123
                                itemDefaults: {
15124
                                    emptyText: 'Search for...'
15125
                                }
15126
                            }
15127
                        });
15128
                    }
15129

    
15130
                }
15131
            });
15132
        };
15133
        var param_ = me.param;
15134
        if (param_ == undefined) {
15135
            param_ = ''
15136
        }
15137
        var jsStoreGrid = new Ext.data.Store({
15138
            storeId: me.storename,
15139
            autoLoad: autoLoad,
15140
            pageSize: me.pagesize,
15141
            proxy: {
15142
                method: 'POST',
15143
                type: 'ajax',
15144
                url: '/UserControl/GetStorePaging',
15145
                extraParams: {
15146
                    tableName: me.tableName,
15147
                    param: param_,
15148
                    //menuId: MinovaUtil.GetMenuID()
15149
                },
15150
                reader: {
15151
                    type: 'json',
15152
                    root: 'data',
15153
                    totalProperty: 'totalRecords'
15154
                }
15155
            },
15156
        });
15157
        Ext.applyIf(me, {
15158
            autoScroll: true,
15159
            enableLocking: locking,
15160
            lockedGridConfig: {
15161
                header: false,
15162
                collapsible: true,
15163
                width: widthLock,
15164
                forceFit: locking,
15165
                listeners: {
15166
                    render: function (grid) {
15167
                        var pagingToolbar = grid.child('pagingtoolbar');
15168
                        if (pagingToolbar) {
15169
                            grid.remove(pagingToolbar, true);
15170
                        }
15171
                    }
15172
                }
15173
            },
15174
            listeners: {
15175
                viewready: function () {
15176
                    if (autoLoad == true) {
15177
                        this.getStore().loadPage(1);
15178
                    }
15179

    
15180
                },
15181
                beforeedit: function () {
15182
                    return false;
15183
                }
15184
            },
15185
            lockedViewConfig: {
15186
                scroll: 'horizontal'
15187
            },
15188
            viewConfig: {
15189
                emptyText: 'No Data Display',
15190
                deferEmptyText: false,
15191
                //Add Nana For Autosize Column Mode Grid MD
15192
                listeners: {
15193
                    refresh: function (dataview) {
15194
                        Ext.each(dataview.panel.columns, function (column) {
15195
                            if (column.autoSizeColumn == false)
15196
                                column.autoSizeColumn = true;
15197
                            column.autoSize();
15198
                            console.log('GridMD');
15199
                        })
15200
                    },
15201
                    //afterrender: function (dataview) {
15202
                    //	console.log(dataview);
15203
                    //	dataview.getStore().reload();
15204
                    //}
15205
                    afterrender: function (dataview) {
15206
                     /*   Ext.defer(function () {
15207
                            dataview.store.reload();
15208
                        }, 2500, this);*/
15209
                    }
15210
                }
15211
            },
15212
            //for chekbox
15213
            selModel: {
15214
                //type: 'cellmodel'
15215
            },
15216
            selType: checkSelection,
15217
            columns: cols_,
15218
            store: jsStoreGrid,
15219
            plugins: [{
15220
                ptype: 'gridfilters'
15221
            }
15222
            ],
15223

    
15224
        });
15225
        me.callParent(arguments);
15226
    }
15227

    
15228
});
15229

    
15230
Ext.define('MinovaUtil.MinovaES.MinovaPMSEditAbleGrid', {
15231
    extend: 'Ext.form.Panel',
15232
    alias: ['widget.MinovaPMSEditAbleGrid', 'widget.Minovapmseditablegrid', 'widget.minovapmseditablegrid'],
15233
    requires: [
15234
		'Ext.grid.plugin.CellEditing',
15235
		'Ext.grid.RowNumberer',
15236
		'Ext.grid.Panel',
15237
		'Ext.grid.plugin.RowEditing',
15238
    ],
15239
    anchor: '100%',
15240
    tableName: undefined,
15241
    apprasalType: undefined,
15242
    empID: undefined,
15243
    hideButton: undefined,
15244
    multiSelect: undefined,
15245
    initComponent: function () {
15246
        var me = this;
15247
        var isLookup = me.isLookup;
15248
        var hide_ = false;
15249
        var widthLock = 250;
15250
        var checkSelection = '';
15251
        if (me.hideButton == true) {
15252
            hide_ = true;
15253
        }
15254
        if (me.multiSelect) {
15255
            locking = false;
15256
            checkSelection = 'checkboxmodel';
15257
            widthLock = 40;
15258
        }
15259
        var tableName = me.tableName;
15260
        var cols = [];
15261
        var fieldStore = [];
15262
        var _url = 'GetAllField';
15263
        var hasil = null;
15264
        var height = me.height;
15265
        var storeID = 'store' + me.tableName;
15266
        var gridName = 'grid' + me.name;
15267
        if (me.storeName) {
15268
            storeID = me.storeName;
15269
        }
15270
        var empID = me.empID;
15271
        var apprasalType = me.apprasalType;
15272
        var LangID = MinovaUtil.GetLangID();
15273
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'" + "," + empID + "," + apprasalType
15274
        Ext.Ajax.request({
15275
            async: false,
15276
            method: 'POST',
15277
            url: '/Performance/getFieldPMS',
15278
            params: {
15279
                tableName: 'PDSPMS001',
15280
                _param: parameter
15281
            },
15282
            success: function (response) {
15283
                var results = Ext.decode(response.responseText);
15284
                hasil = Ext.decode(results.data);
15285
            }
15286
        });
15287
        var addData = 'var data={';
15288
        if (hasil.length > 0) {
15289
            Ext.each(hasil, function (rec) {
15290
                fieldStore.push(rec.FieldName)
15291
                if (rec.FieldName != 'Sequence') {
15292
                    addData = addData + rec.FieldName + ":" + "'',";
15293
                }
15294
                var null_ = null;
15295
                var ReadOnly_ = false;
15296
                if (rec.IsPrimaryKey == true) {
15297
                    null_ = false;
15298
                }
15299
                if (rec.IsRequired == true) {
15300
                    null_ = false;
15301
                } else {
15302
                    null_ = true;
15303
                }
15304
                if (rec.ReadOnly == '1') {
15305
                    ReadOnly_ = true;
15306
                }
15307
                var Hidden_ = false;
15308
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
15309
                    Hidden_ = true;
15310
                    null_ = true;
15311
                }
15312
                if (rec.GridView == 1) {
15313
                    switch (rec.FormatRef) {
15314
                        case "date":
15315
                            cols.push({
15316
                                xtype: 'minovadatecolumn',
15317
                                hidden: Hidden_,
15318
                                text: rec.HeaderTitle,
15319
                                dataIndex: rec.FieldName,
15320
                                filter: {
15321
                                    itemDefaults: {
15322
                                        emptyText: 'Search for...',
15323
                                    }
15324
                                },
15325
                                editor: {
15326
                                    allowBlank: null_,
15327
                                    xtype: 'datefield',
15328
                                    hideMode: 'visibility',
15329
                                    readOnly: ReadOnly_,
15330
                                    id: tableName + rec.FieldName,
15331
                                    fieldGrid: rec.FieldName,
15332
                                    nameTable: rec.TableName,
15333
                                }
15334
                            });
15335
                            break
15336
                        case "amount":
15337
                            cols.push({
15338
                                xtype: 'minovacurrancycolumn',
15339
                                //renderer: Ext.util.Format.numberRenderer("0,0"),
15340
                                text: rec.HeaderTitle,
15341
                                align: 'right',
15342
                                dataIndex: rec.FieldName,
15343
                                hidden: Hidden_,
15344
                                filter: {
15345
                                    itemDefaults: {
15346
                                        emptyText: 'Search for...'
15347
                                    }
15348
                                },
15349
                                editor: {
15350
                                    allowBlank: null_,
15351
                                    xtype: 'minovacurrencyfield',
15352
                                    //renderer: Ext.util.Format.numberRenderer("0,0"),
15353
                                    //vtype: 'validateDecimal',
15354
                                    readOnly: ReadOnly_,
15355
                                    id: tableName + rec.FieldName,
15356
                                    nameTable: rec.TableName,
15357
                                    fieldGrid: rec.FieldName,
15358
                                    fieldStyle: 'text-align:right;',
15359
                                    value: '0',
15360

    
15361
                                }
15362
                            });
15363
                            break
15364
                        case "time":
15365
                            var DefaultValue = rec.DefaultValue;
15366
                            if (DefaultValue == '') {
15367
                                defaultValue = '00:00';
15368
                            }
15369
                            cols.push({
15370
                                //xtype: 'minovatimecolumn',
15371
                                xtype: 'timefield',
15372
                                format: 'H:i',
15373
                                submitFormat: 'Hi',
15374
                                text: rec.HeaderTitle,
15375
                                dataIndex: rec.FieldName,
15376
                                hidden: Hidden_,
15377
                                //renderer: Ext.util.Format.dateRenderer('G:i'),
15378
                                filter: {
15379
                                    itemDefaults: {
15380
                                        emptyText: 'Search for...'
15381
                                    }
15382
                                },
15383
                                editor: {
15384
                                    allowBlank: null_,
15385
                                    xtype: 'timefield',
15386
                                    readOnly: ReadOnly_,
15387
                                    id: tableName + rec.FieldName,
15388
                                    format: 'H:i',
15389
                                    submitFormat: 'Hi',
15390
                                    increment: 5,
15391
                                    value: DefaultValue,
15392
                                    anchor: '100%',
15393
                                    listeners: {}
15394
                                    //renderer: Ext.util.Format.dateRenderer('G:i'),
15395
                                }
15396
                            });
15397
                            break
15398
                        default:
15399
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
15400
                                cols.push({
15401
                                    text: rec.HeaderTitle,
15402
                                    dataIndex: rec.FieldName,
15403
                                    width: 100,
15404
                                    filter: {
15405
                                        type: 'string',
15406
                                        itemDefaults: {
15407
                                            emptyText: 'Search for...'
15408
                                        }
15409
                                    }
15410
                                });
15411
                            } else if (rec.SearchType == '0') {
15412
                                var valueField = null;
15413
                                var displayValue = null;
15414
                                var TableRef = undefined;
15415
                                if (rec.TableRef != '') {
15416
                                    TableRef = rec.TableRef;
15417

    
15418
                                    Ext.Ajax.request({
15419
                                        async: false,
15420
                                        method: 'POST',
15421
                                        url: '/UserControl/GetStore',
15422
                                        params: {
15423
                                            tableName: 'SDATATABLEFIELD',
15424
                                            param: 'TableName[equal]' + rec.TableRef
15425
                                        },
15426
                                        success: function (response) {
15427
                                            var results = Ext.decode(response.responseText);
15428
                                            data_ = results.data;
15429
                                            if (data_ != undefined) {
15430
                                                valueField_ = $.grep(data_, function (r) {
15431
                                                    return r.ValueField == '1'
15432
                                                });
15433
                                                valueField = valueField_[0].FieldName
15434
                                                displayValue_ = $.grep(data_, function (r) {
15435
                                                    return r.DisplayValue == '1'
15436
                                                });
15437
                                                displayValue = displayValue_[0].FieldName
15438
                                            }
15439
                                        }
15440
                                    });
15441

    
15442
                                    //create Store
15443
                                    Ext.create('Ext.data.Store', {
15444
                                        storeId: 'store_' + me.tableName + rec.FieldName,
15445
                                        autoLoad: true,
15446
                                        proxy: {
15447
                                            method: 'POST',
15448
                                            type: 'ajax',
15449
                                            url: '/UserControl/GetStore',
15450
                                            extraParams: {
15451
                                                tableName: TableRef,
15452
                                                param: rec.ParamCombo
15453
                                            },
15454
                                            reader: {
15455
                                                type: 'json',
15456
                                                root: 'data',
15457
                                                totalProperty: 'data[0].TotalCount'
15458
                                            }
15459
                                        }
15460
                                    });
15461
                                } else if (rec.FixedValue != '') {
15462
                                    var storeData = [];
15463
                                    var str = rec.FixedValue;
15464
                                    var hasil = str.split('||');
15465
                                    hasil.forEach(function (h) {
15466
                                        store_ = h.split('=')
15467
                                        storeData.push({
15468
                                            code: store_[0],
15469
                                            desc: store_[1],
15470

    
15471
                                        });
15472
                                    });
15473

    
15474
                                    valueField = 'code';
15475
                                    displayValue = 'desc';
15476

    
15477
                                    Ext.create('Ext.data.Store', {
15478
                                        storeId: 'store_' + me.tableName + rec.FieldName,
15479
                                        autoLoad: true,
15480
                                        data: storeData
15481
                                    })
15482
                                }
15483

    
15484
                                cols.push({
15485
                                    xtype: 'minovacombocolumn',
15486
                                    hidden: Hidden_,
15487
                                    text: rec.HeaderTitle,
15488
                                    dataIndex: rec.FieldName,
15489
                                    valueField: valueField,
15490
                                    displayField: displayValue,
15491
                                    store: 'store_' + me.tableName + rec.FieldName,
15492
                                    editor: {
15493
                                        allowBlank: null_,
15494
                                        xtype: 'combobox',
15495
                                        readOnly: ReadOnly_,
15496
                                        id: tableName + rec.FieldName,
15497
                                        nameTable: rec.TableName,
15498
                                        fieldGrid: rec.FieldName,
15499
                                        valueField: valueField,
15500
                                        displayField: displayValue,
15501

    
15502
                                        store: 'store_' + me.tableName + rec.FieldName,
15503
                                    },
15504
                                    filter: {
15505
                                        type: 'list',
15506
                                        itemDefaults: {
15507
                                            emptyText: 'Search for...'
15508
                                        }
15509
                                    }
15510
                                });
15511
                            } else if (rec.SearchType == '5') {							
15512
                                var valueField = null;
15513
                                var displayValue = null;
15514
                                var AdditionaldisplayValue = null;
15515
                                var TableRef = undefined;
15516
                                if (rec.TableRef != '') {
15517
                                    TableRef = rec.TableRef;
15518
                                    Ext.Ajax.request({
15519
                                        async: false,
15520
                                        method: 'POST',
15521
                                        url: '/UserControl/GetStore',
15522
                                        params: {
15523
                                            tableName: 'SDATATABLEFIELD',
15524
                                            param: 'TableName[equal]' + rec.TableRef
15525
                                        },
15526
                                        success: function (response) {
15527
                                            var results = Ext.decode(response.responseText);
15528
                                            data_ = results.data;
15529
                                            if (data_ != undefined) {
15530
                                                valueField_ = $.grep(data_, function (r) {
15531
                                                    return r.ValueField == '1'
15532
                                                });
15533
                                                if (valueField_.length > 0) {
15534
                                                    valueField = valueField_[0].FieldName
15535
                                                }
15536

    
15537
                                                displayValue_ = $.grep(data_, function (r) {
15538
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
15539
                                                });
15540
                                                if (displayValue_.length > 0) {
15541
                                                    displayValue = displayValue_[0].FieldName;
15542
                                                }
15543
                                                if (displayValue_.length >= 2) {
15544
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
15545
                                                }
15546
                                            }
15547
                                        }
15548
                                    });
15549
                                }
15550
                                Ext.create('Ext.data.Store', {
15551
                                    storeId: 'store_' + me.tableName + rec.FieldName,
15552
                                    autoLoad: true,
15553
                                    proxy: {
15554
                                        method: 'POST',
15555
                                        type: 'ajax',
15556
                                        url: '/UserControl/GetStoreAuth',
15557
                                        extraParams: {
15558
                                            tableName: TableRef,
15559
                                            param: rec.ParamCombo,
15560
                                            menuId: MinovaUtil.GetMenuID()
15561
                                        },
15562
                                        reader: {
15563
                                            type: 'json',
15564
                                            root: 'data',
15565
                                            totalProperty: 'data[0].TotalCount'
15566
                                        }
15567
                                    }
15568
                                });
15569
                                cols.push({
15570
                                    xtype : 'minovacombocolumn',
15571
                                    hidden: Hidden_,
15572
                                    text: rec.HeaderTitle,
15573
                                    dataIndex: rec.FieldName,
15574
                                    valueField : valueField,
15575
                                    displayField : displayValue,
15576
                                    store : 'store_' + me.tableName + rec.FieldName,
15577
                                    tpl: Ext.create('Ext.XTemplate',
15578
                                            '<ul class="x-list-plain"><tpl for=".">',
15579
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
15580
                                            '</tpl></ul>'),
15581
                                    displayTpl: Ext.create('Ext.XTemplate',
15582
                                        '<tpl for=".">',
15583
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
15584
                                        '</tpl>'),
15585
                                    editor: {
15586
                                        allowBlank: null_,
15587
                                        xtype: 'combobox',
15588
                                        readOnly: ReadOnly_,
15589
                                        id: rec.TableName + rec.FieldName,
15590
                                        nameTable: rec.TableName,
15591
                                        fieldGrid: rec.FieldName,
15592
                                        valueField: valueField,
15593
                                        displayField: displayValue,
15594
                                        store: 'store_' + me.tableName + rec.FieldName,
15595
                                        value: rec.DefaultValue,
15596
                                        tpl: Ext.create('Ext.XTemplate',
15597
                                            '<ul class="x-list-plain"><tpl for=".">',
15598
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
15599
                                            '</tpl></ul>'),
15600
                                        displayTpl: Ext.create('Ext.XTemplate',
15601
                                            '<tpl for=".">',
15602
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
15603
                                            '</tpl>')
15604
                                    },
15605
                                    renderer: function (value) {
15606
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
15607
                                        var index = store.find(valueField, value);
15608
                                        var val = "";
15609
                                        if (index != -1) {
15610
                                            var rc = store.getAt(index);
15611
                                            //val = rc.get(displayValue);
15612
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
15613
                                        } else {
15614
                                            val = value;
15615
                                        }
15616
                                        return val;
15617
                                    },
15618
                                    filter: {
15619
                                        type: 'list',
15620
                                        itemDefaults: {
15621
                                            emptyText: 'Search for...'
15622
                                        }
15623
                                    }
15624
                                });
15625
                            } else if (rec.SearchType == '2') {
15626
                                var triger = (rec.TriggerCombo).split('$');
15627
                                var targetField_ = triger[0];
15628
                                var fieldValue_ = triger[1];
15629
                                cols.push({
15630
                                    text: rec.HeaderTitle,
15631
                                    hidden: Hidden_,
15632
                                    dataIndex: rec.FieldName,
15633
                                    filter: {
15634
                                        itemDefaults: {
15635
                                            emptyText: 'Search for...'
15636
                                        }
15637
                                    },
15638
                                    editor: {
15639
                                        allowBlank: null_,
15640
                                        xtype: 'minovalookupgrid',
15641
                                        readOnly: ReadOnly_,
15642
                                        isGrid: true,
15643
                                        fieldTarget: targetField_,
15644
                                        fieldValue: fieldValue_,
15645
                                        isGrid: true,
15646
                                        id: tableName + rec.FieldName,
15647
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
15648
                                        triggerCls: 'x-form-search-trigger',
15649
                                        vtype: 'alphanum', // disable space
15650
                                        nameTable: rec.TableName,
15651
                                        fieldGrid: rec.FieldName,
15652
                                        LookupFunction: rec.LookupFunction,
15653
                                        listeners: {
15654
                                            change: function (val) {
15655
                                                var custumFunc = rec.SelectFunction;
15656
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
15657
                                                    Ext.Ajax.request({
15658
                                                        async: false,
15659
                                                        method: 'POST',
15660
                                                        url: '/UserControl/GetStore',
15661
                                                        params: {
15662
                                                            tableName: 'PCMFUNC',
15663
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
15664
                                                        },
15665
                                                        success: function (response) {
15666
                                                            var results = Ext.decode(response.responseText);
15667
                                                            data_ = results.data[0];
15668
                                                            if (data_ != undefined) {
15669
                                                                custumFunc = data_.FunctionCode;
15670
                                                            }
15671
                                                        }
15672
                                                    });
15673
                                                }
15674
                                                if (custumFunc) {
15675
                                                    eval(custumFunc)
15676
                                                }
15677
                                            }
15678
                                        }
15679
                                    }
15680
                                });
15681
                            } else if (rec.SearchType == '3') {
15682
                                cols.push({
15683
                                    text: rec.HeaderTitle,
15684
                                    hidden: Hidden_,
15685
                                    dataIndex: rec.FieldName,
15686
                                    filter: {
15687
                                        itemDefaults: {
15688
                                            emptyText: 'Search for...'
15689
                                        }
15690
                                    },
15691
                                    editor: {
15692
                                        allowBlank: null_,
15693
                                        // xtype: 'minovalookuptreePopup',
15694
                                        xtype: 'MinovaLookupTree',
15695
                                        readOnly: ReadOnly_,
15696
                                        id: tableName + rec.FieldName,
15697
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
15698
                                        triggerCls: 'x-form-search-trigger',
15699
                                        vtype: 'alphanum', // disable space
15700
                                        treeSructure: rec.SearchFunction, //'O-O-P',
15701
                                        objClassValue: rec.ParamCombo, //'O',
15702
                                        nameTable: rec.TableName,
15703
                                        fieldGrid: rec.FieldName,
15704
                                        listeners: {
15705
                                            change: function (val) {
15706
                                                var custumFunc = rec.SelectFunction;
15707
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
15708
                                                    Ext.Ajax.request({
15709
                                                        async: false,
15710
                                                        method: 'POST',
15711
                                                        url: '/UserControl/GetStore',
15712
                                                        params: {
15713
                                                            tableName: 'PCMFUNC',
15714
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
15715
                                                        },
15716
                                                        success: function (response) {
15717
                                                            var results = Ext.decode(response.responseText);
15718
                                                            data_ = results.data[0];
15719
                                                            if (data_ != undefined) {
15720
                                                                custumFunc = data_.FunctionCode;
15721
                                                            }
15722
                                                        }
15723
                                                    });
15724
                                                }
15725
                                                if (custumFunc) {
15726
                                                    eval(custumFunc)
15727
                                                }
15728
                                            }
15729
                                        }
15730
                                    }
15731
                                });
15732
                            } 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) {
15733
                                var triger = (rec.TriggerCombo).split('&');
15734
                                var targetField_ = triger[0];
15735
                                var fieldValue_ = triger[0];
15736
                                cols.push({
15737
                                    text: rec.HeaderTitle,
15738
                                    hidden: Hidden_,
15739
                                    dataIndex: rec.FieldName,
15740
                                    filter: {
15741
                                        itemDefaults: {
15742
                                            emptyText: 'Search for...'
15743
                                        }
15744
                                    },
15745
                                    editor: {
15746
                                        allowBlank: null_,
15747
                                        xtype: 'lookupemployee',
15748
                                        readOnly: ReadOnly_,
15749
                                        isGrid: true,
15750
                                        fieldTarget: targetField_,
15751
                                        fieldValue: fieldValue_,
15752
                                        isGrid: true,
15753
                                        id: tableName + rec.FieldName,
15754
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
15755
                                        triggerCls: 'x-form-search-trigger',
15756
                                        vtype: 'alphanum', // disable space
15757
                                        nameTable: rec.TableName,
15758
                                        fieldGrid: rec.FieldName,
15759
                                        listeners: {
15760
                                            change: function (val) {
15761
                                                var custumFunc = rec.SelectFunction;
15762
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
15763
                                                    Ext.Ajax.request({
15764
                                                        async: false,
15765
                                                        method: 'POST',
15766
                                                        url: '/UserControl/GetStore',
15767
                                                        params: {
15768
                                                            tableName: 'PCMFUNC',
15769
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
15770
                                                        },
15771
                                                        success: function (response) {
15772
                                                            var results = Ext.decode(response.responseText);
15773
                                                            data_ = results.data[0];
15774
                                                            if (data_ != undefined) {
15775
                                                                custumFunc = data_.FunctionCode;
15776
                                                            }
15777
                                                        }
15778
                                                    });
15779
                                                }
15780
                                                if (custumFunc) {
15781
                                                    eval(custumFunc)
15782
                                                }
15783
                                            }
15784
                                        }
15785
                                    }
15786
                                });
15787
                            } else if (rec.SearchType == '4' && isLookup != true) {
15788
                                cols.push({
15789

    
15790
                                    text: rec.HeaderTitle,
15791
                                    hidden: Hidden_,
15792
                                    dataIndex: rec.FieldName,
15793
                                    filter: {
15794
                                        itemDefaults: {
15795
                                            emptyText: 'Search for...'
15796
                                        }
15797
                                    },
15798
                                    editor: {
15799
                                        allowBlank: null_,
15800
                                        xtype: 'lookupemployee',
15801
                                        readOnly: ReadOnly_,
15802
                                        isGrid: true,
15803
                                        fieldTarget: targetField_,
15804
                                        fieldValue: fieldValue_,
15805
                                        isGrid: true,
15806
                                        id: tableName + rec.FieldName,
15807
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
15808
                                        triggerCls: 'x-form-search-trigger',
15809
                                        vtype: 'alphanum', // disable space
15810
                                        nameTable: rec.TableName,
15811
                                        fieldGrid: rec.FieldName,
15812
                                        listeners: {
15813
                                            change: function (val) {
15814
                                                var custumFunc = rec.SelectFunction;
15815
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
15816
                                                    Ext.Ajax.request({
15817
                                                        async: false,
15818
                                                        method: 'POST',
15819
                                                        url: '/UserControl/GetStore',
15820
                                                        params: {
15821
                                                            tableName: 'PCMFUNC',
15822
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
15823
                                                        },
15824
                                                        success: function (response) {
15825
                                                            var results = Ext.decode(response.responseText);
15826
                                                            data_ = results.data[0];
15827
                                                            if (data_ != undefined) {
15828
                                                                custumFunc = data_.FunctionCode;
15829
                                                            }
15830
                                                        }
15831
                                                    });
15832
                                                }
15833
                                                if (custumFunc) {
15834
                                                    eval(custumFunc)
15835
                                                }
15836
                                            }
15837
                                        }
15838
                                    }
15839
                                });
15840
                            } else {
15841
                                cols.push({
15842
                                    text: rec.HeaderTitle,
15843
                                    hidden: Hidden_,
15844
                                    dataIndex: rec.FieldName,
15845
									editable :ReadOnly_,
15846
									flex: 1,									
15847
                                    filter: {
15848
                                        itemDefaults: {
15849
                                            emptyText: 'Search for...'
15850
                                        }
15851
                                    },
15852
                                    editor: {
15853
                                        allowBlank: null_,
15854
                                        xtype: 'textfield',
15855
                                        readOnly: ReadOnly_,
15856
                                        id: tableName + rec.FieldName,
15857
                                        nameTable: rec.TableName,
15858
                                        fieldGrid: rec.FieldName,
15859
                                        listeners: {
15860
                                            change: function (val) {
15861
                                                var custumFunc = null;
15862
                                                Ext.Ajax.request({
15863
                                                    async: false,
15864
                                                    method: 'POST',
15865
                                                    url: '/UserControl/GetStore',
15866
                                                    params: {
15867
                                                        tableName: 'SDATATABLEFIELD',
15868
                                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
15869
                                                    },
15870
                                                    success: function (response) {
15871
                                                        var results = Ext.decode(response.responseText);
15872
                                                        data_ = results.data[0];
15873
                                                        if (data_ != undefined) {
15874
                                                            custumFunc = data_.SelectFunction;
15875
                                                            
15876
                                                        }
15877
                                                    }
15878
                                                });
15879
                                                if (custumFunc) {
15880
                                                    eval(custumFunc)
15881
                                                }
15882
                                            }
15883
                                        }
15884
                                    }
15885
                                });			
15886
                            }
15887
                            break
15888
                    }
15889
                } else {
15890
                    cols.push({
15891
                        text: rec.HeaderTitle,
15892
                        hidden: Hidden_,
15893
                        dataIndex: rec.FieldName,
15894
                        hidden: true,
15895
                        editor: {
15896
                            allowBlank: true,
15897
                            xtype: 'textfield',
15898
                            readOnly: ReadOnly_,
15899
                            id: tableName + rec.FieldName,
15900
                            nameTable: rec.TableName,
15901
                            fieldGrid: rec.FieldName,
15902
                        },
15903
                        filter: {
15904
                            itemDefaults: {
15905
                                emptyText: 'Search for...'
15906
                            }
15907
                        }
15908
                    });
15909
                }
15910
            });
15911
        };
15912
        addData = addData + "}";
15913
        Ext.applyIf(me, {
15914

    
15915
            items: [{
15916
                xtype: 'grid',
15917
                id: gridName,
15918
                name: gridName,
15919
                height: height,
15920
                autoHeight: true,
15921
                //store: 'gridStore',
15922
                autoScroll: true,
15923
				
15924
                store: Ext.create('Ext.data.Store', {
15925
                    storeId: storeID,
15926
                    fields: fieldStore,
15927
                    proxy: {
15928
                        method: 'POST',
15929
                        type: 'ajax',
15930
                        url: '',
15931
                        reader: {
15932
                            type: 'json',
15933
                            root: 'data'
15934
                        }
15935
                    }
15936
                }),
15937
                dockedItems: [{
15938
                    xtype: 'toolbar',
15939
                    items: [{
15940
                        text: 'Add',
15941
                        hidden: hide_,
15942
                        name: tableName + 'Add',
15943
                        iconCls: 'fa-plus-circle',
15944
                        style: 'font-family: FontAwesome',
15945
                        handler: function () {
15946
                            var store = Ext.StoreMgr.lookup(storeID)
15947
                            idx = store.getCount();
15948
                            var action = getParam('action');
15949
                            var data = '';
15950
                            var Sequence = 0;
15951
                            if (idx == 0) {
15952
                                Sequence = 1;
15953
                            } else {
15954
                                Sequence = 1 + idx;
15955
                            }
15956

    
15957
                            var seq = 'Sequence';
15958
                            var SequenceValue = Sequence;
15959
                            eval(addData);
15960
                            data[seq] = SequenceValue;
15961

    
15962
                            store.insert(idx, data);
15963
                        }
15964

    
15965
                    }, {
15966
                        text: 'Delete',
15967
                        hidden: hide_,
15968
                        name: tableName + 'DeleteText',
15969
                        iconCls: 'fa-trash-o',
15970
                        style: 'font-family: FontAwesome',
15971
                        //disabled: true
15972
                        handler: function () {
15973
                            var me = this,
15974
                            store = Ext.StoreMgr.lookup(storeID)
15975

    
15976
                            var grid = Ext.getCmp(gridName);
15977

    
15978
                            Ext.MessageBox.show({
15979
                                title: 'Remove tab',
15980
                                msg: "This will remove. Do you want to continue?",
15981
                                buttons: Ext.MessageBox.YESNO,
15982
                                fn: function (choice) {
15983
                                    console.log(choice);
15984
                                    if (choice === 'yes') {
15985
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
15986
                                        if (selection) {
15987
                                            store.remove(selection);
15988
                                        }
15989
                                    }
15990
                                    //delete panel.pendingClose;
15991
                                }
15992
                            });
15993
                        }
15994

    
15995
                    }
15996
                    ]
15997
                }
15998
                ],
15999
                columns: cols,
16000
                selType: checkSelection,
16001
                plugins: {
16002
					type: 'grideditable',
16003
					ptype: 'cellediting',
16004
					clicksToEdit: 1					
16005
                    //ptype: 'rowediting',
16006
                    //pluginId: 'rowEditing',
16007
                    //clicksToEdit: 1,
16008
                    //listeners: {
16009
                        //edit: 'onGridEditorEdit'
16010
                    //}
16011
                }
16012
            }, ]
16013

    
16014
        });
16015

    
16016
        me.callParent(arguments);
16017
    }
16018
});
16019

    
16020
Ext.define('MinovaUtil.MinovaES.Minovatimefield', {
16021
    extend: 'Ext.form.field.Time',
16022
    alias: ['widget.minovatimefield'],
16023
    undefinedText: '&#160;',
16024
    setValue: function (v) {
16025
        hasil = '';
16026
        if (v != this.getValue()) {
16027
            if (v) {
16028
                if (v.length == 4) {
16029

    
16030
                    var h = v.substring(0, 2);
16031
                    var m = v.substring(2, 4)
16032
                    //this.setValue(h +':'+m);
16033
                    hasil = h + ':' + m;
16034
                }
16035
                if (v.length == 5) {
16036
                    this.setValue(v);
16037
                    hasil = v;
16038
                }
16039
            }
16040
            this.setValue(hasil);
16041
        }
16042

    
16043
    },
16044
});
16045

    
16046
Ext.define('MinovaUtil.MinovaES.MinovaFixValueLabel', {
16047
    extend: 'Ext.form.Label',
16048
    alias: ['widget.MinovaFixValueLabel', 'widget.minovafixvaluelabel'],
16049
    anchor: '50%',
16050
    defaultRenderer: function (value) {
16051
        if (typeof(this.store) !== 'object') {
16052
            this.store = Ext.data.StoreManager.lookup(this.store);
16053
        }
16054
        var idx = this.store.findExact('code', value);
16055
        if (this.store.getAt(idx)) {
16056
            var result = this.store.getAt(idx).get('desc');
16057
            value = result ? result : value;
16058
        }
16059
        this.setRawValue(value);
16060

    
16061
    },
16062
    initComponent: function () {
16063
        var me = this;
16064
        var storeData = [];
16065
        var str = me.fixedValue;
16066
        var hasil = str.split('||');
16067
        hasil.forEach(function (h) {
16068
            store_ = h.split('=')
16069
            storeData.push({
16070
                code: store_[0],
16071
                desc: store_[1],
16072

    
16073
            });
16074
        });
16075
        Ext.applyIf(me, {
16076

    
16077
            store: Ext.create('Ext.data.Store', {
16078
                storeId: 'store' + name,
16079
                autoLoad: true,
16080
                data: storeData
16081

    
16082
            }),
16083

    
16084
        });
16085
        me.callParent(arguments);
16086
    }
16087
});
16088

    
16089
Ext.define('MinovaUtil.MinovaES.MinovaComboColumnFixValueLabel', {
16090
    extend: 'Ext.grid.column.Column',
16091
    alias: ['widget.minovacombocolumnfixvalue'],
16092
    initComponent: function () {
16093
        var me = this;
16094
        var storeData = [];
16095
        var str = me.fixedValue;
16096
        var hasil = str.split('||');
16097
        hasil.forEach(function (h) {
16098
            store_ = h.split('=')
16099
            storeData.push({
16100
                code: store_[0],
16101
                desc: store_[1],
16102

    
16103
            });
16104
        });
16105
        Ext.applyIf(me, {
16106

    
16107
            store: Ext.create('Ext.data.Store', {
16108
                storeId: 'store' + name,
16109
                autoLoad: true,
16110
                data: storeData
16111

    
16112
            }),
16113

    
16114
        });
16115
        this.callParent(arguments);
16116
    },
16117
    defaultRenderer: function (value) {
16118
        if (typeof(this.store) !== 'object') {
16119
            Ext.data.StoreManager.lookup(this.store).load();
16120
            this.store = Ext.data.StoreManager.lookup(this.store);
16121
        }
16122
        var idx = this.store.findExact('code', value);
16123
        if (this.store.getAt(idx)) {
16124
            var result = this.store.getAt(idx).get('desc');
16125
            value = result ? result : value;
16126
        }
16127
        return value;
16128
    }
16129
});
16130

    
16131
Ext.define('MinovaUtil.MinovaES.MinovaLookupColumn', {
16132
    extend: 'Ext.grid.column.Column',
16133
    alias: ['widget.minovalookupcolumn'],
16134
    initComponent: function () {
16135
        this.callParent(arguments);
16136
    },
16137
    defaultRenderer: function (value) {
16138
        data_ = undefined;
16139
        Ext.Ajax.request({
16140
            async: false,
16141
            method: 'POST',
16142
            url: '/UserControl/GetStore',
16143
            params: {
16144
                tableName: 'PDSCMTABLE',
16145
                param: this.tableName + ',' + value + ',hasil'
16146
            },
16147
            success: function (response) {
16148
                var results = Ext.decode(response.responseText);
16149
                data_ = results.data;
16150
                if (data_ != null) {
16151
                    if (data_.length > 0) {
16152
                        value = value + '-' + data_[0].hasil;
16153
                    }
16154
                }
16155
            }
16156
        });
16157
        return value;
16158
    }
16159
});
16160

    
16161
Ext.define('MinovaUtil.MinovaES.MinovaPMSTreeEditAbleGrid', {
16162
    extend: 'Ext.form.Panel',
16163
    alias: ['widget.MinovaPMSTreeEditAbleGrid', 'widget.Minovapmstreeeditablegrid', 'widget.minovapmstreeeeditablegrid'],
16164
    requires: [
16165
		'Ext.grid.plugin.CellEditing',
16166
		'Ext.grid.Panel',
16167
    ],
16168
    anchor: '100%',
16169
    tableName: undefined,
16170
    apprasalType: undefined,
16171
    empID: undefined,
16172
    hideButton: undefined,
16173
    multiSelect: undefined,
16174
    height: undefined,
16175
    initComponent: function () {
16176
        var me = this;
16177
        var isLookup = me.isLookup;
16178
        var hide_ = false;
16179
        var widthLock = 250;
16180
        var checkSelection = '';
16181
        if (me.hideButton == true) {
16182
            hide_ = true;
16183
        }
16184
        if (me.multiSelect) {
16185
            locking = false;
16186
            checkSelection = 'checkboxmodel';
16187
            widthLock = 40;
16188
        }
16189
        var tableName = me.tableName;
16190
        var cols = [];
16191
        var fieldStore = [];
16192
        var _url = 'GetAllField';
16193
        var hasil = null;
16194
        var height = me.height;
16195
        var storeID = 'store' + me.tableName;
16196
        var gridName = 'grid' + me.tableName;
16197
        if (me.storeName) {
16198
            storeID = me.storeName;
16199
        }
16200
        var empID = me.empID;
16201
        var apprasalType = me.apprasalType;
16202
        var LangID = MinovaUtil.GetLangID();
16203
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'" + "," + empID + "," + apprasalType
16204
        Ext.Ajax.request({
16205
            async: false,
16206
            method: 'POST',
16207
            url: '/Performance/getFieldPMS',
16208
            params: {
16209
                tableName: 'PDSPMS001',
16210
                _param: parameter
16211
            },
16212
            success: function (response) {
16213
                var results = Ext.decode(response.responseText);
16214
                hasil = Ext.decode(results.data);
16215
            }
16216
        });
16217
        var addData = 'var data={';
16218
        if (hasil.length > 0) {
16219
            Ext.each(hasil, function (rec) {
16220
                fieldStore.push(rec.FieldName)
16221
                if (rec.FieldName != 'Sequence') {
16222
                    addData = addData + rec.FieldName + ":" + "'',";
16223
                }
16224
                var null_ = null;
16225
                var ReadOnly_ = false;
16226
                if (rec.IsPrimaryKey == true) {
16227
                    null_ = false;
16228
                }
16229
                if (rec.IsRequired == true) {
16230
                    null_ = false;
16231
                } else {
16232
                    null_ = true;
16233
                }
16234
                if (rec.ReadOnly == '1') {
16235
                    ReadOnly_ = true;
16236
                }
16237
                var Hidden_ = false;
16238
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
16239
                    Hidden_ = true;
16240
                    null_ = true;
16241
                }
16242
                if (rec.GridView != 0) {
16243
                    if (rec.GridView == 3) {
16244
                        cols.push({
16245
                            xtype: 'treecolumn',
16246
                            text: rec.HeaderTitle,
16247
                            dataIndex: rec.FieldName,
16248
                            hidden: Hidden_,
16249
                            width: 200,
16250
                            sortable: true,
16251
                            filter: {
16252
                                itemDefaults: {
16253
                                    emptyText: 'Search for...'
16254
                                }
16255
                            }
16256
                        });
16257
                    } else {
16258
                        switch (rec.FormatRef) {
16259
                            case "date":
16260
                                cols.push({
16261
                                    xtype: 'minovadatecolumn',
16262
                                    hidden: Hidden_,
16263
                                    text: rec.HeaderTitle,
16264
                                    dataIndex: rec.FieldName,
16265
                                    filter: {
16266
                                        itemDefaults: {
16267
                                            emptyText: 'Search for...',
16268
                                        }
16269
                                    },
16270
                                    editor: {
16271
                                        allowBlank: null_,
16272
                                        xtype: 'datefield',
16273
                                        hideMode: 'visibility',
16274
                                        readOnly: ReadOnly_,
16275
                                        id: tableName + rec.FieldName,
16276
                                        fieldGrid: rec.FieldName,
16277
                                        nameTable: rec.TableName,
16278
                                    }
16279
                                });
16280
                                break
16281
                            case "amount":
16282
                                cols.push({
16283
                                    xtype: 'minovacurrancycolumn',
16284
                                    //renderer: Ext.util.Format.numberRenderer("0,0"),
16285
                                    text: rec.HeaderTitle,
16286
                                    align: 'right',
16287
                                    dataIndex: rec.FieldName,
16288
                                    hidden: Hidden_,
16289
                                    filter: {
16290
                                        itemDefaults: {
16291
                                            emptyText: 'Search for...'
16292
                                        }
16293
                                    },
16294
                                    editor: {
16295
                                        allowBlank: null_,
16296
                                        xtype: 'minovacurrencyfield',
16297
                                        //renderer: Ext.util.Format.numberRenderer("0,0"),
16298
                                        //vtype: 'validateDecimal',
16299
                                        readOnly: ReadOnly_,
16300
                                        id: tableName + rec.FieldName,
16301
                                        nameTable: rec.TableName,
16302
                                        fieldGrid: rec.FieldName,
16303
                                        fieldStyle: 'text-align:right;',
16304
                                        value: '0',
16305

    
16306
                                    }
16307
                                });
16308
                                break
16309
                            case "time":
16310
                                var DefaultValue = rec.DefaultValue;
16311
                                if (DefaultValue == '') {
16312
                                    defaultValue = '00:00';
16313
                                }
16314
                                cols.push({
16315
                                    //xtype: 'minovatimecolumn',
16316
                                    xtype: 'timefield',
16317
                                    format: 'H:i',
16318
                                    submitFormat: 'Hi',
16319
                                    text: rec.HeaderTitle,
16320
                                    dataIndex: rec.FieldName,
16321
                                    hidden: Hidden_,
16322
                                    //renderer: Ext.util.Format.dateRenderer('G:i'),
16323
                                    filter: {
16324
                                        itemDefaults: {
16325
                                            emptyText: 'Search for...'
16326
                                        }
16327
                                    },
16328
                                    editor: {
16329
                                        allowBlank: null_,
16330
                                        xtype: 'timefield',
16331
                                        readOnly: ReadOnly_,
16332
                                        id: tableName + rec.FieldName,
16333
                                        format: 'H:i',
16334
                                        submitFormat: 'Hi',
16335
                                        increment: 5,
16336
                                        value: DefaultValue,
16337
                                        anchor: '100%',
16338
                                        listeners: {}
16339
                                        //renderer: Ext.util.Format.dateRenderer('G:i'),
16340
                                    }
16341
                                });
16342
                                break
16343
                            default:
16344
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
16345
                                    cols.push({
16346
                                        text: rec.HeaderTitle,
16347
                                        dataIndex: rec.FieldName,
16348
                                        width: 100,
16349
                                        filter: {
16350
                                            type: 'string',
16351
                                            itemDefaults: {
16352
                                                emptyText: 'Search for...'
16353
                                            }
16354
                                        }
16355
                                    });
16356
                                } else if (rec.SearchType == '0') {
16357
                                    var valueField = null;
16358
                                    var displayValue = null;
16359
                                    var TableRef = undefined;
16360
                                    if (rec.TableRef != '') {
16361
                                        TableRef = rec.TableRef;
16362

    
16363
                                        Ext.Ajax.request({
16364
                                            async: false,
16365
                                            method: 'POST',
16366
                                            url: '/UserControl/GetStore',
16367
                                            params: {
16368
                                                tableName: 'SDATATABLEFIELD',
16369
                                                param: 'TableName[equal]' + rec.TableRef
16370
                                            },
16371
                                            success: function (response) {
16372
                                                var results = Ext.decode(response.responseText);
16373
                                                data_ = results.data;
16374
                                                if (data_ != undefined) {
16375
                                                    valueField_ = $.grep(data_, function (r) {
16376
                                                        return r.ValueField == '1'
16377
                                                    });
16378
                                                    valueField = valueField_[0].FieldName
16379
                                                    displayValue_ = $.grep(data_, function (r) {
16380
                                                        return r.DisplayValue == '1'
16381
                                                    });
16382
                                                    displayValue = displayValue_[0].FieldName
16383
                                                }
16384
                                            }
16385
                                        });
16386

    
16387
                                        //create Store
16388
                                        Ext.create('Ext.data.Store', {
16389
                                            storeId: 'store_' + me.tableName + rec.FieldName,
16390
                                            autoLoad: true,
16391
                                            proxy: {
16392
                                                method: 'POST',
16393
                                                type: 'ajax',
16394
                                                url: '/UserControl/GetStore',
16395
                                                extraParams: {
16396
                                                    tableName: TableRef,
16397
                                                    param: rec.ParamCombo
16398
                                                },
16399
                                                reader: {
16400
                                                    type: 'json',
16401
                                                    root: 'data',
16402
                                                    totalProperty: 'data[0].TotalCount'
16403
                                                }
16404
                                            }
16405
                                        });
16406
                                    } else if (rec.FixedValue != '') {
16407
                                        var storeData = [];
16408
                                        var str = rec.FixedValue;
16409
                                        var hasil = str.split('||');
16410
                                        hasil.forEach(function (h) {
16411
                                            store_ = h.split('=')
16412
                                            storeData.push({
16413
                                                code: store_[0],
16414
                                                desc: store_[1],
16415

    
16416
                                            });
16417
                                        });
16418

    
16419
                                        valueField = 'code';
16420
                                        displayValue = 'desc';
16421

    
16422
                                        Ext.create('Ext.data.Store', {
16423
                                            storeId: 'store_' + me.tableName + rec.FieldName,
16424
                                            autoLoad: true,
16425
                                            data: storeData
16426
                                        })
16427
                                    }
16428

    
16429
                                    cols.push({
16430
                                        xtype: 'minovacombocolumn',
16431
                                        hidden: Hidden_,
16432
                                        text: rec.HeaderTitle,
16433
                                        dataIndex: rec.FieldName,
16434
                                        valueField: valueField,
16435
                                        displayField: displayValue,
16436
                                        store: 'store_' + me.tableName + rec.FieldName,
16437
                                        editor: {
16438
                                            allowBlank: null_,
16439
                                            xtype: 'combobox',
16440
                                            readOnly: ReadOnly_,
16441
                                            id: tableName + rec.FieldName,
16442
                                            nameTable: rec.TableName,
16443
                                            fieldGrid: rec.FieldName,
16444
                                            valueField: valueField,
16445
                                            displayField: displayValue,
16446

    
16447
                                            store: 'store_' + me.tableName + rec.FieldName,
16448
                                        },
16449
                                        filter: {
16450
                                            type: 'list',
16451
                                            itemDefaults: {
16452
                                                emptyText: 'Search for...'
16453
                                            }
16454
                                        }
16455
                                    });
16456

    
16457
                                } else if (rec.SearchType == '5') {								
16458
                                    var valueField = null;
16459
                                    var displayValue = null;
16460
                                    var AdditionaldisplayValue = null;
16461
                                    var TableRef = undefined;
16462
                                    if (rec.TableRef != '') {
16463
                                        TableRef = rec.TableRef;
16464
                                        Ext.Ajax.request({
16465
                                            async: false,
16466
                                            method: 'POST',
16467
                                            url: '/UserControl/GetStore',
16468
                                            params: {
16469
                                                tableName: 'SDATATABLEFIELD',
16470
                                                param: 'TableName[equal]' + rec.TableRef
16471
                                            },
16472
                                            success: function (response) {
16473
                                                var results = Ext.decode(response.responseText);
16474
                                                data_ = results.data;
16475
                                                if (data_ != undefined) {
16476
                                                    valueField_ = $.grep(data_, function (r) {
16477
                                                        return r.ValueField == '1'
16478
                                                    });
16479
                                                    if (valueField_.length > 0) {
16480
                                                        valueField = valueField_[0].FieldName
16481
                                                    }
16482

    
16483
                                                    displayValue_ = $.grep(data_, function (r) {
16484
                                                        return r.DisplayValue == '1' || r.DisplayValue == '2'
16485
                                                    });
16486
                                                    if (displayValue_.length > 0) {
16487
                                                        displayValue = displayValue_[0].FieldName;
16488
                                                    }
16489
                                                    if (displayValue_.length >= 2) {
16490
                                                        AdditionaldisplayValue = displayValue_[1].FieldName
16491
                                                    }
16492
                                                }
16493
                                            }
16494
                                        });
16495
                                    }
16496
                                    Ext.create('Ext.data.Store', {
16497
                                        storeId: 'store_' + me.tableName + rec.FieldName,
16498
                                        autoLoad: true,
16499
                                        proxy: {
16500
                                            method: 'POST',
16501
                                            type: 'ajax',
16502
                                            url: '/UserControl/GetStoreAuth',
16503
                                            extraParams: {
16504
                                                tableName: TableRef,
16505
                                                param: rec.ParamCombo,
16506
                                                menuId: MinovaUtil.GetMenuID()
16507
                                            },
16508
                                            reader: {
16509
                                                type: 'json',
16510
                                                root: 'data',
16511
                                                totalProperty: 'data[0].TotalCount'
16512
                                            }
16513
                                        }
16514
                                    });
16515
                                    cols.push({
16516
                                        xtype : 'minovacombocolumn',
16517
                                        hidden: Hidden_,
16518
                                        text: rec.HeaderTitle,
16519
                                        dataIndex: rec.FieldName,
16520
                                        valueField : valueField,
16521
                                        displayField : displayValue,
16522
                                        store : 'store_' + me.tableName + rec.FieldName,
16523
                                        tpl: Ext.create('Ext.XTemplate',
16524
                                            '<ul class="x-list-plain"><tpl for=".">',
16525
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
16526
                                            '</tpl></ul>'),
16527
                                        displayTpl: Ext.create('Ext.XTemplate',
16528
                                            '<tpl for=".">',
16529
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
16530
                                            '</tpl>'),
16531
                                        editor: {
16532
                                            allowBlank: null_,
16533
                                            xtype: 'combobox',
16534
                                            readOnly: ReadOnly_,
16535
                                            id: rec.TableName + rec.FieldName,
16536
                                            nameTable: rec.TableName,
16537
                                            fieldGrid: rec.FieldName,
16538
                                            valueField: valueField,
16539
                                            displayField: displayValue,
16540
                                            store: 'store_' + me.tableName + rec.FieldName,
16541
                                            value: rec.DefaultValue,
16542
                                            tpl: Ext.create('Ext.XTemplate',
16543
                                                '<ul class="x-list-plain"><tpl for=".">',
16544
                                                '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
16545
                                                '</tpl></ul>'),
16546
                                            displayTpl: Ext.create('Ext.XTemplate',
16547
                                                '<tpl for=".">',
16548
                                                '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
16549
                                                '</tpl>')
16550
                                        },
16551
                                        renderer: function (value) {
16552
                                            var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
16553
                                            var index = store.find(valueField, value);
16554
                                            var val = "";
16555
                                            if (index != -1) {
16556
                                                var rc = store.getAt(index);
16557
                                                //val = rc.get(displayValue);
16558
                                                val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
16559
                                            } else {
16560
                                                val = value;
16561
                                            }
16562
                                            return val;
16563
                                        },
16564
                                        filter: {
16565
                                            type: 'list',
16566
                                            itemDefaults: {
16567
                                                emptyText: 'Search for...'
16568
                                            }
16569
                                        }
16570
                                    });
16571
                                } else if (rec.SearchType == '2') {
16572
                                    var triger = (rec.TriggerCombo).split('$');
16573
                                    var targetField_ = triger[0];
16574
                                    var fieldValue_ = triger[1];
16575
                                    cols.push({
16576
                                        text: rec.HeaderTitle,
16577
                                        hidden: Hidden_,
16578
                                        dataIndex: rec.FieldName,
16579
                                        filter: {
16580
                                            itemDefaults: {
16581
                                                emptyText: 'Search for...'
16582
                                            }
16583
                                        },
16584
                                        editor: {
16585
                                            allowBlank: null_,
16586
                                            xtype: 'minovalookupgrid',
16587
                                            readOnly: ReadOnly_,
16588
                                            isGrid: true,
16589
                                            fieldTarget: targetField_,
16590
                                            fieldValue: fieldValue_,
16591
                                            isGrid: true,
16592
                                            id: tableName + rec.FieldName,
16593
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
16594
                                            triggerCls: 'x-form-search-trigger',
16595
                                            vtype: 'alphanum', // disable space
16596
                                            nameTable: rec.TableName,
16597
                                            fieldGrid: rec.FieldName,
16598
                                            listeners: {
16599
                                                change: function (val) {
16600
                                                    var custumFunc = rec.SelectFunction;
16601
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
16602
                                                        Ext.Ajax.request({
16603
                                                            async: false,
16604
                                                            method: 'POST',
16605
                                                            url: '/UserControl/GetStore',
16606
                                                            params: {
16607
                                                                tableName: 'PCMFUNC',
16608
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
16609
                                                            },
16610
                                                            success: function (response) {
16611
                                                                var results = Ext.decode(response.responseText);
16612
                                                                data_ = results.data[0];
16613
                                                                if (data_ != undefined) {
16614
                                                                    custumFunc = data_.FunctionCode;
16615
                                                                }
16616
                                                            }
16617
                                                        });
16618
                                                    }
16619
                                                    if (custumFunc) {
16620
                                                        eval(custumFunc)
16621
                                                    }
16622
                                                }
16623
                                            }
16624
                                        }
16625
                                    });
16626
                                } else if (rec.SearchType == '3') {
16627
                                    cols.push({
16628
                                        text: rec.HeaderTitle,
16629
                                        hidden: Hidden_,
16630
                                        dataIndex: rec.FieldName,
16631
                                        filter: {
16632
                                            itemDefaults: {
16633
                                                emptyText: 'Search for...'
16634
                                            }
16635
                                        },
16636
                                        editor: {
16637
                                            allowBlank: null_,
16638
                                            // xtype: 'minovalookuptreePopup',
16639
                                            xtype: 'MinovaLookupTree',
16640
                                            readOnly: ReadOnly_,
16641
                                            id: tableName + rec.FieldName,
16642
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
16643
                                            triggerCls: 'x-form-search-trigger',
16644
                                            vtype: 'alphanum', // disable space
16645
                                            treeSructure: rec.SearchFunction, //'O-O-P',
16646
                                            objClassValue: rec.ParamCombo, //'O',
16647
                                            nameTable: rec.TableName,
16648
                                            fieldGrid: rec.FieldName,
16649
                                            listeners: {
16650
                                                change: function (val) {
16651
                                                    var custumFunc = rec.SelectFunction;
16652
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
16653
                                                        Ext.Ajax.request({
16654
                                                            async: false,
16655
                                                            method: 'POST',
16656
                                                            url: '/UserControl/GetStore',
16657
                                                            params: {
16658
                                                                tableName: 'PCMFUNC',
16659
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
16660
                                                            },
16661
                                                            success: function (response) {
16662
                                                                var results = Ext.decode(response.responseText);
16663
                                                                data_ = results.data[0];
16664
                                                                if (data_ != undefined) {
16665
                                                                    custumFunc = data_.FunctionCode;
16666
                                                                }
16667
                                                            }
16668
                                                        });
16669
                                                    }
16670
                                                    if (custumFunc) {
16671
                                                        eval(custumFunc)
16672
                                                    }
16673
                                                }
16674
                                            }
16675
                                        }
16676
                                    });
16677
                                } 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) {
16678
                                    var triger = (rec.TriggerCombo).split('&');
16679
                                    var targetField_ = triger[0];
16680
                                    var fieldValue_ = triger[0];
16681
                                    cols.push({
16682
                                        text: rec.HeaderTitle,
16683
                                        hidden: Hidden_,
16684
                                        dataIndex: rec.FieldName,
16685
                                        filter: {
16686
                                            itemDefaults: {
16687
                                                emptyText: 'Search for...'
16688
                                            }
16689
                                        },
16690
                                        editor: {
16691
                                            allowBlank: null_,
16692
                                            xtype: 'lookupemployee',
16693
                                            readOnly: ReadOnly_,
16694
                                            isGrid: true,
16695
                                            fieldTarget: targetField_,
16696
                                            fieldValue: fieldValue_,
16697
                                            isGrid: true,
16698
                                            id: tableName + rec.FieldName,
16699
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
16700
                                            triggerCls: 'x-form-search-trigger',
16701
                                            vtype: 'alphanum', // disable space
16702
                                            nameTable: rec.TableName,
16703
                                            fieldGrid: rec.FieldName,
16704
                                            listeners: {
16705
                                                change: function (val) {
16706
                                                    var custumFunc = rec.SelectFunction;
16707
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
16708
                                                        Ext.Ajax.request({
16709
                                                            async: false,
16710
                                                            method: 'POST',
16711
                                                            url: '/UserControl/GetStore',
16712
                                                            params: {
16713
                                                                tableName: 'PCMFUNC',
16714
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
16715
                                                            },
16716
                                                            success: function (response) {
16717
                                                                var results = Ext.decode(response.responseText);
16718
                                                                data_ = results.data[0];
16719
                                                                if (data_ != undefined) {
16720
                                                                    custumFunc = data_.FunctionCode;
16721
                                                                }
16722
                                                            }
16723
                                                        });
16724
                                                    }
16725
                                                    if (custumFunc) {
16726
                                                        eval(custumFunc)
16727
                                                    }
16728
                                                }
16729
                                            }
16730
                                        }
16731
                                    });
16732
                                } else if (rec.SearchType == '4' && isLookup != true) {
16733
                                    cols.push({
16734

    
16735
                                        text: rec.HeaderTitle,
16736
                                        hidden: Hidden_,
16737
                                        dataIndex: rec.FieldName,
16738
                                        filter: {
16739
                                            itemDefaults: {
16740
                                                emptyText: 'Search for...'
16741
                                            }
16742
                                        },
16743
                                        editor: {
16744
                                            allowBlank: null_,
16745
                                            xtype: 'lookupemployee',
16746
                                            readOnly: ReadOnly_,
16747
                                            isGrid: true,
16748
                                            fieldTarget: targetField_,
16749
                                            fieldValue: fieldValue_,
16750
                                            isGrid: true,
16751
                                            id: tableName + rec.FieldName,
16752
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
16753
                                            triggerCls: 'x-form-search-trigger',
16754
                                            vtype: 'alphanum', // disable space
16755
                                            nameTable: rec.TableName,
16756
                                            fieldGrid: rec.FieldName,
16757
                                            listeners: {
16758
                                                change: function (val) {
16759
                                                    var custumFunc = rec.SelectFunction;
16760
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
16761
                                                        Ext.Ajax.request({
16762
                                                            async: false,
16763
                                                            method: 'POST',
16764
                                                            url: '/UserControl/GetStore',
16765
                                                            params: {
16766
                                                                tableName: 'PCMFUNC',
16767
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
16768
                                                            },
16769
                                                            success: function (response) {
16770
                                                                var results = Ext.decode(response.responseText);
16771
                                                                data_ = results.data[0];
16772
                                                                if (data_ != undefined) {
16773
                                                                    custumFunc = data_.FunctionCode;
16774
                                                                }
16775
                                                            }
16776
                                                        });
16777
                                                    }
16778
                                                    if (custumFunc) {
16779
                                                        eval(custumFunc)
16780
                                                    }
16781
                                                }
16782
                                            }
16783
                                        }
16784
                                    });
16785
                                } else {
16786
                                    cols.push({
16787
                                        text: rec.HeaderTitle,
16788
                                        hidden: Hidden_,
16789
                                        dataIndex: rec.FieldName,
16790
                                        filter: {
16791
                                            itemDefaults: {
16792
                                                emptyText: 'Search for...'
16793
                                            }
16794
                                        },
16795
                                        editor: {
16796
                                            allowBlank: null_,
16797
                                            xtype: 'textfield',
16798
                                            readOnly: ReadOnly_,
16799
                                            id: tableName + rec.FieldName,
16800
                                            nameTable: rec.TableName,
16801
                                            fieldGrid: rec.FieldName,
16802
                                            listeners: {
16803
                                                change: function (val) {
16804
                                                    var custumFunc = null;
16805
                                                    Ext.Ajax.request({
16806
                                                        async: false,
16807
                                                        method: 'POST',
16808
                                                        url: '/UserControl/GetStore',
16809
                                                        params: {
16810
                                                            tableName: 'SDATATABLEFIELD',
16811
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
16812
                                                        },
16813
                                                        success: function (response) {
16814
                                                            var results = Ext.decode(response.responseText);
16815
                                                            data_ = results.data[0];
16816
                                                            if (data_ != undefined) {
16817
                                                                custumFunc = data_.SelectFunction;
16818
                                                                //console.log(data_)
16819
                                                            }
16820
                                                        }
16821
                                                    });
16822
                                                    if (custumFunc) {
16823
                                                        eval(custumFunc)
16824
                                                    }
16825
                                                }
16826
                                            }
16827
                                        }
16828
                                    });
16829
                                }
16830
                                break
16831
                        }
16832
                    }
16833
                } else {
16834
                    cols.push({
16835
                        text: rec.HeaderTitle,
16836
                        hidden: Hidden_,
16837
                        dataIndex: rec.FieldName,
16838
                        hidden: true,
16839
                        editor: {
16840
                            allowBlank: true,
16841
                            xtype: 'textfield',
16842
                            readOnly: ReadOnly_,
16843
                            id: tableName + rec.FieldName,
16844
                            nameTable: rec.TableName,
16845
                            fieldGrid: rec.FieldName,
16846
                        },
16847
                        filter: {
16848
                            itemDefaults: {
16849
                                emptyText: 'Search for...'
16850
                            }
16851
                        }
16852
                    });
16853
                }
16854
            })
16855
        }
16856
        addData = addData + "}";
16857

    
16858
        cols.push({
16859
            text: 'Action',
16860
            width: 100,
16861
            xtype: 'actioncolumn',
16862
            tooltip: 'View Data',
16863
            name: 'Action',
16864
            itemId: 'Action',
16865
            align: 'center',
16866
            iconCls: 'fa-edit',
16867
            renderer: function (value, metadata, record) {
16868
                metadata.tdStyle = 'font-family: FontAwesome'
16869
            },
16870
            handler: function (grid, rowIndex, colIndex, actionItem, event, record, row) {
16871
                var main_ = Ext.ComponentQuery.query('[name=grid' + me.tableName + ']')[0];
16872
                this.fireEvent("onEditClick");
16873
            }
16874
        });
16875

    
16876
        Ext.applyIf(me, {
16877

    
16878
            items: [{
16879
                xtype: 'treepanel',
16880
                id: gridName,
16881
                name: gridName,
16882
                height: height,
16883
                width: 'fit',
16884
                autoHeight: true,
16885
                //store: 'gridStore',
16886
                autoLoad: false,
16887
                autoScroll: true,
16888
                useArrows: true,
16889
                animate: false,
16890
                rootVisible: false,
16891
                plugins: [
16892
                    Ext.create('Ext.grid.plugin.CellEditing', {
16893
                        clicksToEdit: 2
16894
                    })
16895
                ],
16896
                root: {
16897
                    expanded: true,
16898
                    nodeType: 'async',
16899
                    ext: 'Favorites',
16900
                    id: 'null'
16901
                },
16902
                columns: cols,
16903
                //selType: 'rowmodel',
16904
            }
16905
            ]
16906

    
16907
        });
16908

    
16909
        me.callParent(arguments);
16910
    }
16911
});
16912
/*Add by Taufan ( Tab List MasterData For ERP )*/
16913
Ext.define('MinovaUtil.MinovaES.MinovaTabListMasterData', {
16914
    extend: 'Ext.tab.Panel',
16915
    alias: ['widget.masterdatatablist'],
16916
    moduleType: undefined,
16917
    tablenameheader: undefined,
16918
    langId: undefined,
16919
    param: undefined,
16920
    layout: 'fit',
16921
    name: 'panelTab',
16922
    id: 'mainTab',    
16923
    initComponent: function () {
16924
        var me = this;
16925
        var hasil = null;
16926
        var action = "0";
16927
        var _items = [];
16928
        var act = getParam("action");
16929
        if (act == 'add') {
16930
            action = '0';
16931
        }
16932
        if (act == 'edit') {
16933
            action = '1';
16934
        }
16935
        if (act == 'view') {
16936
            action = '1';
16937
        }
16938
        if (act == 'copy') {
16939
            action = '0';
16940
        }
16941
        Ext.Ajax.request({
16942
            async: false,
16943
            method: 'POST',
16944
            url: '/UserControl/GetStore',
16945
            params: {
16946
                tableName: 'PCMEPMDLIST',
16947
                param: 'ModuleType[=]' + me.moduleType + ',Language[=]' + me.langId
16948
            },
16949
            success: function (response) {
16950
                var results = Ext.decode(response.responseText);
16951
                hasil = results.data;                
16952
            }
16953
        });
16954
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
16955
        if (hasil.length > 0) {
16956
            Ext.each(hasil, function (rec) {
16957
                if (rec.LayoutType == "L004") { // L004=Custom
16958
                    var pnl = Ext.create(rec.CustomLayout, {
16959
                        title: rec.LabelName,
16960
                        tableName: rec.TableName,
16961
                        height: 450,
16962
                        name: 'panelTab' + rec.TableName,
16963
                        tbl: rec.TableName,
16964
                        layoutType: rec.LayoutType
16965
                    });
16966
                    _items.push(pnl)
16967
                } else if (rec.LayoutType == "L002" || rec.LayoutType == "L003") {
16968
                    _items.push({
16969
                        xtype: 'panel',
16970
                        title: rec.LabelName,
16971
                        name: 'panelTab' + rec.TableName,
16972
                        tbl: rec.TableName,
16973
                        layoutType: rec.LayoutType,
16974
                        items: [{
16975
                            xtype: 'minovagrid1',
16976
                            height: 450,
16977
                            tableName: rec.TableName,
16978
                            storename: 'store' + rec.TableName,
16979
                            pagesize: 25,
16980
                            name: 'GRID' + rec.TableName,
16981
                            margin: '0 0 10 0',
16982
                            autoLoad: false,
16983
                            tbar: [{
16984
                                xtype: 'button',
16985
                                text: 'Action',
16986
                                name: 'actionGrid' + rec.TableName,
16987
                                menu: [{
16988
                                    text: 'Add',
16989
                                    name: 'add' + rec.TableName,
16990
                                    tbl: rec.TableName,
16991
                                    style: 'font-family: FontAwesome',
16992
                                    iconCls: 'fa-plus-circle',
16993
                                    handler: function () {
16994
                                        var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16995
                                        var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16996
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16997
                                        var keyField = getParam("KeyID");
16998
                                        var keyValue = getParam("KeyValue");
16999
                                        frmDisplay.reset();
17000
                                        frmForm.reset();
17001
                                        var idseq = 0;
17002
										if (keyValue=='null'){
17003
											keyValue=Ext.ComponentQuery.query('MinovaHeadermdLogistic')[0].items.items[0].items.items[0].value;
17004
										}											
17005
                                        var params = {
17006
                                            apiController: 'api/Devt',
17007
                                            methodName: 'GetLastSeqID',
17008
                                            parameter: 'tableName=' + rec.TableName + '&keyField=' + keyField + '&keyValue=' + keyValue
17009
                                        };
17010
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17011
                                            var result = Ext.decode(xhr.responseText);
17012
                                            var r = Ext.decode(result.data);
17013
                                            idseq = r.data + 1;
17014
                                            frmForm.getForm().findField(keyField).setValue(keyValue);
17015
                                            frmForm.getForm().findField("SeqID").setValue(idseq);
17016
                                        });
17017
                                        frmDisplay.setHidden(true);
17018
                                        frmForm.setHidden(false);
17019
                                        grdPanel.setHidden(true);
17020
                                        action = "0";
17021
                                    }
17022
                                }, {
17023
                                    text: 'Copy',
17024
                                    name: 'copy' + rec.TableName,
17025
                                    tbl: rec.TableName,
17026
                                    iconCls: 'fa-copy',
17027
                                    style: 'font-family: FontAwesome',
17028
                                    handler: function () {
17029
                                        var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17030
                                        var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17031
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17032
                                        var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
17033
                                        var keyField = getParam("KeyID");
17034
                                        if (dtrec) {
17035
                                            frmDisplay.reset();
17036
                                            frmForm.reset();
17037
                                            frmForm.getForm().setValues(dtrec.data);
17038
                                            frmDisplay.setHidden(true);
17039
                                            frmForm.setHidden(false);
17040
                                            grdPanel.setHidden(true);
17041
                                            action = "0";
17042
                                            frmForm.getForm().findField(keyField).setValue("");
17043
                                        }
17044
                                    }
17045
                                }, {
17046
                                    text: 'Edit',
17047
                                    name: 'edit' + rec.TableName,
17048
                                    tbl: rec.TableName,
17049
                                    iconCls: 'fa-edit',
17050
                                    style: 'font-family: FontAwesome',
17051
                                    handler: function () {
17052
                                        var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17053
                                        var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17054
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17055
                                        var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
17056
                                        if (dtrec) {
17057
                                            frmDisplay.reset();
17058
                                            frmForm.reset();
17059
                                            frmForm.getForm().setValues(dtrec.data);
17060
                                            frmDisplay.setHidden(true);
17061
                                            frmForm.setHidden(false);
17062
                                            grdPanel.setHidden(true);
17063
                                            me.action = "1";
17064
                                        }
17065
                                    }
17066
                                }
17067
                                ]
17068
                            }, {
17069
                                xtype: 'tbfill'
17070
                            }, {
17071
                                text: 'Clear Filters',
17072
                                tooltip: 'Clear all filters',
17073
                                name: 'clearbtn',
17074
                                handler: function () {}
17075
                            }
17076
                            ],
17077
                            dockedItems: [{
17078
                                xtype: 'pagingtoolbar',
17079
                                store: 'store' + rec.TableName,
17080
                                dock: 'bottom',
17081
                                pageSize: me.pagesize,
17082
                                displayInfo: true
17083
                            }
17084
                            ],
17085
                            listeners: {
17086
                                'itemdblclick': function (me, record, item, index, e, eOpts) {
17087
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17088
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17089
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17090
                                    frmDisplay.reset();
17091
                                    frmForm.reset();
17092
                                    frmDisplay.getForm().setValues(record.data);
17093
                                    frmForm.getForm().setValues(record.data);
17094
                                    frmDisplay.setHidden(false);
17095
                                    frmForm.setHidden(true);
17096
                                    grdPanel.setHidden(true);
17097
                                    me.action = "1";
17098
                                }
17099
                            }
17100
                        }, {
17101
                            xtype: 'minovaform',
17102
                            name: 'DISPLAY' + rec.TableName,
17103
                            id: 'DISPLAY' + rec.TableName,
17104
                            itemId: 'DISPLAY' + rec.TableName,
17105
                            tableName: rec.TableName,
17106
                            isDisplay: true,
17107
                            hidden: true,
17108
                            buttons: [{
17109
                                text: 'Edit',
17110
                                name: 'editDISPLAY' + rec.TableName,
17111
                                iconCls: 'fa-edit',
17112
                                style: 'font-family: FontAwesome',
17113
                                handler: function () {
17114
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17115
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17116
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17117
                                    frmDisplay.setHidden(true);
17118
                                    frmForm.setHidden(false);
17119
                                    grdPanel.setHidden(true);
17120
                                }
17121
                            }, {
17122
                                text: 'Cancel',
17123
                                name: 'cancelDISPLAY' + rec.TableName,
17124
                                iconCls: 'fa-reply',
17125
                                style: 'font-family: FontAwesome',
17126
                                handler: function () {
17127
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17128
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17129
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17130
                                    frmDisplay.setHidden(true);
17131
                                    frmForm.setHidden(true);
17132
                                    grdPanel.setHidden(false);
17133
                                    grdPanel.getStore().reload();
17134
                                }
17135
                            }
17136
                            ]
17137
                        }, {
17138
                            xtype: 'minovaform',
17139
                            name: 'FORM' + rec.TableName,
17140
                            id: 'FORM' + rec.TableName,
17141
                            itemId: 'FORM' + rec.TableName,
17142
                            tableName: rec.TableName,
17143
                            isDisplay: false,
17144
                            hidden: true,
17145
                            buttons: [{
17146
                                text: 'Save',
17147
                                name: 'saveFORM' + rec.TableName,
17148
                                iconCls: 'fa-save',
17149
                                style: 'font-family: FontAwesome',
17150
                                handler: function () {
17151
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17152
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17153
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17154
                                    var frm = frmForm.getForm();
17155
                                    console.log(frmForm);
17156
                                    if (frm.isValid()) {
17157
                                        var keyField = getParam("KeyID");
17158
                                        var table = rec.TableName;
17159
                                        var data = Ext.encode(frmForm.getValues());
17160
                                        var token = MinovaUtil.SESSIONS.Token;
17161
                                        var params = {
17162
                                            apiController: 'api/Devt',
17163
                                            methodName: 'SaveTableMaster',
17164
                                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17165
                                        };
17166
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17167
                                            var result = Ext.decode(xhr.responseText);
17168
                                            var r = Ext.decode(result.data);
17169
                                            if (r.success) {
17170
                                                frmDisplay.setHidden(true);
17171
                                                frmForm.setHidden(true);
17172
                                                grdPanel.setHidden(false);
17173
                                                grdPanel.getStore().reload();
17174
                                                MinovaMessage('Not Null', '000006', '', 'S');
17175
                                            } else {
17176
                                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17177
                                            }
17178
                                        });
17179
                                    }
17180
                                }
17181
                            }, {
17182
                                text: 'Delete',
17183
                                name: 'deleteFORM' + rec.TableName,
17184
                                iconCls: 'fa-trash-o',
17185
                                style: 'font-family: FontAwesome ',                                
17186
                                handler: function () {
17187
                                    alert('Delete Function');
17188
                                    MinovaMessage(' Message ', ' 000007 ', ' ', 'C', function (respone) {
17189
                                        if (respone == "yes") {
17190
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17191
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17192
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17193
                                            var frm = frmForm.getForm();
17194
                                            if (frm.isValid()) {
17195
                                                var keyField = getParam("KeyID");
17196
                                                var table = rec.TableName;
17197
                                                var data = Ext.encode(frmForm.getValues());
17198
                                                var token = MinovaUtil.SESSIONS.Token;
17199
                                                action = "2";
17200
                                                var params = {
17201
                                                    apiController: 'api/Devt',
17202
                                                    methodName: 'SaveTableMaster',
17203
                                                    parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17204
                                                };
17205
                                                MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17206
                                                    var result = Ext.decode(xhr.responseText);
17207
                                                    var r = Ext.decode(result.data);
17208
                                                    if (r.success) {
17209
                                                        frmDisplay.setHidden(true);
17210
                                                        frmForm.setHidden(true);
17211
                                                        grdPanel.setHidden(false);
17212
                                                        grdPanel.getStore().reload();
17213
                                                        MinovaMessage('Not Null', '000006', '', 'S');
17214
                                                    } else {
17215
                                                        MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17216
                                                    }
17217
                                                });
17218
                                            }
17219
                                        }
17220
                                    });
17221
                                }
17222
                            }, {
17223
                                text: 'Cancel',
17224
                                name: 'cancelFORM' + rec.TableName,
17225
                                iconCls: 'fa-reply',
17226
                                style: 'font-family: FontAwesome',
17227
                                handler: function () {
17228
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
17229
                                        if (respone == "yes") {
17230
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17231
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17232
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17233
                                            frmDisplay.setHidden(true);
17234
                                            frmForm.setHidden(true);
17235
                                            grdPanel.setHidden(false);
17236
                                            grdPanel.getStore().reload();
17237
                                        }
17238
                                    });
17239
                                }
17240
                            }
17241
                            ]
17242
                        }
17243
                        ]
17244
                    });
17245
                } else if (rec.LayoutType == "L005") { // Grid View Only
17246
                    _items.push({
17247
                        xtype: 'panel',
17248
                        title: rec.LabelName,
17249
                        name: 'panelTab' + rec.TableName,
17250
                        tbl: rec.TableName,
17251
                        layoutType: rec.LayoutType,
17252
                        items: [{
17253
                            xtype: 'minovagrid1',
17254
                            height: 450,
17255
                            tableName: rec.TableName,
17256
                            storename: 'store' + rec.TableName,
17257
                            pagesize: 25,
17258
                            name: 'GRID' + rec.TableName,
17259
                            margin: '0 0 10 0',
17260
                            autoLoad: false,
17261
                            tbar: [{
17262
                                xtype: 'tbfill'
17263
                            }, {
17264
                                text: 'Clear Filters',
17265
                                tooltip: 'Clear all filters',
17266
                                name: 'clearbtn',
17267
                                handler: function () {}
17268
                            }
17269
                            ],
17270
                            dockedItems: [{
17271
                                xtype: 'pagingtoolbar',
17272
                                store: 'store' + rec.TableName,
17273
                                dock: 'bottom',
17274
                                pageSize: me.pagesize,
17275
                                displayInfo: true
17276
                            }
17277
                            ]
17278
                        }
17279
                        ]
17280
                    });
17281
                } else { // L001=Default Form Only
17282
				//saswanto 25MEI2022  BARCODE AND QRCODE START
17283
				var tbblename =rec.TableName;
17284
					if (tbblename == "PMDAST0002"){
17285
                    _items.push({
17286
                        xtype: 'panel',
17287
                        title: rec.LabelName,
17288
                        name: 'panelTab' + rec.TableName,
17289
                        tbl: rec.TableName,
17290
                        layoutType: rec.LayoutType,
17291
                        items: [{
17292
                            xtype: 'minovaform',
17293
                            name: 'DISPLAY' + rec.TableName,
17294
                            id: 'DISPLAY' + rec.TableName,
17295
                            itemId: 'DISPLAY' + rec.TableName,
17296
                            tableName: rec.TableName,
17297
                            isDisplay: true,
17298
                            hidden: false,
17299
                            buttons: [{
17300
                                text: 'Create QR Code',
17301
                                name: 'editDISPLAY' + rec.TableName,
17302
                                iconCls: 'fa-edit',
17303
                                style: 'font-family: FontAwesome',
17304
                                handler: function () {
17305
									var myfrmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17306
									var asetid=myfrmForm.getValues().AssetID;
17307
									var asetdesc=myfrmForm.getValues().AssetName;	
17308
									var ExternalID=myfrmForm.getValues().ExternalID;									
17309
									Ext.widget('window', {
17310
										width: 600,
17311
										height: 600,
17312
										padding: 5,
17313
										title: 'QR Code Perview',
17314
										html: '<div id="BarCodePrint" style=" display: block;text-align: center;margin-left: auto;margin-right: auto;">'+
17315
										'<p>'+ asetdesc +'</p>'+									
17316
										'<div id="qrcode" style=" display: block;text-align: center;margin-left: auto;margin-right: auto;"></div>'+
17317

    
17318
												'<div style="padding: 10px;  width: 15%; display: inline-block;">Location</div>'+
17319
												'<div style="padding: 5px;  width: 25%; display: inline-block;">: Jakarta</div>'+
17320
												'<div style="padding: 10px;  width: 15%; display: inline-block;">Divition</div>'+
17321
												'<div style="padding: 5px;  width: 25%; display: inline-block;">: Developer</div><br>'+	
17322
												
17323
												'<div style="padding: 10px;  width: 15%; display: inline-block;">Location</div>'+
17324
												'<div style="padding: 5px;  width: 25%; display: inline-block;">: Jakarta</div>'+
17325
												'<div style="padding: 10px;  width: 15%; display: inline-block;">Divition</div>'+
17326
												'<div style="padding: 5px;  width: 25%; display: inline-block;">: Developer</div>'+		
17327
												'</div>'+												
17328
											  '<div><p><input type="button" id="bt" onclick="printDiv()" value="Print PDF" style=" position: fixed; left: 0; bottom: 0; width: 100%; background-color: #3487c3; color: white; text-align: center; "/></p>'+	
17329
											  '</div>'
17330
									}).show();
17331

    
17332
								  const qrcode = document.getElementById("qrcode");
17333
								  const textInput = document.getElementById(ExternalID);
17334
								  
17335
								  const qr = new QRCode(qrcode);
17336
								  qr.makeCode(ExternalID);
17337
								  
17338
								}
17339
                            },{
17340
                                text: 'Create Barcode',
17341
                                name: 'editDISPLAY' + rec.TableName,
17342
                                iconCls: 'fa-edit',
17343
                                style: 'font-family: FontAwesome',
17344
                                handler: function () {
17345
									var myfrmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17346
									var asetid=myfrmForm.getValues().AssetID;
17347
									var asetdesc=myfrmForm.getValues().AssetName;
17348
									var ExternalID=myfrmForm.getValues().ExternalID;									
17349
									Ext.widget('window', {
17350
										width: 600,
17351
										height: 600,
17352
										padding: 5,
17353
										title: 'Barcode Perview',
17354
										html: '<div id="BarCodePrint" style="text-align: center;">'+
17355
										'<div id="BarCode" style="width:590px;align-items: center; justify-content: center;display: flex;">'+
17356
											  '<img id="barcode3" class="Center">'+
17357
											  '</img></div>'+
17358
												'<div style="padding: 10px;  width: 15%; display: inline-block;">Location</div>'+
17359
												'<div style="padding: 5px;  width: 25%; display: inline-block;">: Jakarta</div>'+
17360
												'<div style="padding: 10px;  width: 15%; display: inline-block;">Divition</div>'+
17361
												'<div style="padding: 5px;  width: 25%; display: inline-block;">: Developer</div><br>'+	
17362
												
17363
												'<div style="padding: 10px;  width: 15%; display: inline-block;">Location</div>'+
17364
												'<div style="padding: 5px;  width: 25%; display: inline-block;">: Jakarta</div>'+
17365
												'<div style="padding: 10px;  width: 15%; display: inline-block;">Divition</div>'+
17366
												'<div style="padding: 5px;  width: 25%; display: inline-block;">: Developer</div>'+		
17367
												'</div>'+												
17368
											  '<div><p><input type="button" id="bt" onclick="printDiv()" value="Print PDF" style=" position: fixed; left: 0; bottom: 0; width: 100%; background-color: #3487c3; color: white; text-align: center; "/></p>'+	
17369
											  '</div>'
17370
									}).show();
17371

    
17372
								JsBarcode("#barcode3",ExternalID, {
17373
								  textAlign: "Center",
17374
								  textPosition: "top",
17375
								  font: "FontAwesome",
17376
								  fontOptions: "",
17377
								  fontSize: 20,
17378
								  textMargin: 5,
17379
								  text: asetdesc});
17380
                                }
17381
                            },{
17382
                                text: 'Edit',
17383
                                name: 'editDISPLAY' + rec.TableName,
17384
                                iconCls: 'fa-edit',
17385
                                style: 'font-family: FontAwesome',
17386
                                handler: function () {
17387
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17388
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17389
                                    frmDisplay.setHidden(true);
17390
                                    frmForm.setHidden(false);
17391
                                    me.action = "1";
17392
                                }
17393
                            }, {
17394
                                text: 'Back',
17395
                                name: 'cancelDISPLAY' + rec.TableName,
17396
                                iconCls: 'fa-reply',
17397
                                style: 'font-family: FontAwesome',
17398
								handler: function () {
17399
									window.history.back();
17400
								},
17401
								hidden: false
17402
                            }
17403
                            ]
17404
                        }, {
17405
                            xtype: 'minovaform',
17406
                            name: 'FORM' + rec.TableName,
17407
                            id: 'FORM' + rec.TableName,
17408
                            itemId: 'FORM' + rec.TableName,
17409
                            tableName: rec.TableName,
17410
                            isDisplay: false,
17411
                            hidden: true,
17412
                            buttons: [{
17413
                                text: 'Save',
17414
                                name: 'saveDISPLAY' + rec.TableName,
17415
                                iconCls: 'fa-save',
17416
                                style: 'font-family: FontAwesome',
17417
                                handler: function () {
17418
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17419
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17420

    
17421
									 var headerDisplay =undefined;
17422
									if(rec.TableName=="PTRPRODUCTIONHEAD"){
17423
										headerDisplay=Ext.ComponentQuery.query('[name=MainHeaderDocument]')[0];
17424
										frmForm.getForm().findField("DocNo").setValue(headerDisplay.getForm().findField("DocNo").getValue());
17425
										frmForm.getForm().findField("DocType").setValue(headerDisplay.getForm().findField("DocType").getValue());
17426
										frmForm.getForm().findField("ProcessID").setValue(headerDisplay.getForm().findField("ProcessID").getValue());
17427
										frmForm.getForm().findField("DocDate").setValue(headerDisplay.getForm().findField("DocDate").getValue());
17428
										frmForm.getForm().findField("DocStatus").setValue(headerDisplay.getForm().findField("DocStatus").getValue());
17429
										frmForm.getForm().findField("OrderDate").setValue(headerDisplay.getForm().findField("OrderDate").getValue());
17430
										frmForm.getForm().findField("Description").setValue(headerDisplay.getForm().findField("Description").getValue());
17431
										frmForm.getForm().findField("FinishGoods").setValue(headerDisplay.getForm().findField("FinishGoods").getValue());											
17432
									}else{
17433
										headerDisplay=Ext.ComponentQuery.query('[name=MainHeaderMDLogistic]')[0];	
17434
									}
17435

    
17436
                                    var frm = frmForm.getForm();
17437
                                    if (frm.isValid()) {
17438
                                                
17439
										
17440
                                        var keyField = getParam("KeyID");
17441
                                        var table = rec.TableName;
17442
                                        var data = Ext.encode(frmForm.getValues());
17443
                                        var token = MinovaUtil.SESSIONS.Token;
17444
										var action=me.action;
17445
										if(action==undefined){action="0"};
17446
                                        var params = {
17447
                                            apiController: 'api/Devt',
17448
                                            methodName: 'SaveTableMaster',
17449
                                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17450
                                        };
17451
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17452
                                            var result = Ext.decode(xhr.responseText);
17453
                                            var r = Ext.decode(result.data);
17454
                                            if (r.success) {
17455
                                                headerDisplay.mask("Loading...");
17456
                                                var idNo = r.data;
17457
                                                frmForm.getForm().findField(keyField).setValue(idNo);
17458
												frmDisplay.getForm().setValues(frmForm.getValues());
17459
                                                headerDisplay.getForm().setValues(frmForm.getValues());
17460
                                                frmDisplay.setHidden(false);
17461
                                                frmForm.setHidden(true);
17462
                                                MinovaMessage('Not Null', '000006', '', 'S');
17463
                                                headerDisplay.unmask();
17464
                                            } else {
17465
                                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17466
                                            }
17467
                                        });
17468
                                    }
17469
                                }
17470
                            }, {
17471
                                text: 'Delete',
17472
                                name: 'deleteDISPLAY' + rec.TableName,
17473
                                iconCls: 'fa-trash-o',
17474
                                style: 'font-family: FontAwesome',
17475
                                handler: function () {                                    
17476
                                    MinovaMessage(' Message ', ' 000007 ', ' ', 'C', function (respone) {
17477
                                        if (respone == "yes") {
17478
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17479
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17480
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17481
                                            var frm = frmForm.getForm();
17482
                                            if (frm.isValid()) {
17483
                                                var keyField = getParam("KeyID");
17484
                                                var table = rec.TableName;
17485
                                                var data = Ext.encode(frmForm.getValues());
17486
                                                var token = MinovaUtil.SESSIONS.Token;
17487
                                                action = "2";
17488
                                                var params = {
17489
                                                    apiController: 'api/Devt',
17490
                                                    methodName: 'SaveTableMaster',
17491
                                                    parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17492
                                                };
17493
                                                MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17494
                                                    var result = Ext.decode(xhr.responseText);
17495
                                                    var r = Ext.decode(result.data);
17496
                                                    if (r.success) {
17497
                                                        frmDisplay.setHidden(true);
17498
                                                        frmForm.setHidden(true);
17499
                                                        grdPanel.setHidden(false);
17500
                                                        grdPanel.getStore().reload();
17501
                                                        MinovaMessage('Not Null', '000006', '', 'S');
17502
                                                    } else {
17503
                                                        MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17504
                                                    }
17505
                                                });
17506
                                            }
17507
                                        }
17508
                                    });
17509
                                }
17510
                            }, {
17511
                                text: 'Cancel',
17512
                                name: 'cancelDISPLAY' + rec.TableName,
17513
                                iconCls: 'fa-reply',
17514
                                style: 'font-family: FontAwesome',
17515
                                handler: function () {
17516
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
17517
                                        if (respone == "yes") {
17518
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17519
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17520
                                            frmDisplay.setHidden(false);
17521
                                            frmForm.setHidden(true);
17522
                                        }
17523
                                    });
17524
                                }
17525
                            }
17526
                            ]
17527
                        }
17528
                        ]
17529
                    });					
17530
					}else{
17531
                    _items.push({
17532
                        xtype: 'panel',
17533
                        title: rec.LabelName,
17534
                        name: 'panelTab' + rec.TableName,
17535
                        tbl: rec.TableName,
17536
                        layoutType: rec.LayoutType,
17537
                        items: [{
17538
                            xtype: 'minovaform',
17539
                            name: 'DISPLAY' + rec.TableName,
17540
                            id: 'DISPLAY' + rec.TableName,
17541
                            itemId: 'DISPLAY' + rec.TableName,
17542
                            tableName: rec.TableName,
17543
                            isDisplay: true,
17544
                            hidden: false,
17545
                            buttons: [{
17546
                                text: 'Edit',
17547
                                name: 'editDISPLAY' + rec.TableName,
17548
                                iconCls: 'fa-edit',
17549
                                style: 'font-family: FontAwesome',
17550
                                handler: function () {
17551
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17552
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17553
                                    frmDisplay.setHidden(true);
17554
                                    frmForm.setHidden(false);
17555
                                    me.action = "1";
17556
                                }
17557
                            }, {
17558
                                text: 'Back',
17559
                                name: 'cancelDISPLAY' + rec.TableName,
17560
                                iconCls: 'fa-reply',
17561
                                style: 'font-family: FontAwesome',
17562
								handler: function () {
17563
									window.history.back();
17564
								},
17565
								hidden: false
17566
                            }
17567
                            ]
17568
                        }, {
17569
                            xtype: 'minovaform',
17570
                            name: 'FORM' + rec.TableName,
17571
                            id: 'FORM' + rec.TableName,
17572
                            itemId: 'FORM' + rec.TableName,
17573
                            tableName: rec.TableName,
17574
                            isDisplay: false,
17575
                            hidden: true,
17576
                            buttons: [{
17577
                                text: 'Save',
17578
                                name: 'saveDISPLAY' + rec.TableName,
17579
                                iconCls: 'fa-save',
17580
                                style: 'font-family: FontAwesome',
17581
                                handler: function () {
17582
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17583
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17584
                                    
17585
									 var headerDisplay =undefined;
17586
									if(rec.TableName=="PTRPRODUCTIONHEAD"){
17587
										headerDisplay=Ext.ComponentQuery.query('[name=MainHeaderDocument]')[0];
17588
										frmForm.getForm().findField("DocNo").setValue(headerDisplay.getForm().findField("DocNo").getValue());
17589
										frmForm.getForm().findField("DocType").setValue(headerDisplay.getForm().findField("DocType").getValue());
17590
										frmForm.getForm().findField("ProcessID").setValue(headerDisplay.getForm().findField("ProcessID").getValue());
17591
										frmForm.getForm().findField("DocDate").setValue(headerDisplay.getForm().findField("DocDate").getValue());
17592
										frmForm.getForm().findField("DocStatus").setValue(headerDisplay.getForm().findField("DocStatus").getValue());
17593
										frmForm.getForm().findField("OrderDate").setValue(headerDisplay.getForm().findField("OrderDate").getValue());
17594
										frmForm.getForm().findField("Description").setValue(headerDisplay.getForm().findField("Description").getValue());
17595
										frmForm.getForm().findField("FinishGoods").setValue(headerDisplay.getForm().findField("FinishGoods").getValue());											
17596
									}else{
17597
										headerDisplay=Ext.ComponentQuery.query('[name=MainHeaderMDLogistic]')[0];	
17598
									}									
17599
									
17600
                                    var frm = frmForm.getForm();
17601
                                    if (frm.isValid()) {
17602
                                                
17603
										
17604
                                        var keyField = getParam("KeyID");
17605
                                        var table = rec.TableName;
17606
                                        var data = Ext.encode(frmForm.getValues());
17607
                                        var token = MinovaUtil.SESSIONS.Token;
17608
										var action=me.action;
17609
										if(action==undefined){action="0"};
17610
                                        var params = {
17611
                                            apiController: 'api/Devt',
17612
                                            methodName: 'SaveTableMaster',
17613
                                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17614
                                        };
17615
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17616
                                            var result = Ext.decode(xhr.responseText);
17617
                                            var r = Ext.decode(result.data);
17618
                                            if (r.success) {
17619
                                                headerDisplay.mask("Loading...");
17620
                                                var idNo = r.data;
17621
                                                frmForm.getForm().findField(keyField).setValue(idNo);
17622
												frmDisplay.getForm().setValues(frmForm.getValues());
17623
                                                headerDisplay.getForm().setValues(frmForm.getValues());
17624
                                                frmDisplay.setHidden(false);
17625
                                                frmForm.setHidden(true);
17626
                                                MinovaMessage('Not Null', '000006', '', 'S');
17627
                                                headerDisplay.unmask();
17628
                                            } else {
17629
                                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17630
                                            }
17631
                                        });
17632
                                    }
17633
                                }
17634
                            }, {
17635
                                text: 'Delete',
17636
                                name: 'deleteDISPLAY' + rec.TableName,
17637
                                iconCls: 'fa-trash-o',
17638
                                style: 'font-family: FontAwesome',
17639
                                handler: function () {                                    
17640
                                    MinovaMessage(' Message ', ' 000007 ', ' ', 'C', function (respone) {
17641
                                        if (respone == "yes") {
17642
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17643
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17644
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17645
                                            var frm = frmForm.getForm();
17646
                                            if (frm.isValid()) {
17647
                                                var keyField = getParam("KeyID");
17648
                                                var table = rec.TableName;
17649
                                                var data = Ext.encode(frmForm.getValues());
17650
                                                var token = MinovaUtil.SESSIONS.Token;
17651
                                                action = "2";
17652
                                                var params = {
17653
                                                    apiController: 'api/Devt',
17654
                                                    methodName: 'SaveTableMaster',
17655
                                                    parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17656
                                                };
17657
                                                MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17658
                                                    var result = Ext.decode(xhr.responseText);
17659
                                                    var r = Ext.decode(result.data);
17660
                                                    if (r.success) {
17661
                                                        frmDisplay.setHidden(true);
17662
                                                        frmForm.setHidden(true);
17663
                                                        grdPanel.setHidden(false);
17664
                                                        grdPanel.getStore().reload();
17665
                                                        MinovaMessage('Not Null', '000006', '', 'S');
17666
                                                    } else {
17667
                                                        MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17668
                                                    }
17669
                                                });
17670
                                            }
17671
                                        }
17672
                                    });
17673
                                }
17674
                            }, {
17675
                                text: 'Cancel',
17676
                                name: 'cancelDISPLAY' + rec.TableName,
17677
                                iconCls: 'fa-reply',
17678
                                style: 'font-family: FontAwesome',
17679
                                handler: function () {
17680
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
17681
                                        if (respone == "yes") {
17682
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17683
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17684
                                            frmDisplay.setHidden(false);
17685
                                            frmForm.setHidden(true);
17686
                                        }
17687
                                    });
17688
                                }
17689
                            }
17690
                            ]
17691
                        }
17692
                        ]
17693
                    });
17694
				  }
17695
                }
17696
            });
17697
        }
17698
			//saswanto 25MEI2022 END
17699
        Ext.applyIf(me, {
17700
            items: _items
17701
        });
17702
        me.callParent(arguments);
17703
    }
17704
});
17705
/*Add by Taufan ( Tab List Doc Transaction For ERP )*/
17706
Ext.define('MinovaUtil.MinovaES.MinovaTabListDocTrans', {
17707
    extend: 'Ext.tab.Panel',
17708
    alias: ['widget.doctablist'],
17709
    transType: undefined,
17710
    docType: undefined,
17711
    docNo: undefined,
17712
    langId: undefined,
17713
    param: undefined,
17714
    layout: 'fit',
17715
    name: 'panelTab',
17716
    id: 'mainTab',
17717
    action: undefined,
17718
    initComponent: function () {
17719
        var me = this;
17720
        var documentType = me.docType;
17721
        var transactionType = me.transType;
17722
        var hasil = null;
17723
        var _items = [];
17724
		var formimage = undefined;
17725
        Ext.Ajax.request({
17726
            async: false,
17727
            method: 'POST',
17728
            url: '/UserControl/GetStore',
17729
            params: {
17730
                tableName: 'PCMBSTRANSLIST',
17731
                param: 'TransType[=]' + me.transType + ',' + 'DocType[=]' + me.docType // add Tri nwh 20240220
17732
            },
17733
            success: function (response) {
17734
                var results = Ext.decode(response.responseText);
17735
                hasil = results.data;
17736
            }
17737
        });
17738
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
17739
        if (hasil.length > 0) {
17740
            Ext.each(hasil, function (rec) {
17741
				if(rec.TableName=="PTRPRODUCTIONHEAD"){
17742
					rec.LabelName=rec.Title;
17743
				}
17744
                if (rec.LayoutType == "L004") { // L004=Custom
17745
					if(rec.TableName =='PTRPRODUCTIONDETAIL'){					
17746
						var pnl = Ext.create(rec.CustomLayout, {
17747
							title: rec.Title,
17748
							name:  'panelTab' + rec.TableName,
17749
							tableName: rec.TableName,
17750
							docType: me.docType,
17751
							transType: me.transType,
17752
							autoScroll: true
17753
						});
17754
						_items.push(pnl)						
17755
					}else{
17756
						var pnl = Ext.create(rec.CustomLayout, {
17757
							title: rec.Title,
17758
							tableName: rec.TableName,
17759
							height: 400,
17760
							name: 'panelTab' + rec.TableName,
17761
							tbl: rec.TableName,
17762
							layoutType: rec.LayoutType
17763
						});
17764
						_items.push(pnl)						
17765
					}
17766

    
17767
                } else if (rec.LayoutType == "L002" || rec.LayoutType == "L003") {
17768
                    _items.push({
17769
                        xtype: 'panel',
17770
                        title: rec.Title,
17771
                        name: 'panelTab' + rec.TableName,
17772
                        tbl: rec.TableName,
17773
                        layoutType: rec.LayoutType,
17774
                        items: [{
17775
                            xtype: 'docgrid',
17776
                            height: 400,
17777
                            tableName: rec.TableName,
17778
                            docType: me.docType,
17779
                            transType: me.transType,
17780
                            storename: 'store' + rec.TableName,
17781
                            pagesize: 25,
17782
                            name: 'GRID' + rec.TableName,
17783
                            margin: '0 0 10 0',
17784
                            autoLoad: false,
17785
                            tbar: [{
17786
                                xtype: 'button',
17787
                                text: 'Action',
17788
                                name: 'actionGrid' + rec.TableName,
17789
                                menu: [{
17790
                                    text: 'Add',
17791
                                    name: 'add' + rec.TableName,
17792
                                    tbl: rec.TableName,
17793
                                    style: 'font-family: FontAwesome',
17794
                                    iconCls: 'fa-plus-circle',
17795
                                    handler: function () {
17796
                                        var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17797
                                        var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17798
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17799
                                        frmDisplay.reset();
17800
                                        frmForm.reset();
17801
                                        frmDisplay.setHidden(true);
17802
                                        frmForm.setHidden(false);
17803
                                        grdPanel.setHidden(true);
17804
                                        action = "0";
17805
                                    }
17806
                                }, {
17807
                                    text: 'Delete',
17808
                                    name: 'delete' + rec.TableName,
17809
                                    tbl: rec.TableName,
17810
                                    iconCls: 'fa-trash-o',
17811
                                    style: 'font-family: FontAwesome',
17812
                                    handler: function () {
17813
                                        var me = this;
17814
                                        var store = Ext.StoreMgr.lookup('store' + rec.TableName);
17815
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17816
                                        Ext.MessageBox.show({
17817
                                            title: 'Remove tab',
17818
                                            msg: "This will remove. Do you want to continue?",
17819
                                            buttons: Ext.MessageBox.YESNO,
17820
                                            fn: function (choice) {
17821
                                                console.log(choice);
17822
                                                if (choice === 'yes') {
17823
                                                    var selection = grdPanel.getView().getSelectionModel().getSelection()[0];
17824
                                                    if (selection) {
17825
                                                        store.remove(selection);
17826
                                                    }
17827
                                                }
17828
                                            }
17829
                                        });
17830
                                    }
17831
                                }
17832
                                ]
17833
                            }, {
17834
                                xtype: 'tbfill'
17835
                            }, {
17836
                                text: 'Clear Filters',
17837
                                tooltip: 'Clear all filters',
17838
                                name: 'clearbtn',
17839
                                handler: function () {}
17840
                            }
17841
                            ],
17842
                            dockedItems: [{
17843
                                xtype: 'pagingtoolbar',
17844
                                store: 'store' + rec.TableName,
17845
                                dock: 'bottom',
17846
                                pageSize: me.pagesize,
17847
                                displayInfo: true
17848
                            }
17849
                            ],
17850
                            listeners: {
17851
                                'itemdblclick': function (me, record, item, index, e, eOpts) {
17852
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17853
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17854
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17855
                                    frmDisplay.reset();
17856
                                    frmForm.reset();
17857
                                    frmDisplay.getForm().setValues(record.data);
17858
                                    frmForm.getForm().setValues(record.data);
17859
                                    frmDisplay.setHidden(false);
17860
                                    frmForm.setHidden(true);
17861
                                    grdPanel.setHidden(true);
17862
                                    me.action = "1";
17863
                                }
17864
                            }
17865
                        }, {
17866
                            xtype: 'minovadocform',
17867
                            name: 'DISPLAY' + rec.TableName,
17868
                            id: 'DISPLAY' + rec.TableName,
17869
                            itemId: 'DISPLAY' + rec.TableName,
17870
                            tableName: rec.TableName,
17871
                            docType: me.docType,
17872
                            transType: me.transType,
17873
                            isDisplay: true,
17874
                            hidden: true,
17875
                            buttons: [{
17876
                                text: 'Edit',
17877
                                name: 'editDISPLAY' + rec.TableName,
17878
                                handler: function () {
17879
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17880
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17881
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17882
                                    frmDisplay.setHidden(true);
17883
                                    frmForm.setHidden(false);
17884
                                    grdPanel.setHidden(true);
17885
                                }
17886
                            }, {
17887
                                text: 'Cancel',
17888
                                name: 'cancelDISPLAY' + rec.TableName,
17889
                                handler: function () {
17890
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17891
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17892
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17893
                                    frmDisplay.setHidden(true);
17894
                                    frmForm.setHidden(true);
17895
                                    grdPanel.setHidden(false);
17896
                                    grdPanel.getStore().reload();
17897
                                }
17898
                            }
17899
                            ]
17900
                        }, {
17901
                            xtype: 'minovadocform',
17902
                            name: 'FORM' + rec.TableName,
17903
                            id: 'FORM' + rec.TableName,
17904
                            itemId: 'FORM' + rec.TableName,
17905
                            tableName: rec.TableName,
17906
                            docType: me.docType,
17907
                            transType: me.transType,
17908
                            isDisplay: false,
17909
                            hidden: true,
17910
                            buttons: [{
17911
                                text: 'Submit',
17912
                                name: 'submitFORM' + rec.TableName,
17913
                                handler: function () {
17914
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17915
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17916
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17917
                                    var frm = frmForm.getForm();
17918
                                    if (frm.isValid()) {
17919
                                        var table = rec.TableName;
17920
                                        var data = frmForm.getValues();
17921
                                        var token = MinovaUtil.SESSIONS.Token;
17922
                                        var str = grdPanel.getStore();
17923
                                        var idx = str.getCount();
17924
                                        str.insert(idx, data);
17925
                                        frmDisplay.setHidden(true);
17926
                                        frmForm.setHidden(true);
17927
                                        grdPanel.setHidden(false);
17928
                                    }
17929
                                }
17930
                            }, {
17931
                                text: 'Cancel',
17932
                                name: 'cancelFORM' + rec.TableName,
17933
                                handler: function () {
17934
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
17935
                                        if (respone == "yes") {
17936
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17937
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17938
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17939
                                            frmDisplay.setHidden(true);
17940
                                            frmForm.setHidden(true);
17941
                                            grdPanel.setHidden(false);
17942
                                        }
17943
                                    });
17944
                                }
17945
                            }
17946
                            ]
17947
                        }
17948
                        ]
17949
                    });
17950
                } else if (rec.LayoutType == "L005") { // Grid View Only
17951
                    _items.push({
17952
                        xtype: 'panel',
17953
                        title: rec.Title,
17954
                        name: 'panelTab' + rec.TableName,
17955
                        tbl: rec.TableName,
17956
                        layoutType: rec.LayoutType,
17957
                        items: [{
17958
                            xtype: 'docgrid',
17959
                            height: 400,
17960
                            tableName: rec.TableName,
17961
                            docType: me.docType,
17962
                            transType: me.transType,
17963
                            storename: 'store' + rec.TableName,
17964
                            pagesize: 25,
17965
                            name: 'GRID' + rec.TableName,
17966
                            margin: '0 0 10 0',
17967
                            autoLoad: false,
17968
                            tbar: [{
17969
                                xtype: 'tbfill'
17970
                            }, {
17971
                                text: 'Clear Filters',
17972
                                tooltip: 'Clear all filters',
17973
                                name: 'clearbtn',
17974
                                handler: function () {}
17975
                            }
17976
                            ],
17977
                            dockedItems: [{
17978
                                xtype: 'pagingtoolbar',
17979
                                store: 'store' + rec.TableName,
17980
                                dock: 'bottom',
17981
                                pageSize: me.pagesize,
17982
                                displayInfo: true
17983
                            }
17984
                            ]
17985
                        }
17986
                        ]
17987
                    });
17988
                } else if (rec.LayoutType == "L006") {
17989
                    _items.push({
17990
                        xtype: 'panel',
17991
                        title: rec.Title,
17992
                        name: 'panelTab' + rec.TableName,
17993
                        tbl: rec.TableName,
17994
                        layoutType: rec.LayoutType,
17995
                        items: [{
17996
                            xtype: 'docgridcelledit',
17997
                            name: 'CELLGRID' + rec.TableName,
17998
                            tableName: rec.TableName,
17999
                            docType: me.docType,
18000
                            transType: me.transType,
18001
                            docNo: me.docNo,
18002
                            height: 400,
18003
                            hideButton: false,
18004
                            margin: '0 0 10 0'
18005
                        }
18006
                        ]
18007
                    });
18008
                } else if (rec.LayoutType == "L007"&& rec.TableName !='PTRPRODUCTIONITEM') {
18009
                    _items.push({
18010
                        xtype: 'panel',
18011
                        title: rec.Title,
18012
                        name: 'panelTab' + rec.TableName,
18013
                        tbl: rec.TableName,
18014
                        layoutType: rec.LayoutType,
18015
                        items: [{
18016
                            xtype: 'docgridcelleditsum',
18017
                            name: 'CELLGRID' + rec.TableName,
18018
                            tableName: rec.TableName,
18019
                            docType: me.docType,
18020
                            transType: me.transType,
18021
                            docNo: me.docNo,
18022
                            height: 400,
18023
                            hideButton: false,
18024
                            margin: '0 0 10 0'
18025
                        }, {
18026
                            xtype: 'summarydocform',
18027
                            name: 'SUM' + rec.TableName,
18028
                            id: 'SUM' + rec.TableName,
18029
                            itemId: 'SUM' + rec.TableName,
18030
                            tableName: rec.TableName,
18031
                            docType: me.docType,
18032
                            transType: me.transType,
18033
                        }
18034
                        ]
18035
                    });
18036
                }  else if (rec.LayoutType == "L007" && rec.TableName =='PTRPRODUCTIONITEM') {
18037
                    _items.push({
18038
                        xtype: 'panel',
18039
                        title: rec.Title,
18040
                        name: 'panelTab' + rec.TableName,
18041
                        tbl: rec.TableName,
18042
                        layoutType: rec.LayoutType,						
18043
                        items: [{
18044
                            xtype: 'docgridcelleditsum',
18045
                            name: 'CELLGRID' + rec.TableName,
18046
                            tableName: rec.TableName,
18047
                            docType: me.docType,
18048
                            transType: me.transType,
18049
                            docNo: me.docNo,
18050
                            height: 400,
18051
                            hideButton: false,
18052
                            margin: '0 0 10 0'
18053
                        }, {
18054
                            xtype: 'summarydocform',
18055
                            name: 'SUM' + rec.TableName,
18056
                            id: 'SUM' + rec.TableName,
18057
                            itemId: 'SUM' + rec.TableName,
18058
                            tableName: rec.TableName,
18059
                            docType: me.docType,
18060
                            transType: me.transType,
18061
                        }
18062
                        ]
18063
                    });
18064
                } else { // L001=Default Form Only
18065
                    _items.push({
18066
                        xtype: 'panel',
18067
                        title: rec.LabelName,
18068
                        name: 'panelTab' + rec.TableName,
18069
                        tbl: rec.TableName,
18070
                        layoutType: rec.LayoutType,
18071
                        items: [{
18072
                            xtype: 'minovadocform',
18073
                            name: 'DISPLAY' + rec.TableName,
18074
                            id: 'DISPLAY' + rec.TableName,
18075
                            itemId: 'DISPLAY' + rec.TableName,
18076
                            tableName: rec.TableName,
18077
                            docType: me.docType,
18078
                            transType: me.transType,
18079
                            isDisplay: true,
18080
                            hidden: false,
18081
                            buttons: [{
18082
                                text: 'Edit',
18083
                                name: 'editDISPLAY' + rec.TableName,
18084
                                iconCls: 'fa-edit',
18085
                                style: 'font-family: FontAwesome',
18086
                                handler: function () {
18087
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
18088
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
18089
                                    frmDisplay.setHidden(true);
18090
                                    frmForm.setHidden(false);
18091
									if(rec.TableName=='PTRPRODUCTIONHEAD'){
18092
										Ext.ComponentQuery.query('[name=deleteDISPLAYPTRPRODUCTIONHEAD]')[0].setHidden(true);
18093
									}			
18094
                                    me.action = "1";
18095
                                }
18096
                            }, {
18097
                                text: 'Back',
18098
                                name: 'backDISPLAY' + rec.TableName,
18099
                                iconCls: 'fa-reply',
18100
                                style: 'font-family: FontAwesome',
18101
								hidden: true,
18102
                                handler: function () {
18103
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
18104
                                        if (respone == "yes") {
18105
											MinovaUtil.LockData('CheckUser','CheckUser',5,0,MinovaUtil.SESSIONS.EmployeeID,MinovaUtil.GetMenuID());
18106
											//me.afterrenderTab();
18107
											var pnlSelect = Ext.ComponentQuery.query('[name=DocSelectionJoil]')[0];
18108
											//var tes = Ext.ComponentQuery.query('[name=searchResultInfo]')[0];
18109
											var pnlTransaction = Ext.ComponentQuery.query('[name=DocTransaction]')[0];
18110
											var panelHead = Ext.ComponentQuery.query('[name=MainHeaderDocument]')[0];
18111
											var panelDisplayHead = Ext.ComponentQuery.query('[name=DisplayMainHeaderDocument]')[0];
18112
											var formHead = panelHead.getForm();
18113
											formHead.reset();
18114
											var formHeadDisplay = panelDisplayHead.getForm();
18115
											formHeadDisplay.reset();
18116
											var btnCreate = Ext.ComponentQuery.query('[name=CreateDoc]')[0];
18117
											var btnSave = Ext.ComponentQuery.query('[name=SaveDoc]')[0];
18118
											var btnEdit = Ext.ComponentQuery.query('[name=EditDoc]')[0];
18119
											var btnDelete = Ext.ComponentQuery.query('[name=DeleteDoc]')[0];
18120
											pnlSelect.setHidden(false);
18121
											//tes.setHidden(true);
18122
											pnlTransaction.setHidden(true);
18123
											panelHead.setHidden(false);
18124
											panelDisplayHead.setHidden(true);
18125
                                        }
18126
                                    });
18127
                                }
18128
                            }, {
18129
                                text: 'Cancel',
18130
                                name: 'cancelDISPLAY' + rec.TableName,
18131
                                iconCls: 'fa-reply',
18132
                                style: 'font-family: FontAwesome',
18133
                                hidden: true
18134
                            }
18135
                            ]
18136
                        }, {
18137
                            xtype: 'minovadocform',
18138
                            name: 'FORM' + rec.TableName,
18139
                            id: 'FORM' + rec.TableName,
18140
                            itemId: 'FORM' + rec.TableName,
18141
                            tableName: rec.TableName,
18142
                            docType: me.docType,
18143
                            transType: me.transType,
18144
                            isDisplay: false,
18145
                            hidden: true,
18146
                            buttons: [{
18147
                                text: 'Save',
18148
                                name: 'saveDISPLAY' + rec.TableName,
18149
                                iconCls: 'fa-save',
18150
                                style: 'font-family: FontAwesome',
18151
                                handler: function () {
18152
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
18153
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
18154
									
18155
									 var headerDisplay =undefined;
18156
									if(rec.TableName=="PTRPRODUCTIONHEAD"){
18157
										headerDisplay=Ext.ComponentQuery.query('[name=MainHeaderDocument]')[0];
18158
										frmForm.getForm().findField("DocNo").setValue(headerDisplay.getForm().findField("DocNo").getValue());
18159
										frmForm.getForm().findField("DocType").setValue(headerDisplay.getForm().findField("DocType").getValue());
18160
										frmForm.getForm().findField("ProcessID").setValue(headerDisplay.getForm().findField("ProcessID").getValue());
18161
										frmForm.getForm().findField("DocDate").setValue(headerDisplay.getForm().findField("DocDate").getValue());
18162
										frmForm.getForm().findField("DocStatus").setValue(headerDisplay.getForm().findField("DocStatus").getValue());
18163
										frmForm.getForm().findField("OrderDate").setValue(headerDisplay.getForm().findField("OrderDate").getValue());
18164
										frmForm.getForm().findField("Description").setValue(headerDisplay.getForm().findField("Description").getValue());	
18165
										frmForm.getForm().findField("FinishGoods").setValue(headerDisplay.getForm().findField("FinishGoods").getValue());										
18166
									}else{
18167
										headerDisplay=Ext.ComponentQuery.query('[name=MainHeaderMDLogistic]')[0];	
18168
									}
18169
                                   
18170
                                    var frm = frmForm.getForm();
18171
                                    if (frm.isValid()) {
18172

    
18173
										
18174
                                        var table = rec.TableName;
18175
                                        var data = Ext.encode(frmForm.getValues());
18176
                                        var token = MinovaUtil.SESSIONS.Token;
18177
										var action=me.action;
18178
										if(action==undefined){action="0"};
18179
                                        var params = {
18180
                                            apiController: 'api/Devt',
18181
                                            methodName: 'SaveTableMaster',
18182
                                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
18183
                                        };
18184
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
18185
                                            var result = Ext.decode(xhr.responseText);
18186
                                            var r = Ext.decode(result.data);
18187
                                            if (r.success) {
18188
                                                headerDisplay.mask("Loading...");
18189
                                                var idNo = r.data;
18190
                                                frmForm.getForm().findField("DocNo").setValue(idNo);
18191
												frmDisplay.getForm().setValues(frmForm.getValues());
18192
												headerDisplay.getForm().setValues(frmForm.getValues());													
18193
                                                frmDisplay.setHidden(false);
18194
                                                frmForm.setHidden(true);
18195
                                                MinovaMessage('Not Null', '000006', '', 'S');
18196
                                                headerDisplay.unmask();
18197
                                            } else {
18198
                                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
18199
                                            }
18200
                                        });
18201
                                    }
18202
                                }
18203
                            }, {
18204
                                text: 'Delete',
18205
                                name: 'deleteDISPLAY' + rec.TableName,
18206
                                iconCls: 'fa-trash-o',
18207
                                style: 'font-family: FontAwesome',
18208
                                handler: function () {}
18209
                            }, {
18210
                                text: 'Cancel',
18211
                                name: 'cancelDISPLAY' + rec.TableName,
18212
                                iconCls: 'fa-reply',
18213
                                style: 'font-family: FontAwesome',
18214
                                handler: function () {
18215
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
18216
                                        if (respone == "yes") {
18217
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
18218
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
18219
                                            frmDisplay.setHidden(false);
18220
                                            frmForm.setHidden(true);
18221
                                        }
18222
                                    });
18223
                                }
18224
                            }
18225
                            ]
18226
                        }
18227
                        ]
18228
                    });
18229
                }
18230
            });
18231
        }
18232
        Ext.applyIf(me, {
18233
            items: _items
18234
        });
18235
        me.callParent(arguments);
18236
    }
18237
});
18238
/*Add by Taufan ( Generate Doc Transaction Form For ERP )*/
18239
Ext.define('MinovaUtil.MinovaES.MinovaDocForm', {
18240
    extend: 'Ext.form.Panel',
18241
    alias: ['widget.MinovaDocForm', 'widget.minovadocform', 'widget.docform'],
18242
    formname: this.name,
18243
    tableName: undefined,
18244
    docType: undefined,
18245
    transType: undefined,
18246
    resizable: true,
18247
    border: false,
18248
    autoScroll: true,
18249
    isDisplay: undefined,
18250
    isLookup: undefined,
18251
    layout: 'column',
18252
    defaults: {
18253
        layout: 'form',
18254
        xtype: 'container',
18255
        defaultType: 'textfield',
18256
        style: 'width: 50%',
18257
    },
18258
    initComponent: function () {
18259
        var me = this;
18260
        var col1 = [];
18261
        var col2 = [];
18262
        var LangID = localStorage.LangId;
18263
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "'";
18264
        var formname_ = me.name;
18265
        var nameTable_ = me.tableName;
18266
        Ext.Ajax.request({
18267
            async: false,
18268
            method: 'POST',
18269
            url: '/UserControl/GetStore',
18270
            params: {
18271
                tableName: 'PDSDOCFIELD',
18272
                param: parameter
18273
            },
18274
            success: function (response) {
18275
                var results = Ext.decode(response.responseText);
18276
                hasil = results.data;
18277
            }
18278
        });
18279

    
18280
        if (hasil.length > 0) {
18281
            Ext.each(hasil, function (rec) {
18282
                var isnull = null;
18283
                if (rec.IsPrimaryKey == '1') {
18284
                    isnull = false;
18285
                }
18286
                if (rec.IsRequired == '1') {
18287
                    isnull = false;
18288
                } else {
18289
                    isnull = true;
18290
                }
18291
                var formfield = MinovaUtil.FieldGenerator.Form(me.name, rec, isnull, me.isDisplay, me.tableName, me.isLookup);
18292
                var descField = undefined;
18293
		
18294
                if (rec.ColumnNo == 1) {
18295
                    col1.push(formfield);
18296
                    if (descField) {
18297
                        col1.push(descField)
18298
                    }
18299
                } else {
18300
                    col2.push(formfield);
18301
                    if (descField) {
18302
                        col2.push(descField)
18303
                    }
18304
                }
18305

    
18306
                if (rec.IsPrimaryKey == 1 && me.isLookup == undefined) {
18307
                    formfieldKey = new Ext.form.TextField({
18308
                        hidden: true,
18309
                        name: "Key_" + rec.FieldName,
18310
                    });
18311
                    col2.push(formfieldKey);
18312
                }			
18313
            });
18314
        }
18315
        Ext.applyIf(me, {
18316
            items: [{
18317
                style: 'width: 50%',
18318
                items: col1
18319
            }, {
18320
                style: 'width: 50%',
18321
                items: col2
18322
            }
18323
            ]
18324
        });
18325
        this.callParent();
18326
    }
18327
});
18328
/*Add by Taufan ( Generate Doc Transaction Grid For ERP )*/
18329
Ext.define('MinovaUtil.MinovaES.MinovaDocGrid', {
18330
    extend: 'Ext.grid.Panel',
18331
    requires: ['Ext.grid.RowNumberer'],
18332
    alias: 'widget.docgrid',
18333
    alternateClassName: 'Ext.grid.MinovaGrid',
18334
    tableName: undefined,
18335
    docType: undefined,
18336
    transType: undefined,
18337
    isLookup: undefined,
18338
    param: undefined,
18339
    pagesize: undefined,
18340
    storename: undefined,
18341
    layoutType: undefined,
18342
    enableLocking: true,
18343
    autoLoad: undefined,
18344
    multiSelect: undefined,
18345
    getTableName: function () {
18346
        return this.tableName;
18347
    },
18348
    initComponent: function () {
18349
        var me = this;
18350
        var cols_ = [];
18351
        var fieldeditor = {};
18352
        var hasil = null;
18353
        var autoLoad = true;
18354
        var LangID = localStorage.LangId;
18355
        var fielGrid = 'rec.GridView == 1';
18356
        var locking = true;
18357
        var checkSelection = '';
18358
        var widthLock = 250;
18359
        if (me.multiSelect) {
18360
            locking = false;
18361
            checkSelection = 'checkboxmodel';
18362
            widthLock = 40;
18363
        }
18364
        if (me.autoLoad == false) {
18365
            autoLoad = false;
18366
        }
18367
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "'";
18368
        Ext.Ajax.request({
18369
            async: false,
18370
            method: 'POST',
18371
            url: '/UserControl/GetStore',
18372
            params: {
18373
                tableName: 'PDSDOCFIELD',
18374
                param: parameter
18375
            },
18376
            success: function (response) {
18377
                var results = Ext.decode(response.responseText);
18378
                hasil = results.data;
18379
            }
18380
        });
18381
        if (hasil.length > 0) {
18382
            Ext.each(hasil, function (rec) {
18383
                var null_ = null;
18384
                if (rec.IsPrimaryKey == true) {
18385
                    null_ = false;
18386
                }
18387
                if (rec.IsRequired == true) {
18388
                    null_ = false;
18389
                } else {
18390
                    null_ = true;
18391
                }
18392
                if (rec.GridView == 1) {
18393
                    switch (rec.FormatRef) {
18394
                        case "action":
18395
                            cols_.push({
18396
                                text: rec.HeaderTitle,
18397
                                width: 100,
18398
                                xtype: 'actioncolumn',
18399
                                tooltip: 'View Data',
18400
                                name: rec.FieldName,
18401
                                itemId: me.tableName + rec.FieldName,
18402
                                align: 'center',
18403
                                iconCls: 'fa-edit',
18404
                                renderer: function (value, metadata, record) {
18405
                                    metadata.tdStyle = 'font-family: FontAwesome'
18406
                                },
18407
                                handler: function (grid, rowIndex, colIndex, actionItem, event, record, row) {
18408

    
18409
                                    this.fireEvent(me.tableName + rec.FieldName + "onActionClick", record);
18410
                                }
18411
                            });
18412
                            break
18413
                        case "file":
18414
                            cols_.push({
18415
                                xtype: 'minovapicturecolumn',
18416
                                text: rec.HeaderTitle,
18417
                                dataIndex: rec.FieldName,
18418
                                width: 100
18419
                            });
18420
                            break
18421
                        case "date":
18422
                            cols_.push({
18423
                                xtype: 'minovadatecolumn',
18424
                                text: rec.HeaderTitle,
18425
                                dataIndex: rec.FieldName,
18426
                                width: 100,
18427
                                filter: {
18428
                                    type: 'date',
18429
                                    itemDefaults: {
18430
                                        emptyText: 'Search for...'
18431
                                    }
18432
                                }
18433
                            });
18434
                            break
18435
                        case "amountencrypt":
18436
                            cols_.push({
18437
                                xtype: 'minovaamountcolumn',
18438
                                text: rec.HeaderTitle,
18439
                                dataIndex: rec.FieldName,
18440
                                align: 'right',
18441
                                width: 100,
18442
                                filter: {
18443
                                    type: 'string',
18444
                                    itemDefaults: {
18445
                                        emptyText: 'Search for...'
18446
                                    }
18447
                                }
18448
                            });
18449
                            break
18450
                        case "amount":
18451
                            cols_.push({
18452
                                xtype: 'minovacurrancycolumn',
18453
                                text: rec.HeaderTitle,
18454
                                dataIndex: rec.FieldName,
18455
                                align: 'right',
18456
                                width: 100,
18457
                                filter: {
18458
                                    type: 'number',
18459
                                    itemDefaults: {
18460
                                        emptyText: 'Search for...'
18461
                                    }
18462
                                }
18463
                            });
18464
                            break
18465
                        case "datetime":
18466
                            cols_.push({
18467
                                xtype: 'minovadatetimecolumn',
18468
                                text: rec.HeaderTitle,
18469
                                dataIndex: rec.FieldName,
18470
                                width: 140,
18471
                                filter: {
18472
                                    type: 'string',
18473
                                    itemDefaults: {
18474
                                        emptyText: 'Search for...'
18475
                                    }
18476
                                }
18477
                            });
18478
                            break
18479
                        default:
18480
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
18481
                                cols_.push({
18482
                                    text: rec.HeaderTitle,
18483
                                    dataIndex: rec.FieldName,
18484
                                    width: 100,
18485
                                    filter: {
18486
                                        type: 'string',
18487
                                        itemDefaults: {
18488
                                            emptyText: 'Search for...'
18489
                                        }
18490
                                    }
18491
                                });
18492
                            } else if (rec.TableRef != "") {
18493
                                if (rec.TableRef != null) {
18494
                                    var valueField = null;
18495
                                    var displayValue = null;
18496
                                    Ext.Ajax.request({
18497
                                        async: false,
18498
                                        method: 'POST',
18499
                                        url: '/UserControl/GetStore',
18500
                                        params: {
18501
                                            tableName: 'SDATATABLEFIELD',
18502
                                            param: 'TableName[equal]' + rec.TableRef
18503
                                        },
18504
                                        success: function (response) {
18505
                                            var results = Ext.decode(response.responseText);
18506
                                            data_ = results.data;
18507
                                            if (data_.length > 0) {
18508
                                                valueField_ = $.grep(data_, function (r) {
18509
                                                    return r.ValueField == '1'
18510
                                                });
18511
                                                valueField = valueField_[0].FieldName
18512
                                                displayValue_ = $.grep(data_, function (r) {
18513
                                                    return r.DisplayValue == '1'
18514
                                                });
18515
                                                displayValue = displayValue_[0].FieldName
18516
                                            } else {
18517
                                                MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
18518
                                            }
18519
                                        }
18520
                                    });
18521
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
18522
                                    var count_ = 0;
18523
                                    if (store_) {
18524
                                        count_ = store_.count();
18525
                                    }
18526
                                    if (count_ == 0) {
18527
                                        Ext.create('Ext.data.Store', {
18528
                                            storeId: 'store_' + rec.FieldName,
18529
                                            autoLoad: false,
18530
                                            proxy: {
18531
                                                method: 'POST',
18532
                                                type: 'ajax',
18533
                                                url: '/UserControl/GetStore',
18534
                                                extraParams: {
18535
                                                    tableName: rec.TableRef,
18536
                                                    param: rec.ParamCombo
18537
                                                },
18538
                                                reader: {
18539
                                                    type: 'json',
18540
                                                    root: 'data',
18541
                                                    totalProperty: 'data[0].TotalCount'
18542
                                                }
18543
                                            }
18544
                                        })
18545
                                    }
18546
                                    cols_.push({
18547
                                        xtype: 'minovacombocolumn',
18548
                                        text: rec.HeaderTitle,
18549
                                        dataIndex: rec.FieldName,
18550
                                        valueField: valueField,
18551
                                        displayField: displayValue,
18552
                                        store: 'store_' + rec.FieldName,
18553
                                        filter: {
18554
                                            type: 'list',
18555
                                            itemDefaults: {
18556
                                                emptyText: 'Search for...'
18557
                                            }
18558
                                        }
18559
                                    });
18560
                                }
18561
                            } else if (rec.FixedValue != "") {
18562
                                cols_.push({
18563
                                    xtype: 'minovacombocolumnfixvalue',
18564
                                    text: rec.HeaderTitle,
18565
                                    dataIndex: rec.FieldName,
18566
                                    fixedValue: rec.FixedValue,
18567
                                    filter: {
18568
                                        type: 'list',
18569
                                        itemDefaults: {
18570
                                            emptyText: 'Search for...'
18571
                                        }
18572
                                    }
18573
                                });
18574
                            } else {
18575
                                cols_.push({
18576
                                    text: rec.HeaderTitle,
18577
                                    dataIndex: rec.FieldName,
18578
                                    filter: {
18579
                                        itemDefaults: {
18580
                                            emptyText: 'Search for...'
18581
                                        }
18582
                                    }
18583
                                });
18584
                            }
18585
                            break
18586
                    }
18587
                } else {
18588
                    cols_.push({
18589
                        text: rec.HeaderTitle,
18590
                        dataIndex: rec.FieldName,
18591
                        hidden: true,
18592
                        filter: {
18593
                            itemDefaults: {
18594
                                emptyText: 'Search for...'
18595
                            }
18596
                        }
18597
                    });
18598
                }
18599

    
18600
            });
18601
        };
18602
        var param_ = me.param;
18603
        if (param_ == undefined) {
18604
            param_ = ''
18605
        }
18606
        var jsStoreGrid = new Ext.data.Store({
18607
            storeId: me.storename,
18608
            autoLoad: autoLoad,
18609
            pageSize: me.pagesize,
18610
            proxy: {
18611
                method: 'POST',
18612
                type: 'ajax',
18613
                url: '/UserControl/GetStorePagingAuth',
18614
                extraParams: {
18615
                    tableName: me.tableName,
18616
                    param: param_,
18617
                    menuId: MinovaUtil.GetMenuID()
18618
                },
18619
                reader: {
18620
                    type: 'json',
18621
                    root: 'data',
18622
                    totalProperty: 'totalRecords'
18623
                }
18624
            },
18625
        });
18626
        Ext.applyIf(me, {
18627
            autoScroll: true,
18628
            enableLocking: locking,
18629
            lockedGridConfig: {
18630
                header: false,
18631
                collapsible: true,
18632
                width: widthLock,
18633
                forceFit: locking,
18634
                listeners: {
18635
                    render: function (grid) {
18636
                        var pagingToolbar = grid.child('pagingtoolbar');
18637
                        if (pagingToolbar) {
18638
                            grid.remove(pagingToolbar, true);
18639
                        }
18640
                    }
18641
                }
18642
            },
18643
            listeners: {
18644
                viewready: function () {
18645
                    if (autoLoad == true) {
18646
                        this.getStore().loadPage(1);
18647
                    }
18648
                },
18649
                beforeedit: function () {
18650
                    return false;
18651
                }
18652
            },
18653
            lockedViewConfig: {
18654
                scroll: 'horizontal'
18655
            },
18656

    
18657
            //Add For Auto Size Coloum Mode
18658
            viewConfig: {
18659
                emptyText: 'No Data Display',
18660
                deferEmptyText: false,
18661
                listeners: {
18662
                    refresh: function (dataview) {
18663
                        Ext.each(dataview.panel.columns, function (column) {
18664
                            if (column.autoSizeColumn == false)
18665
                                column.autoSizeColumn = true;
18666
                                column.autoSize();
18667
                        })
18668
                    }
18669
                }
18670
            },
18671
            selModel: {},
18672
            selType: checkSelection,
18673
            columns: cols_,
18674
            store: jsStoreGrid,
18675
            plugins: [{
18676
                ptype: 'gridfilters'
18677
            }
18678
            ]
18679
        });
18680
        me.callParent(arguments);
18681
    }
18682
});
18683
/*Add by Taufan ( Generate Doc Transaction Cell Edit Grid  For ERP )*/
18684
Ext.define('MinovaUtil.MinovaES.MinovaDocGridCellEdit', {
18685
    extend: 'Ext.form.Panel',
18686
    alias: 'widget.docgridcelledit',
18687
    requires: [
18688
		'Ext.grid.plugin.CellEditing',
18689
		'Ext.grid.Panel'
18690
    ],
18691
    autoScroll: true,
18692
    anchor: '100%',
18693
    tableName: undefined,
18694
    docType: undefined,
18695
    transType: undefined,
18696
    docNo: undefined,
18697
    hideButton: undefined,
18698
    multiSelect: undefined,
18699
    initComponent: function () {
18700
        var me = this;
18701
        var isLookup = me.isLookup;
18702
        var hide_ = false;
18703
        var widthLock = 250;
18704
        var checkSelection = '';
18705
		var hideUploadDownload = false; // add by Tri nwh 20220829
18706
		var hideCheckStock = true; // add by Tri nwh 20220829
18707
		var hideGenBOMProd = true; // add by Tri nwh 20220829
18708
		
18709
		Ext.Ajax.request({ // add by Tri nwh 20220829
18710
			async: false,
18711
			method: 'POST',
18712
			url: '/UserControl/GetStore',
18713
			params: {
18714
				tableName: "PCMBSTRANSLIST",
18715
				param: 'TableName[=]' + me.tableName + ',' + 'DocType[=]' + me.docType // add Tri nwh 20240220
18716
			},
18717
			success: function (response) {
18718
				var results = Ext.decode(response.responseText);
18719
				if (results.data[0].UploadDownloadEnable == '0') {
18720
					hideUploadDownload = true;
18721
				} else {
18722
					hideUploadDownload = false;
18723
				}
18724
			}
18725
		});
18726

    
18727
		if (me.tableName == "PTRALLOCATION") { // add by Tri nwh 20220829
18728
			hideCheckStock = false;
18729
		}
18730
		
18731
        if (me.hideButton == true) {
18732
            hide_ = true;
18733
        }
18734
        if (me.multiSelect) {
18735
            locking = false;
18736
            checkSelection = 'checkboxmodel';
18737
            widthLock = 40;
18738
        }
18739
        var tableName = me.tableName;
18740
        var cols = [];
18741
        var fieldStore = [];
18742
        var _url = 'GetAllField';
18743
        var hasil = null;
18744
        var height = me.height;
18745
        var storeID = 'store' + me.tableName;
18746
        var gridName = 'grid' + me.name;
18747
        if (me.storeName) {
18748
            storeID = me.storeName;
18749
        }
18750
        var LangID = MinovaUtil.GetLangID();
18751
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "'";
18752
        Ext.Ajax.request({
18753
            async: false,
18754
            method: 'POST',
18755
            url: '/UserControl/GetStore',
18756
            params: {
18757
                tableName: 'PDSDOCFIELD',
18758
                param: parameter
18759
            },
18760
            success: function (response) {
18761
                var results = Ext.decode(response.responseText);
18762
                hasil = results.data;
18763
            }
18764
        });
18765
        cols.push({
18766
            xtype: 'rownumberer'
18767
        });
18768
        var addData = '({';
18769
        if (hasil.length > 0) {
18770
            Ext.each(hasil, function (rec) {
18771
                fieldStore.push(rec.FieldName);
18772
                var defaultValue = rec.DefaultValue;
18773
                if (defaultValue.substring(0, 2).toLowerCase() == 'fn') {
18774
                    Ext.Ajax.request({
18775
                        async: false,
18776
                        method: 'POST',
18777
                        url: '/UserControl/GetStore',
18778
                        params: {
18779
                            tableName: 'PCMFUNC',
18780
                            param: 'FuncName[equal]' + rec.DefaultValue
18781
                        },
18782
                        success: function (response) {
18783
                            var results = Ext.decode(response.responseText);
18784
                            data_ = results.data;
18785
                            if (data_.length > 0) {
18786
                                defaultValue = eval(data_[0].FunctionCode);
18787
                            }
18788
                        }
18789
                    });
18790
                }
18791
                addData = addData + rec.FieldName + ":" + "'" + defaultValue + "',";
18792
                var null_ = null;
18793
                var ReadOnly_ = false;
18794
                if (rec.IsPrimaryKey == true) {
18795
                    null_ = false;
18796
                }
18797
                if (rec.IsRequired == true) {
18798
                    null_ = false;
18799
                } else {
18800
                    null_ = true;
18801
                }
18802
                var Hidden_ = false;
18803
                if (rec.ReadOnly == '1') {
18804
                    ReadOnly_ = true;
18805
                }
18806
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
18807
                    Hidden_ = true;
18808
                    null_ = true;
18809
                }
18810
                if (rec.GridView == 1) {
18811
                    switch (rec.FormatRef) {
18812
                        case "date":
18813
                            cols.push({
18814
                                xtype: 'minovadatecolumn',
18815
                                hidden: Hidden_,
18816
                                text: rec.HeaderTitle,
18817
                                dataIndex: rec.FieldName,
18818
                                filter: {
18819
                                    itemDefaults: {
18820
                                        emptyText: 'Search for...'
18821
                                    }
18822
                                },
18823
                                editor: {
18824
                                    allowBlank: null_,
18825
                                    xtype: 'datefield',
18826
                                    hideMode: 'visibility',
18827
                                    readOnly: ReadOnly_,
18828
                                    id: tableName + rec.FieldName,
18829
                                    value: defaultValue
18830
                                }
18831
                            });
18832
                            break
18833
                        case "amount":
18834
                            cols.push({
18835
                                //xtype : 'minovacurrancycolumn',
18836
                                xtype: 'numbercolumn',
18837
                                text: rec.HeaderTitle,
18838
                                align: 'right',
18839
                                dataIndex: rec.FieldName,
18840
                                hidden: Hidden_,
18841
								minWidth: 150,
18842
                                filter: {
18843
                                    itemDefaults: {
18844
                                        emptyText: 'Search for...'
18845
                                    }
18846
                                },
18847
                                editor: {
18848
                                    allowBlank: null_,
18849
                                    xtype: 'textfield',
18850
                                    readOnly: ReadOnly_,
18851
                                    id: tableName + rec.FieldName,
18852
                                    nameTable: rec.TableName,
18853
                                    fieldGrid: rec.FieldName,
18854
                                    fieldStyle: 'text-align:right;',
18855
                                    vtype: 'validateMinovaNumber',
18856
                                    value: '0',
18857
                                    listeners: {
18858
                                        change: function (val, recs) {
18859
                                            var fvalue = val.getValue();
18860
                                            var custumFunc = rec.SelectFunction;
18861
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18862
                                                Ext.Ajax.request({
18863
                                                    async: false,
18864
                                                    method: 'POST',
18865
                                                    url: '/UserControl/GetStore',
18866
                                                    params: {
18867
                                                        tableName: 'PCMFUNC',
18868
                                                        param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18869
                                                    },
18870
                                                    success: function (response) {
18871
                                                        var results = Ext.decode(response.responseText);
18872
                                                        var dt = results.data[0];
18873
                                                        if (dt != undefined) {
18874
                                                            custumFunc = dt.FunctionCode;
18875
                                                        }
18876
                                                    }
18877
                                                });
18878
                                            }
18879
                                            if (custumFunc) {
18880
                                                eval(custumFunc)
18881
                                            }
18882
                                        }
18883
                                    }
18884
                                }
18885
                            });
18886
                            break
18887
                        default:
18888
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
18889
                                cols.push({
18890
                                    text: rec.HeaderTitle,
18891
                                    dataIndex: rec.FieldName,
18892
                                    width: 100,
18893
									minWidth: 150,
18894
                                    filter: {
18895
                                        type: 'string',
18896
                                        itemDefaults: {
18897
                                            emptyText: 'Search for...'
18898
                                        }
18899
                                    }
18900
                                });
18901
                            } else if (rec.SearchType == '0') {
18902
                                var valueField = null;
18903
                                var displayValue = null;
18904
                                var TableRef = undefined;
18905
                                if (rec.TableRef != '') {
18906
                                    TableRef = rec.TableRef;
18907
                                    Ext.Ajax.request({
18908
                                        async: false,
18909
                                        method: 'POST',
18910
                                        url: '/UserControl/GetStore',
18911
                                        params: {
18912
                                            tableName: 'SDATATABLEFIELD',
18913
                                            param: 'TableName[equal]' + rec.TableRef
18914
                                        },
18915
                                        success: function (response) {
18916
                                            var results = Ext.decode(response.responseText);
18917
                                            data_ = results.data;
18918
                                            if (data_ != undefined) {
18919
                                                valueField_ = $.grep(data_, function (r) {
18920
                                                    return r.ValueField == '1'
18921
                                                });
18922
                                                valueField = valueField_[0].FieldName
18923
                                                displayValue_ = $.grep(data_, function (r) {
18924
                                                    return r.DisplayValue == '1'
18925
                                                });
18926
												if(displayValue_[0] !=undefined){
18927
													displayValue = displayValue_[0].FieldName
18928
												}
18929
                                                
18930
                                            }
18931
                                        }
18932
                                    });
18933
                                }
18934
                                Ext.create('Ext.data.Store', {
18935
                                    storeId: 'store_' + me.tableName + rec.FieldName,
18936
                                    autoLoad: true,
18937
                                    proxy: {
18938
                                        method: 'POST',
18939
                                        type: 'ajax',
18940
                                        url: '/UserControl/GetStoreAuth',
18941
                                        extraParams: {
18942
                                            tableName: TableRef,
18943
                                            param: rec.ParamCombo,
18944
                                            menuId: MinovaUtil.GetMenuID()
18945
                                        },
18946
                                        reader: {
18947
                                            type: 'json',
18948
                                            root: 'data',
18949
                                            totalProperty: 'data[0].TotalCount'
18950
                                        }
18951
                                    }
18952
                                });
18953
                                cols.push({
18954
                                    xtype: 'minovacombocolumn',
18955
                                    hidden: Hidden_,
18956
                                    text: rec.HeaderTitle,
18957
                                    dataIndex: rec.FieldName,
18958
                                    valueField: valueField,
18959
                                    displayField: displayValue,
18960
                                    store: 'store_' + me.tableName + rec.FieldName,
18961
									minWidth: 150,
18962
                                    editor: {
18963
                                        allowBlank: null_,
18964
                                        xtype: 'minovacombobox',
18965
                                        readOnly: ReadOnly_,
18966
                                        id: tableName + rec.FieldName,
18967
                                        valueField: valueField,
18968
                                        displayField: displayValue,
18969
                                        store: 'store_' + me.tableName + rec.FieldName,
18970
										forceSelection: false,
18971
									lazyRender: true,
18972
                                        listeners: {
18973
                                            change: function (val) {
18974
                                                var fvalue = val.getValue();
18975
                                                var custumFunc = rec.SelectFunction;
18976
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18977
                                                    Ext.Ajax.request({
18978
                                                        async: false,
18979
                                                        method: 'POST',
18980
                                                        url: '/UserControl/GetStore',
18981
                                                        params: {
18982
                                                            tableName: 'PCMFUNC',
18983
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18984
                                                        },
18985
                                                        success: function (response) {
18986
                                                            var results = Ext.decode(response.responseText);
18987
                                                            var dt = results.data[0];
18988
                                                            if (dt != undefined) {
18989
                                                                custumFunc = dt.FunctionCode;
18990
                                                            }
18991
                                                        }
18992
                                                    });
18993
                                                }
18994
                                                if (custumFunc) {
18995
                                                    eval(custumFunc)
18996
                                                }
18997
                                            }
18998
                                        }
18999
                                    },
19000
                                    filter: {
19001
                                        type: 'list',
19002
                                        itemDefaults: {
19003
                                            emptyText: 'Search for...'
19004
                                        }
19005
                                    }
19006
                                });
19007
                            } else if (rec.SearchType == '5') {							
19008
                                var valueField = null;
19009
                                var displayValue = null;
19010
                                var AdditionaldisplayValue = null;
19011
                                var TableRef = undefined;
19012
                                if (rec.TableRef != '') {
19013
                                    TableRef = rec.TableRef;
19014
                                    Ext.Ajax.request({
19015
                                        async: false,
19016
                                        method: 'POST',
19017
                                        url: '/UserControl/GetStore',
19018
                                        params: {
19019
                                            tableName: 'SDATATABLEFIELD',
19020
                                            param: 'TableName[equal]' + rec.TableRef
19021
                                        },
19022
                                        success: function (response) {
19023
                                            var results = Ext.decode(response.responseText);
19024
                                            data_ = results.data;
19025
                                            if (data_ != undefined) {
19026
                                                valueField_ = $.grep(data_, function (r) {
19027
                                                    return r.ValueField == '1'
19028
                                                });
19029
                                                if (valueField_.length > 0) {
19030
                                                    valueField = valueField_[0].FieldName
19031
                                                }
19032

    
19033
                                                displayValue_ = $.grep(data_, function (r) {
19034
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
19035
                                                });
19036
                                                if (displayValue_.length > 0) {
19037
                                                    displayValue = displayValue_[0].FieldName;
19038
                                                }
19039
                                                if (displayValue_.length >= 2) {
19040
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
19041
                                                }
19042
                                            }
19043
                                        }
19044
                                    });
19045
                                }
19046
                                Ext.create('Ext.data.Store', {
19047
                                    storeId: 'store_' + me.tableName + rec.FieldName,
19048
                                    autoLoad: true,
19049
                                    proxy: {
19050
                                        method: 'POST',
19051
                                        type: 'ajax',
19052
                                        url: '/UserControl/GetStoreAuth',
19053
                                        extraParams: {
19054
                                            tableName: TableRef,
19055
                                            param: rec.ParamCombo,
19056
                                            menuId: MinovaUtil.GetMenuID()
19057
                                        },
19058
                                        reader: {
19059
                                            type: 'json',
19060
                                            root: 'data',
19061
                                            totalProperty: 'data[0].TotalCount'
19062
                                        }
19063
                                    }
19064
                                });
19065
                                cols.push({
19066
                                    xtype : 'minovacombocolumn',
19067
                                    hidden: Hidden_,
19068
                                    text: rec.HeaderTitle,
19069
                                    dataIndex: rec.FieldName,
19070
                                    valueField : valueField,
19071
                                    displayField : displayValue,
19072
                                    store : 'store_' + me.tableName + rec.FieldName,
19073
									minWidth: 150,
19074
                                    tpl: Ext.create('Ext.XTemplate',
19075
                                            '<ul class="x-list-plain"><tpl for=".">',
19076
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
19077
                                            '</tpl></ul>'),
19078
                                    displayTpl: Ext.create('Ext.XTemplate',
19079
                                        '<tpl for=".">',
19080
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
19081
                                        '</tpl>'),
19082
                                    editor: {
19083
                                        allowBlank: null_,
19084
                                        xtype: 'combobox',
19085
                                        readOnly: ReadOnly_,
19086
                                        id: rec.TableName + rec.FieldName,
19087
                                        nameTable: rec.TableName,
19088
                                        fieldGrid: rec.FieldName,
19089
                                        valueField: valueField,
19090
                                        displayField: displayValue,
19091
                                        store: 'store_' + me.tableName + rec.FieldName,
19092
                                        value: rec.DefaultValue,
19093
                                        tpl: Ext.create('Ext.XTemplate',
19094
                                            '<ul class="x-list-plain"><tpl for=".">',
19095
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
19096
                                            '</tpl></ul>'),
19097
                                        displayTpl: Ext.create('Ext.XTemplate',
19098
                                            '<tpl for=".">',
19099
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
19100
                                            '</tpl>')
19101
                                    },
19102
                                    renderer: function (value) {
19103
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
19104
                                        var index = store.find(valueField, value);
19105
                                        var val = "";
19106
                                        if (index != -1) {
19107
                                            var rc = store.getAt(index);
19108
                                            //val = rc.get(displayValue);
19109
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
19110
                                        } else {
19111
                                            val = value;
19112
                                        }
19113
                                        return val;
19114
                                    },
19115
                                    filter: {
19116
                                        type: 'list',
19117
                                        itemDefaults: {
19118
                                            emptyText: 'Search for...'
19119
                                        }
19120
                                    }
19121
                                });
19122
                            } else if (rec.SearchType == '2') {
19123
                                var triger = (rec.TriggerCombo).split('$');
19124
                                var targetField_ = triger[0];
19125
                                var fieldValue_ = triger[1];
19126
                                cols.push({
19127
                                    text: rec.HeaderTitle,
19128
                                    hidden: Hidden_,
19129
                                    dataIndex: rec.FieldName,
19130
                                    filter: {
19131
                                        itemDefaults: {
19132
                                            emptyText: 'Search for...'
19133
                                        }
19134
                                    },
19135
                                    editor: {
19136
                                        allowBlank: null_,
19137
                                        xtype: 'minovalookupgrid',
19138
                                        readOnly: ReadOnly_,
19139
                                        isGrid: true,
19140
                                        fieldTarget: targetField_,
19141
                                        fieldValue: fieldValue_,
19142
                                        isGrid: true,
19143
                                        id: tableName + rec.FieldName,
19144
                                        tableName: rec.TableRef,
19145
                                        triggerCls: 'x-form-search-trigger',
19146
                                        vtype: 'alphanum',
19147
                                        listeners: {
19148
                                            change: function (val) {
19149
                                                var custumFunc = rec.SelectFunction;
19150
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19151
                                                    Ext.Ajax.request({
19152
                                                        async: false,
19153
                                                        method: 'POST',
19154
                                                        url: '/UserControl/GetStore',
19155
                                                        params: {
19156
                                                            tableName: 'PCMFUNC',
19157
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19158
                                                        },
19159
                                                        success: function (response) {
19160
                                                            var results = Ext.decode(response.responseText);
19161
                                                            data_ = results.data[0];
19162
                                                            if (data_ != undefined) {
19163
                                                                custumFunc = data_.FunctionCode;
19164
                                                            }
19165
                                                        }
19166
                                                    });
19167
                                                }
19168
                                                if (custumFunc) {
19169
                                                    eval(custumFunc)
19170
                                                }
19171
                                            }
19172
                                        }
19173
                                    }
19174
                                });
19175
                            } else if (rec.SearchType == '3') {
19176
                                cols.push({
19177
                                    text: rec.HeaderTitle,
19178
                                    hidden: Hidden_,
19179
                                    dataIndex: rec.FieldName,
19180
                                    filter: {
19181
                                        itemDefaults: {
19182
                                            emptyText: 'Search for...'
19183
                                        }
19184
                                    },
19185
                                    editor: {
19186
                                        allowBlank: null_,
19187
                                        xtype: 'MinovaLookupTree',
19188
                                        readOnly: ReadOnly_,
19189
                                        id: tableName + rec.FieldName,
19190
                                        tableName: rec.TableRef,
19191
                                        triggerCls: 'x-form-search-trigger',
19192
                                        vtype: 'alphanum',
19193
                                        treeSructure: rec.SearchFunction,
19194
                                        objClassValue: rec.ParamCombo,
19195
                                        listeners: {
19196
                                            change: function (val) {
19197
                                                var custumFunc = rec.SelectFunction;
19198
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19199
                                                    Ext.Ajax.request({
19200
                                                        async: false,
19201
                                                        method: 'POST',
19202
                                                        url: '/UserControl/GetStore',
19203
                                                        params: {
19204
                                                            tableName: 'PCMFUNC',
19205
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19206
                                                        },
19207
                                                        success: function (response) {
19208
                                                            var results = Ext.decode(response.responseText);
19209
                                                            data_ = results.data[0];
19210
                                                            if (data_ != undefined) {
19211
                                                                custumFunc = data_.FunctionCode;
19212
                                                            }
19213
                                                        }
19214
                                                    });
19215
                                                }
19216
                                                if (custumFunc) {
19217
                                                    eval(custumFunc)
19218
                                                }
19219
                                            }
19220
                                        }
19221
                                    }
19222
                                });
19223
                            } 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) {
19224
                                var triger = (rec.TriggerCombo).split('&');
19225
                                var targetField_ = triger[0];
19226
                                var fieldValue_ = triger[0];
19227
                                cols.push({
19228
                                    text: rec.HeaderTitle,
19229
                                    hidden: Hidden_,
19230
                                    dataIndex: rec.FieldName,
19231
                                    filter: {
19232
                                        itemDefaults: {
19233
                                            emptyText: 'Search for...'
19234
                                        }
19235
                                    },
19236
                                    editor: {
19237
                                        allowBlank: null_,
19238
                                        xtype: 'lookupemployee',
19239
                                        readOnly: ReadOnly_,
19240
                                        isGrid: true,
19241
                                        fieldTarget: targetField_,
19242
                                        fieldValue: fieldValue_,
19243
                                        isGrid: true,
19244
                                        id: tableName + rec.FieldName,
19245
                                        tableName: rec.TableRef,
19246
                                        triggerCls: 'x-form-search-trigger',
19247
                                        vtype: 'alphanum',
19248
                                        listeners: {
19249
                                            change: function (val) {
19250
                                                var custumFunc = rec.SelectFunction;
19251
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19252
                                                    Ext.Ajax.request({
19253
                                                        async: false,
19254
                                                        method: 'POST',
19255
                                                        url: '/UserControl/GetStore',
19256
                                                        params: {
19257
                                                            tableName: 'PCMFUNC',
19258
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19259
                                                        },
19260
                                                        success: function (response) {
19261
                                                            var results = Ext.decode(response.responseText);
19262
                                                            data_ = results.data[0];
19263
                                                            if (data_ != undefined) {
19264
                                                                custumFunc = data_.FunctionCode;
19265
                                                            }
19266
                                                        }
19267
                                                    });
19268
                                                }
19269
                                                if (custumFunc) {
19270
                                                    eval(custumFunc)
19271
                                                }
19272
                                            }
19273
                                        }
19274
                                    }
19275
                                });
19276
                            } else if (rec.SearchType == '4' && isLookup != true) {
19277
                                cols.push({
19278
                                    text: rec.HeaderTitle,
19279
                                    hidden: Hidden_,
19280
                                    dataIndex: rec.FieldName,
19281
                                    filter: {
19282
                                        itemDefaults: {
19283
                                            emptyText: 'Search for...'
19284
                                        }
19285
                                    },
19286
                                    editor: {
19287
                                        allowBlank: null_,
19288
                                        xtype: 'lookupemployee',
19289
                                        readOnly: ReadOnly_,
19290
                                        isGrid: true,
19291
                                        fieldTarget: targetField_,
19292
                                        fieldValue: fieldValue_,
19293
                                        isGrid: true,
19294
                                        id: tableName + rec.FieldName,
19295
                                        tableName: rec.TableRef,
19296
                                        triggerCls: 'x-form-search-trigger',
19297
                                        vtype: 'alphanum',
19298
                                        listeners: {
19299
                                            change: function (val) {
19300
                                                var custumFunc = rec.SelectFunction;
19301
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19302
                                                    Ext.Ajax.request({
19303
                                                        async: false,
19304
                                                        method: 'POST',
19305
                                                        url: '/UserControl/GetStore',
19306
                                                        params: {
19307
                                                            tableName: 'PCMFUNC',
19308
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19309
                                                        },
19310
                                                        success: function (response) {
19311
                                                            var results = Ext.decode(response.responseText);
19312
                                                            data_ = results.data[0];
19313
                                                            if (data_ != undefined) {
19314
                                                                custumFunc = data_.FunctionCode;
19315
                                                            }
19316
                                                        }
19317
                                                    });
19318
                                                }
19319
                                                if (custumFunc) {
19320
                                                    eval(custumFunc)
19321
                                                }
19322
                                            }
19323
                                        }
19324
                                    }
19325
                                });
19326
                            } else if (rec.FixedValue != '') {
19327
                                cols.push({
19328
                                    text: rec.HeaderTitle,
19329
                                    hidden: Hidden_,
19330
                                    dataIndex: rec.FieldName,
19331
									
19332
                                    filter: {
19333
                                        itemDefaults: {
19334
                                            emptyText: 'Search for...'
19335
                                        }
19336
                                    },
19337
									autoSizeColumn: true,
19338
								width: 200,
19339
                                    editor: {
19340
                                        allowBlank: null_,
19341
                                        xtype: 'minovafixvalue',
19342
                                        readOnly: ReadOnly_,
19343
										forceSelection: false,
19344
                                        id: tableName + rec.FieldName,
19345
                                        nameTable: tableName,
19346
                                        fieldGrid: rec.FieldName,
19347
                                        fixedValue: rec.FixedValue,
19348
                                        valueField: 'code',
19349
                                        displayField: 'desc',
19350
                                        value: defaultValue,
19351
											/*Add by Midi 12 Juni 2019*/
19352
									listeners: {
19353
										change: function (val) {
19354
											var custumFunc = rec.SelectFunction;
19355
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19356
												Ext.Ajax.request({
19357
													async: false,
19358
													method: 'POST',
19359
													url: '/UserControl/GetStore',
19360
													params: {
19361
														tableName: 'PCMFUNC',
19362
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19363
													},
19364
													success: function (response) {
19365
														var results = Ext.decode(response.responseText);
19366
														var dt = results.data[0];
19367
														if (dt != undefined) {
19368
															custumFunc = dt.FunctionCode;
19369
														}
19370
													}
19371
												});
19372
											}
19373
											if (custumFunc) {
19374
												eval(custumFunc)
19375
											}
19376
										}
19377
									}
19378
									//
19379
                                    },
19380
                                    renderer: function (value) {
19381
                                        var val = "";
19382
                                        var storeData = [];
19383
                                        var str = rec.FixedValue;
19384
                                        var hasil = str.split('||');
19385
                                        hasil.forEach(function (h) {
19386
                                            store_ = h.split('=')
19387
                                            storeData.push({
19388
                                                code: store_[0],
19389
                                                desc: store_[1]
19390
                                            });
19391
                                        });
19392
                                        var item = storeData.find(x => x.code == value);
19393
                                        if (item != undefined) {
19394
                                            val = item.desc;
19395
                                        }
19396
                                        return val;
19397
                                    }
19398
                                });
19399
                            } else if (rec.FieldDataType == 3) {
19400
                                cols.push({
19401
                                    text: rec.HeaderTitle,
19402
                                    hidden: Hidden_,
19403
                                    dataIndex: rec.FieldName,
19404
									isSummary:isSum,
19405
                                    filter: {
19406
                                        itemDefaults: {
19407
                                            emptyText: 'Search for...'
19408
                                        }
19409
                                    },
19410
								autoSizeColumn: true,
19411
								width: 200,
19412
                                    editor: {
19413
                                        allowBlank: null_,
19414
                                        xtype: 'textfield',
19415
                                        readOnly: ReadOnly_,
19416
                                        id: tableName + rec.FieldName,
19417
                                        nameTable: rec.TableName,
19418
                                        fieldGrid: rec.FieldName,
19419
                                        vtype: 'validateDecimal',
19420
                                        maxLength: rec.Length,
19421
                                        precision: rec.Prec,
19422
                                        fieldStyle: 'text-align:right;',
19423
                                        value: defaultValue,
19424
                                        listeners: {
19425
                                            change: function (val) {
19426
                                                var custumFunc = rec.SelectFunction;
19427
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19428
                                                    Ext.Ajax.request({
19429
                                                        async: false,
19430
                                                        method: 'POST',
19431
                                                        url: '/UserControl/GetStore',
19432
                                                        params: {
19433
                                                            tableName: 'PCMFUNC',
19434
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19435
                                                        },
19436
                                                        success: function (response) {
19437
                                                            var results = Ext.decode(response.responseText);
19438
                                                            var dt = results.data[0];
19439
                                                            if (dt != undefined) {
19440
                                                                custumFunc = dt.FunctionCode;
19441
                                                            }
19442
                                                        }
19443
                                                    });
19444
                                                }
19445
                                                if (custumFunc) {
19446
                                                    eval(custumFunc)
19447
                                                }
19448
                                            }
19449
                                        }
19450
                                    }
19451
                                });
19452
                            } else {
19453
                                cols.push({
19454
                                    text: rec.HeaderTitle,
19455
                                    hidden: Hidden_,
19456
                                    dataIndex: rec.FieldName,
19457
									// isSummary: isSum,
19458
                                    filter: {
19459
                                        itemDefaults: {
19460
                                            emptyText: 'Search for...'
19461
                                        }
19462
                                    },
19463
								autoSizeColumn: true,
19464
								width: 200,
19465
								minWidth: 150,
19466
                                    editor: {
19467
                                        allowBlank: null_,
19468
                                        xtype: 'textfield',
19469
                                        readOnly: ReadOnly_,
19470
                                        id: tableName + rec.FieldName,
19471
                                        value: defaultValue,
19472
                                        listeners: {
19473
                                            change: function (val) {
19474
                                                var custumFunc = rec.SelectFunction;
19475
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19476
                                                    Ext.Ajax.request({
19477
                                                        async: false,
19478
                                                        method: 'POST',
19479
                                                        url: '/UserControl/GetStore',
19480
                                                        params: {
19481
                                                            tableName: 'PCMFUNC',
19482
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19483
                                                        },
19484
                                                        success: function (response) {
19485
                                                            var results = Ext.decode(response.responseText);
19486
                                                            data_ = results.data[0];
19487
                                                            if (data_ != undefined) {
19488
                                                                custumFunc = data_.FunctionCode;
19489
                                                            }
19490
                                                        }
19491
                                                    });
19492
                                                }
19493
                                                if (custumFunc) {
19494
                                                    eval(custumFunc)
19495
                                                }
19496
                                            }
19497
                                        }
19498
                                    }
19499
                                });
19500
                            }
19501
                            break
19502
                    }
19503
                } else {
19504
                    cols.push({
19505
                        text: rec.HeaderTitle,
19506
                        hidden: Hidden_,
19507
                        dataIndex: rec.FieldName,
19508
                        hidden: true,
19509
                        editor: {
19510
                            allowBlank: true,
19511
                            xtype: 'textfield',
19512
                            readOnly: ReadOnly_,
19513
                            id: tableName + rec.FieldName,
19514
                            value: defaultValue
19515
                        },
19516
                        filter: {
19517
                            itemDefaults: {
19518
                                emptyText: 'Search for...'
19519
                            }
19520
                        }
19521
                    });
19522
                }
19523
            });
19524
        };
19525
        addData = addData + "})";
19526
        this.cellEditing = new Ext.grid.plugin.CellEditing({
19527
            clicksToEdit: 1
19528
        });
19529
        Ext.applyIf(me, {
19530
            items: [{
19531
                xtype: 'grid',
19532
                autoScroll: true,
19533
                id: gridName,
19534
                name: gridName,
19535
                height: height,
19536
                store: Ext.create('Ext.data.Store', {
19537
                    storeId: storeID,
19538
                    fields: fieldStore,
19539
                    proxy: {
19540
                        method: 'POST',
19541
                        type: 'ajax',
19542
                        url: '',
19543
                        reader: {
19544
                            type: 'json',
19545
                            root: 'data'
19546
                        }
19547
                    }
19548
                }),
19549
                dockedItems: [{
19550
                    xtype: 'toolbar',
19551
                    items: [{
19552
                        text: 'Add',
19553
                        name: 'add' + tableName,
19554
                        iconCls: 'fa-plus-circle',
19555
                        style: 'font-family: FontAwesome',
19556
                        handler: function () {
19557
                            var store = Ext.StoreMgr.lookup(storeID);
19558
                            var data = eval(addData);
19559
                            if (me.transType == "FIN") {
19560
                                var fp = Ext.ComponentQuery.query("[name=FiscalPeriod]")[0].getValue();
19561
                                var fy = Ext.ComponentQuery.query("[name=FiscalYear]")[0].getValue();
19562
                                var cp = Ext.ComponentQuery.query("[name=CompanyID]")[0].getValue();
19563
                                var bu = Ext.ComponentQuery.query("[name=BusinessUnit]")[0].getValue();
19564
                                data["FiscalPeriod"] = fp;
19565
                                data["FiscalYear"] = fy;
19566
                                data["CompanyID"] = cp;
19567
                                data["BusinessUnit"] = bu;
19568
                            }
19569
                            idx = store.getCount();
19570
                            store.insert(idx, data);
19571
                        }
19572
                    }, {
19573
                        text: 'Delete',
19574
                        name: 'delete' + tableName,
19575
                        iconCls: 'fa-trash-o',
19576
                        style: 'font-family: FontAwesome',
19577
                        handler: function () {
19578
                            var me = this,
19579
                            store = Ext.StoreMgr.lookup(storeID);
19580
                            var grid = Ext.getCmp(gridName);
19581
                            Ext.MessageBox.show({
19582
                                title: 'Remove tab',
19583
                                msg: "This will remove. Do you want to continue?",
19584
                                buttons: Ext.MessageBox.YESNO,
19585
                                fn: function (choice) {
19586
                                    console.log(choice);
19587
                                    if (choice === 'yes') {
19588
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
19589
                                        if (selection) {
19590
                                            store.remove(selection);
19591
                                        }
19592
                                    }
19593
                                }
19594
                            });
19595
                        }
19596
                    }
19597
					,{ //// add by Tri nwh 20211119
19598
                        text: 'Check Stock',
19599
						hidden: hideCheckStock,
19600
                        name: 'checkStock' + tableName,
19601
                        //iconCls: 'fa-trash-o',
19602
                        style: 'font-family: FontAwesome',
19603
                        handler: function () { //add by Tri nwh 20220829
19604
							var getPnl = Ext.ComponentQuery.query('[name=panelTabPTRSALESITEMS]')[0];
19605
							var getTbl = getPnl.query('[name=gridCELLGRIDPTRSALESITEMS]')[0];
19606
							var recC = getTbl.store.getNewRecords(); console.log(recC);
19607
							var obj = [];
19608
							for (var i = 0; i < recC.length; i++) {
19609
								var temp = [];
19610
								temp.push(recC[i]);
19611
								Ext.each(temp, function (rec) {
19612
									var x = Ext.decode(Ext.encode(rec.data));
19613
									obj.push(x);
19614
								});
19615
							}
19616
							var __param = Ext.encode(obj);
19617
							store = Ext.StoreMgr.lookup(storeID);
19618
							var afterCheck = store.getNewRecords();
19619
							if (afterCheck.length != '0') {
19620
								store.remove(afterCheck);
19621
							}
19622
							idx = store.getCount();
19623
							var _data = '';
19624
							Ext.Ajax.request({
19625
								async: false,
19626
								method: 'POST',
19627
								url: '/UserControl/GetStore',
19628
								params: {
19629
									tableName: 'PDSTRALLOCATION',
19630
									param: __param
19631
								},
19632
								success: function (response) {
19633
									var results = Ext.decode(response.responseText);
19634
									_data = results.data;
19635
								}
19636
							});
19637
							store.insert(idx, _data);
19638
						}
19639
                    }
19640
                    ]
19641
                }
19642
                ],
19643
                columns: cols,
19644
                selModel: {
19645
                    type: 'cellmodel'
19646
                },
19647
                plugins: [this.cellEditing],
19648
                //For Auto Size Coloum Mode - Nana
19649
                viewConfig: {
19650
                    emptyText: 'No Data Display',
19651
                    deferEmptyText: false,
19652
                    listeners: {
19653
                        refresh: function (dataview) {
19654
                            Ext.each(dataview.panel.columns, function (column) {
19655
                                if (column.autoSizeColumn == false)
19656
                                    column.autoSizeColumn = true;
19657
                                column.autoSize();
19658
                            })
19659
                        }
19660
                    }
19661
                },listeners: {
19662
					'beforeedit': function (editor, e, eOpts) {
19663
						if (e.colIdx == 2 && tableName == 'PTRMATERIALITEM') {
19664
							var store = Ext.StoreMgr.lookup('store_' + tableName + 'MaterialID');
19665
							var itemType = e.record.get('ItemType');
19666
							console.log(itemType);
19667
							if (itemType == '0') {
19668
								store.proxy.extraParams = {
19669
									tableName: 'PDSTRANSITEMS',
19670
									param: "TableName[=]PMDMAT0001",
19671
									menuId: MinovaUtil.GetMenuID()
19672
								};
19673
							} else if (itemType == '1') {
19674
								store.proxy.extraParams = {
19675
									tableName: 'PDSTRANSITEMS',
19676
									param: "TableName[=]PMDSRV0001",
19677
									menuId: MinovaUtil.GetMenuID()
19678
								};
19679
							} else if (itemType == '2') {
19680
								store.proxy.extraParams = {
19681
									tableName: 'PDSTRANSITEMS',
19682
									param: "TableName[=]PMDAST0001",
19683
									menuId: MinovaUtil.GetMenuID()
19684
								};
19685
							} else if (itemType == 'Material') {
19686
								store.proxy.extraParams = {
19687
									tableName: 'PDSTRANSITEMS',
19688
									param: "TableName[=]PMDMAT0001",
19689
									menuId: MinovaUtil.GetMenuID()
19690
								};
19691
							} else {
19692
								store.proxy.extraParams = {
19693
									tableName: '',
19694
									param: "",
19695
									menuId: MinovaUtil.GetMenuID()
19696
								};
19697
							}
19698
							store.removeAll();
19699
							store.reload();
19700
						}
19701
					}
19702
					}
19703
            }
19704
            ]
19705
        });
19706
        me.callParent(arguments);
19707
    }
19708
});
19709
/*Add by Taufan ( Generate Doc Transaction Cell Edit Grid Sum For ERP )*/
19710
Ext.define('MinovaUtil.MinovaES.MinovaDocGridCellEditSum', {
19711
	extend: 'Ext.form.Panel',
19712
	alias: 'widget.docgridcelleditsum',
19713
	requires: [
19714
		'Ext.grid.plugin.CellEditing',
19715
		'Ext.grid.Panel',
19716
		'Ext.grid.RowNumberer'
19717
	],
19718
	autoScroll: true,
19719
	anchor: '100%',
19720
	tableName: undefined,
19721
	docType: undefined,
19722
	transType: undefined,
19723
	docNo: undefined,
19724
	hideButton: undefined,
19725
	multiSelect: undefined,
19726
	initComponent: function () {
19727
		var me = this;
19728
		var isLookup = me.isLookup;
19729
		var hide_ = false;
19730
		var hideUploadDownload = false;
19731
		var widthLock = 250;
19732
		var checkSelection = '';
19733
		
19734
		Ext.Ajax.request({
19735
			async: false,
19736
			method: 'POST',
19737
			url: '/UserControl/GetStore',
19738
			params: {
19739
				tableName: "PCMBSTRANSLIST",
19740
				param: 'TableName[=]' + me.tableName + ',' + 'DocType[=]' + me.docType // add Tri nwh 20240220
19741
			},
19742
			success: function (response) {
19743
				var results = Ext.decode(response.responseText);
19744
				if (results.data[0].UploadDownloadEnable == '0') {
19745
					hideUploadDownload = true;
19746
				} else {
19747
					hideUploadDownload = false;
19748
				}
19749
			}
19750
		});
19751

    
19752
		if (me.hideButton == true) {
19753
			hide_ = true;
19754
		}
19755
		if (me.multiSelect) {
19756
			locking = false;
19757
			checkSelection = 'checkboxmodel';
19758
			widthLock = 40;
19759
		}
19760
		var tableName = me.tableName;
19761
		var cols = [];
19762
		var fieldStore = [];
19763
		var _url = 'GetAllField';
19764
		var hasil = null;
19765
		var height = me.height;
19766
		var storeID = 'store' + me.tableName;
19767
		var gridName = 'grid' + me.name;
19768
		if (me.storeName) {
19769
			storeID = me.storeName;
19770
		}
19771
		var LangID = MinovaUtil.GetLangID();
19772
		var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "'";
19773
		Ext.Ajax.request({
19774
			async: false,
19775
			method: 'POST',
19776
			url: '/UserControl/GetStore',
19777
			params: {
19778
				tableName: 'PDSDOCFIELD',
19779
				param: parameter
19780
			},
19781
			success: function (response) {
19782
				var results = Ext.decode(response.responseText);
19783
				hasil = results.data;
19784
			}
19785
		});
19786
		cols.push({
19787
			xtype: 'rownumberer'
19788
		});
19789
		var addData = '({';
19790
		if (hasil.length > 0) {
19791
			Ext.each(hasil, function (rec) {
19792
				fieldStore.push(rec.FieldName);
19793
				var defaultValue = rec.DefaultValue;
19794
				if (defaultValue.substring(0, 2).toLowerCase() == 'fn') {
19795
					Ext.Ajax.request({
19796
						async: false,
19797
						method: 'POST',
19798
						url: '/UserControl/GetStore',
19799
						params: {
19800
							tableName: 'PCMFUNC',
19801
							param: 'FuncName[equal]' + rec.DefaultValue
19802
						},
19803
						success: function (response) {
19804
							var results = Ext.decode(response.responseText);
19805
							data_ = results.data;
19806
							if (data_.length > 0) {
19807
								defaultValue = eval(data_[0].FunctionCode);
19808
							}
19809
						}
19810
					});
19811
				}
19812
				addData = addData + rec.FieldName + ":" + "'" + defaultValue + "',";
19813
				var null_ = null;
19814
				var ReadOnly_ = false;
19815
				if (rec.IsPrimaryKey == true) {
19816
					null_ = false;
19817
				}
19818
				if (rec.IsRequired == true) {
19819
					null_ = false;
19820
				} else {
19821
					null_ = true;
19822
				}
19823
				var Hidden_ = false;
19824
				if (rec.ReadOnly == '1') {
19825
					ReadOnly_ = true;
19826
				}
19827
				if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
19828
					Hidden_ = true;
19829
					null_ = true;
19830
				}
19831
				var isSum = rec.IsSummary;
19832
				if (rec.GridView == 1) {
19833
					switch (rec.FormatRef) {
19834
					case "date":
19835
						cols.push({
19836
							xtype: 'minovadatecolumn',
19837
							hidden: Hidden_,
19838
							text: rec.HeaderTitle,
19839
							dataIndex: rec.FieldName,
19840
							filter: {
19841
								itemDefaults: {
19842
									emptyText: 'Search for...'
19843
								}
19844
							},
19845
							isSummary: isSum,
19846
							editor: {
19847
								allowBlank: null_,
19848
								xtype: 'datefield',
19849
								hideMode: 'visibility',
19850
								readOnly: ReadOnly_,
19851
								id: tableName + rec.FieldName,
19852
								value: defaultValue
19853
							}
19854
						});
19855
						break
19856
					case "amount":
19857
						cols.push({
19858
							xtype: 'numbercolumn',
19859
							text: rec.HeaderTitle,
19860
							align: 'right',
19861
							dataIndex: rec.FieldName,
19862
							isSummary: isSum,
19863
							hidden: Hidden_,
19864
							filter: {
19865
								itemDefaults: {
19866
									emptyText: 'Search for...'
19867
								}
19868
							},						
19869
							autoSizeColumn: false,
19870
							width: 140,
19871
							editor: {
19872
								allowBlank: null_,
19873
								xtype: 'textfield',
19874
								readOnly: ReadOnly_,
19875
								id: tableName + rec.FieldName,
19876
								nameTable: rec.TableName,
19877
								fieldGrid: rec.FieldName,
19878
								fieldStyle: 'text-align:right;',
19879
								vtype: 'validateMinovaNumber',
19880
								value: '0',
19881
								listeners: {
19882
									change: function (val, recs) {
19883
										var fvalue = val.getValue();
19884
										var custumFunc = rec.SelectFunction;
19885
										if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19886
											Ext.Ajax.request({
19887
												async: false,
19888
												method: 'POST',
19889
												url: '/UserControl/GetStore',
19890
												params: {
19891
													tableName: 'PCMFUNC',
19892
													param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19893
												},
19894
												success: function (response) {
19895
													var results = Ext.decode(response.responseText);
19896
													var dt = results.data[0];
19897
													if (dt != undefined) {
19898
														custumFunc = dt.FunctionCode;
19899
													}
19900
												}
19901
											});
19902
										}
19903
										if (custumFunc) {
19904
											eval(custumFunc)
19905
										}
19906
									}
19907
								}
19908
							}
19909
						});
19910
						break
19911
					default:
19912
						if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
19913
							cols.push({
19914
								text: rec.HeaderTitle,
19915
								dataIndex: rec.FieldName,
19916
								width: 100,
19917
								isSummary: isSum,
19918
								filter: {
19919
									type: 'string',
19920
									itemDefaults: {
19921
										emptyText: 'Search for...'
19922
									}
19923
								}
19924
							});
19925
						} else if (rec.SearchType == '0') {
19926
							var valueField = null;
19927
							var displayValue = null;
19928
							var TableRef = undefined;
19929
							if (rec.TableRef != '') {
19930
								TableRef = rec.TableRef;
19931
								Ext.Ajax.request({
19932
									async: false,
19933
									method: 'POST',
19934
									url: '/UserControl/GetStore',
19935
									params: {
19936
										tableName: 'SDATATABLEFIELD',
19937
										param: 'TableName[equal]' + rec.TableRef
19938
									},
19939
									success: function (response) {
19940
										var results = Ext.decode(response.responseText);
19941
										data_ = results.data;
19942
										if (data_ != undefined) {
19943
											valueField_ = $.grep(data_, function (r) {
19944
													return r.ValueField == '1'
19945
												});
19946
											valueField = valueField_[0].FieldName
19947
												displayValue_ = $.grep(data_, function (r) {
19948
													return r.DisplayValue == '1'
19949
												});
19950
											displayValue = displayValue_[0].FieldName
19951
										}
19952
									}
19953
								});
19954
							}
19955
							Ext.create('Ext.data.Store', {
19956
								storeId: 'store_' + me.tableName + rec.FieldName,
19957
								autoLoad: true,
19958
								proxy: {
19959
									method: 'POST',
19960
									type: 'ajax',
19961
									url: '/UserControl/GetStoreAuth',
19962
									extraParams: {
19963
										tableName: TableRef,
19964
										param: rec.ParamCombo,
19965
										menuId: MinovaUtil.GetMenuID()
19966
									},
19967
									reader: {
19968
										type: 'json',
19969
										root: 'data',
19970
										totalProperty: 'data[0].TotalCount'
19971
									}
19972
								}
19973
							});
19974
							cols.push({
19975
								xtype: 'minovacombocolumn',
19976
								hidden: Hidden_,
19977
								text: rec.HeaderTitle,
19978
								dataIndex: rec.FieldName,
19979
								valueField: valueField,
19980
								displayField: displayValue,
19981
								store: 'store_' + me.tableName + rec.FieldName,
19982
								isSummary: isSum,
19983
								autoSizeColumn: true,
19984
								width: 200,
19985
								minWidth: 150,
19986
								editor: {
19987
									allowBlank: null_,
19988
									xtype: 'minovacombobox',
19989
									readOnly: ReadOnly_,
19990
									id: tableName + rec.FieldName,
19991
									valueField: valueField,
19992
									displayField: displayValue,
19993
									store: 'store_' + me.tableName + rec.FieldName,
19994
									forceSelection: false,
19995
									lazyRender: true,
19996
									listeners: {
19997
										change: function (val) {
19998
											var fvalue = val.getValue();
19999
											var custumFunc = rec.SelectFunction;
20000
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20001
												Ext.Ajax.request({
20002
													async: false,
20003
													method: 'POST',
20004
													url: '/UserControl/GetStore',
20005
													params: {
20006
														tableName: 'PCMFUNC',
20007
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20008
													},
20009
													success: function (response) {
20010
														var results = Ext.decode(response.responseText);
20011
														var dt = results.data[0];
20012
														if (dt != undefined) {
20013
															custumFunc = dt.FunctionCode;
20014
														}
20015
													}
20016
												});
20017
											}
20018
											if (custumFunc) {
20019
												eval(custumFunc)
20020
											}
20021
										}
20022
									}
20023
								},
20024
								filter: {
20025
									type: 'list',
20026
									itemDefaults: {
20027
										emptyText: 'Search for...'
20028
									}
20029
								}
20030
							});
20031
						} else if (rec.SearchType == '5') {
20032
							var valueField = null;
20033
							var displayValue = null;
20034
							var AdditionaldisplayValue = null;
20035
							var TableRef = undefined;
20036
							if (rec.TableRef != '') {
20037
								TableRef = rec.TableRef;
20038
								Ext.Ajax.request({
20039
									async: false,
20040
									method: 'POST',
20041
									url: '/UserControl/GetStore',
20042
									params: {
20043
										tableName: 'SDATATABLEFIELD',
20044
										param: 'TableName[equal]' + rec.TableRef
20045
									},
20046
									success: function (response) {
20047
										var results = Ext.decode(response.responseText);
20048
										data_ = results.data;
20049
										if (data_ != undefined) {
20050
											valueField_ = $.grep(data_, function (r) {
20051
													return r.ValueField == '1'
20052
												});
20053
											if (valueField_.length > 0) {
20054
												valueField = valueField_[0].FieldName
20055
											}
20056

    
20057
											displayValue_ = $.grep(data_, function (r) {
20058
													return r.DisplayValue == '1' || r.DisplayValue == '2'
20059
												});
20060
											if (displayValue_.length > 0) {
20061
												displayValue = displayValue_[0].FieldName;
20062
											}
20063
											if (displayValue_.length >= 2) {
20064
												AdditionaldisplayValue = displayValue_[1].FieldName
20065
											}
20066
										}
20067
									}
20068
								});
20069
							}
20070
							Ext.create('Ext.data.Store', {
20071
								storeId: 'store_' + me.tableName + rec.FieldName,
20072
								autoLoad: true,
20073
								proxy: {
20074
									method: 'POST',
20075
									type: 'ajax',
20076
									url: '/UserControl/GetStoreAuth',
20077
									extraParams: {
20078
										tableName: TableRef,
20079
										param: rec.ParamCombo,
20080
										menuId: MinovaUtil.GetMenuID()
20081
									},
20082
									reader: {
20083
										type: 'json',
20084
										root: 'data',
20085
										totalProperty: 'data[0].TotalCount'
20086
									}
20087
								}
20088
							});
20089
							cols.push({
20090
								xtype: 'minovacombocolumn',
20091
								hidden: Hidden_,
20092
								text: rec.HeaderTitle,
20093
								dataIndex: rec.FieldName,
20094
								valueField: valueField,
20095
								displayField: displayValue,
20096
								store: 'store_' + me.tableName + rec.FieldName,
20097
								tpl: Ext.create('Ext.XTemplate',
20098
									'<ul class="x-list-plain"><tpl for=".">',
20099
									'<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
20100
									'</tpl></ul>'),
20101
								displayTpl: Ext.create('Ext.XTemplate',
20102
									'<tpl for=".">',
20103
									'{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
20104
									'</tpl>'),
20105
								editor: {
20106
									allowBlank: null_,
20107
									xtype: 'combobox',
20108
									readOnly: ReadOnly_,
20109
									id: rec.TableName + rec.FieldName,
20110
									nameTable: rec.TableName,
20111
									fieldGrid: rec.FieldName,
20112
									valueField: valueField,
20113
									displayField: displayValue,
20114
									store: 'store_' + me.tableName + rec.FieldName,
20115
									value: rec.DefaultValue,
20116
									tpl: Ext.create('Ext.XTemplate',
20117
										'<ul class="x-list-plain"><tpl for=".">',
20118
										'<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
20119
										'</tpl></ul>'),
20120
									displayTpl: Ext.create('Ext.XTemplate',
20121
										'<tpl for=".">',
20122
										'{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
20123
										'</tpl>'),
20124
										listeners: {
20125
										change: function (val) {
20126
											var fvalue = val.getValue();
20127
											var custumFunc = rec.SelectFunction;
20128
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20129
												Ext.Ajax.request({
20130
													async: false,
20131
													method: 'POST',
20132
													url: '/UserControl/GetStore',
20133
													params: {
20134
														tableName: 'PCMFUNC',
20135
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20136
													},
20137
													success: function (response) {
20138
														var results = Ext.decode(response.responseText);
20139
														var dt = results.data[0];
20140
														if (dt != undefined) {
20141
															custumFunc = dt.FunctionCode;
20142
														}
20143
													}
20144
												});
20145
											}
20146
											if (custumFunc) {
20147
												eval(custumFunc)
20148
											}
20149
										}
20150
									}
20151

    
20152
								},
20153
								renderer: function (value) {
20154
									var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
20155
									console.log(store);
20156
									var index = store.find(valueField, value);
20157
									var val = "";
20158
									if (index != -1) {
20159
										var rc = store.getAt(index);
20160
										val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
20161
									} else {
20162
										val = value;
20163
									}
20164
									return val;
20165
								},
20166
								filter: {
20167
									type: 'list',
20168
									itemDefaults: {
20169
										emptyText: 'Search for...'
20170
									}
20171
								},
20172
								tpl: Ext.create('Ext.XTemplate',
20173
									'<ul class="x-list-plain"><tpl for=".">',
20174
									'<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
20175
									'</tpl></ul>'),
20176
								displayTpl: Ext.create('Ext.XTemplate',
20177
									'<tpl for=".">',
20178
									'{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
20179
									'</tpl>')
20180
							});
20181
						} else if (rec.SearchType == '2') {
20182
							var triger = (rec.TriggerCombo).split('$');
20183
							var targetField_ = triger[0];
20184
							var fieldValue_ = triger[1];
20185
							cols.push({
20186
								text: rec.HeaderTitle,
20187
								hidden: Hidden_,
20188
								dataIndex: rec.FieldName,
20189
								isSummary: isSum,
20190
								filter: {
20191
									itemDefaults: {
20192
										emptyText: 'Search for...'
20193
									}
20194
								},
20195
								autoSizeColumn: true,
20196
								width: 200,
20197
								editor: {
20198
									allowBlank: null_,
20199
									xtype: 'minovalookupgrid',
20200
									readOnly: ReadOnly_,
20201
									isGrid: true,
20202
									fieldTarget: targetField_,
20203
									fieldValue: fieldValue_,
20204
									isGrid: true,
20205
									id: tableName + rec.FieldName,
20206
									tableName: rec.TableRef,
20207
									triggerCls: 'x-form-search-trigger',
20208
									vtype: 'alphanum',
20209
									listeners: {
20210
										change: function (val) {
20211
											var custumFunc = rec.SelectFunction;
20212
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20213
												Ext.Ajax.request({
20214
													async: false,
20215
													method: 'POST',
20216
													url: '/UserControl/GetStore',
20217
													params: {
20218
														tableName: 'PCMFUNC',
20219
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20220
													},
20221
													success: function (response) {
20222
														var results = Ext.decode(response.responseText);
20223
														var dt = results.data[0];
20224
														if (dt != undefined) {
20225
															custumFunc = dt.FunctionCode;
20226
														}
20227
													}
20228
												});
20229
											}
20230
											if (custumFunc) {
20231
												eval(custumFunc)
20232
											}
20233
										}
20234
									}
20235
								}
20236
							});
20237
						} else if (rec.SearchType == '3') {
20238
							cols.push({
20239
								text: rec.HeaderTitle,
20240
								hidden: Hidden_,
20241
								dataIndex: rec.FieldName,
20242
								isSummary: isSum,
20243
								filter: {
20244
									itemDefaults: {
20245
										emptyText: 'Search for...'
20246
									}
20247
								},
20248
								autoSizeColumn: true,
20249
								width: 200,
20250
								editor: {
20251
									allowBlank: null_,
20252
									xtype: 'MinovaLookupTree',
20253
									readOnly: ReadOnly_,
20254
									id: tableName + rec.FieldName,
20255
									tableName: rec.TableRef,
20256
									triggerCls: 'x-form-search-trigger',
20257
									vtype: 'alphanum',
20258
									treeSructure: rec.SearchFunction,
20259
									objClassValue: rec.ParamCombo,
20260
									listeners: {
20261
										change: function (val) {
20262
											var custumFunc = rec.SelectFunction;
20263
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20264
												Ext.Ajax.request({
20265
													async: false,
20266
													method: 'POST',
20267
													url: '/UserControl/GetStore',
20268
													params: {
20269
														tableName: 'PCMFUNC',
20270
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20271
													},
20272
													success: function (response) {
20273
														var results = Ext.decode(response.responseText);
20274
														var dt = results.data[0];
20275
														if (dt != undefined) {
20276
															custumFunc = dt.FunctionCode;
20277
														}
20278
													}
20279
												});
20280
											}
20281
											if (custumFunc) {
20282
												eval(custumFunc)
20283
											}
20284
										}
20285
									}
20286
								}
20287
							});
20288
						} 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) {
20289
							var triger = (rec.TriggerCombo).split('&');
20290
							var targetField_ = triger[0];
20291
							var fieldValue_ = triger[0];
20292
							cols.push({
20293
								text: rec.HeaderTitle,
20294
								hidden: Hidden_,
20295
								dataIndex: rec.FieldName,
20296
								isSummary: isSum,
20297
								filter: {
20298
									itemDefaults: {
20299
										emptyText: 'Search for...'
20300
									}
20301
								},
20302
								autoSizeColumn: true,
20303
								width: 200,
20304
								editor: {
20305
									allowBlank: null_,
20306
									xtype: 'lookupemployee',
20307
									readOnly: ReadOnly_,
20308
									isGrid: true,
20309
									fieldTarget: targetField_,
20310
									fieldValue: fieldValue_,
20311
									isGrid: true,
20312
									id: tableName + rec.FieldName,
20313
									tableName: rec.TableRef,
20314
									triggerCls: 'x-form-search-trigger',
20315
									vtype: 'alphanum',
20316
									listeners: {
20317
										change: function (val) {
20318
											var custumFunc = rec.SelectFunction;
20319
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20320
												Ext.Ajax.request({
20321
													async: false,
20322
													method: 'POST',
20323
													url: '/UserControl/GetStore',
20324
													params: {
20325
														tableName: 'PCMFUNC',
20326
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20327
													},
20328
													success: function (response) {
20329
														var results = Ext.decode(response.responseText);
20330
														var dt = results.data[0];
20331
														if (dt != undefined) {
20332
															custumFunc = dt.FunctionCode;
20333
														}
20334
													}
20335
												});
20336
											}
20337
											if (custumFunc) {
20338
												eval(custumFunc)
20339
											}
20340
										}
20341
									}
20342
								}
20343
							});
20344
						} else if (rec.SearchType == '4' && isLookup != true) {
20345
							cols.push({
20346
								text: rec.HeaderTitle,
20347
								hidden: Hidden_,
20348
								dataIndex: rec.FieldName,
20349
								isSummary: isSum,
20350
								filter: {
20351
									itemDefaults: {
20352
										emptyText: 'Search for...'
20353
									}
20354
								},
20355
								autoSizeColumn: true,
20356
								width: 200,
20357
								editor: {
20358
									allowBlank: null_,
20359
									xtype: 'lookupemployee',
20360
									readOnly: ReadOnly_,
20361
									isGrid: true,
20362
									fieldTarget: targetField_,
20363
									fieldValue: fieldValue_,
20364
									isGrid: true,
20365
									id: tableName + rec.FieldName,
20366
									tableName: rec.TableRef,
20367
									triggerCls: 'x-form-search-trigger',
20368
									vtype: 'alphanum',
20369
									listeners: {
20370
										change: function (val) {
20371
											var custumFunc = rec.SelectFunction;
20372
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20373
												Ext.Ajax.request({
20374
													async: false,
20375
													method: 'POST',
20376
													url: '/UserControl/GetStore',
20377
													params: {
20378
														tableName: 'PCMFUNC',
20379
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20380
													},
20381
													success: function (response) {
20382
														var results = Ext.decode(response.responseText);
20383
														var dt = results.data[0];
20384
														if (dt != undefined) {
20385
															custumFunc = dt.FunctionCode;
20386
														}
20387
													}
20388
												});
20389
											}
20390
											if (custumFunc) {
20391
												eval(custumFunc)
20392
											}
20393
										}
20394
									}
20395
								}
20396
							});
20397
						} else if (rec.FixedValue != '') {
20398
							cols.push({
20399
								text: rec.HeaderTitle,
20400
								hidden: Hidden_,
20401
								dataIndex: rec.FieldName,
20402
								isSummary: isSum,
20403
								filter: {
20404
									itemDefaults: {
20405
										emptyText: 'Search for...'
20406
									}
20407
								},
20408
								autoSizeColumn: true,
20409
								width: 200,
20410
								editor: {
20411
									allowBlank: null_,
20412
									xtype: 'minovafixvalue',
20413
									readOnly: ReadOnly_,
20414
									forceSelection: false,
20415
									id: tableName + rec.FieldName,
20416
									nameTable: tableName,
20417
									fieldGrid: rec.FieldName,
20418
									fixedValue: rec.FixedValue,
20419
									valueField: 'code',
20420
									displayField: 'desc',
20421
									value: defaultValue,
20422
									/*Add by Midi 12 Juni 2019*/
20423
									listeners: {
20424
										change: function (val) {
20425
											var custumFunc = rec.SelectFunction;
20426
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20427
												Ext.Ajax.request({
20428
													async: false,
20429
													method: 'POST',
20430
													url: '/UserControl/GetStore',
20431
													params: {
20432
														tableName: 'PCMFUNC',
20433
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20434
													},
20435
													success: function (response) {
20436
														var results = Ext.decode(response.responseText);
20437
														var dt = results.data[0];
20438
														if (dt != undefined) {
20439
															custumFunc = dt.FunctionCode;
20440
														}
20441
													}
20442
												});
20443
											}
20444
											if (custumFunc) {
20445
												eval(custumFunc)
20446
											}
20447
										}
20448
									}
20449
									//
20450
								},
20451
								renderer: function (value) {
20452
									var val = "";
20453
									var storeData = [];
20454
									var str = rec.FixedValue;
20455
									var hasil = str.split('||');
20456
									hasil.forEach(function (h) {
20457
										store_ = h.split('=')
20458
											storeData.push({
20459
												code: store_[0],
20460
												desc: store_[1]
20461
											});
20462
									});
20463
									var item = storeData.find(x => x.code == value);
20464
									if (item != undefined) {
20465
										val = item.desc;
20466
									}
20467
									return val;
20468
								}
20469
							});
20470
						} else if (rec.FieldDataType == 3) {
20471
							cols.push({
20472
								text: rec.HeaderTitle,
20473
								hidden: Hidden_,
20474
								dataIndex: rec.FieldName,
20475
								isSummary: isSum,
20476
								filter: {
20477
									itemDefaults: {
20478
										emptyText: 'Search for...'
20479
									}
20480
								},
20481
								autoSizeColumn: true,
20482
								width: 200,
20483
								editor: {
20484
									allowBlank: null_,
20485
									xtype: 'textfield',
20486
									readOnly: ReadOnly_,
20487
									id: tableName + rec.FieldName,
20488
									nameTable: rec.TableName,
20489
									fieldGrid: rec.FieldName,
20490
									vtype: 'validateDecimal',
20491
									maxLength: rec.Length,
20492
									precision: rec.Prec,
20493
									fieldStyle: 'text-align:right;',
20494
									value: defaultValue,
20495
									listeners: {
20496
										change: function (val) {
20497
											var custumFunc = rec.SelectFunction;
20498
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20499
												Ext.Ajax.request({
20500
													async: false,
20501
													method: 'POST',
20502
													url: '/UserControl/GetStore',
20503
													params: {
20504
														tableName: 'PCMFUNC',
20505
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20506
													},
20507
													success: function (response) {
20508
														var results = Ext.decode(response.responseText);
20509
														var dt = results.data[0];
20510
														if (dt != undefined) {
20511
															custumFunc = dt.FunctionCode;
20512
														}
20513
													}
20514
												});
20515
											}
20516
											if (custumFunc) {
20517
												eval(custumFunc)
20518
											}
20519
										}
20520
									}
20521
								}
20522
							});
20523
						} else {
20524
							cols.push({
20525
								text: rec.HeaderTitle,
20526
								hidden: Hidden_,
20527
								dataIndex: rec.FieldName,
20528
								isSummary: isSum,
20529
								filter: {
20530
									itemDefaults: {
20531
										emptyText: 'Search for...'
20532
									}
20533
								},
20534
								autoSizeColumn: true,
20535
								width: 200,
20536
								editor: {
20537
									allowBlank: null_,
20538
									xtype: 'textfield',
20539
									readOnly: ReadOnly_,
20540
									id: tableName + rec.FieldName,
20541
									value: defaultValue,
20542
									vtype: 'validateMinovaXss', //// Tri 20210906
20543
									listeners: {
20544
										change: function (val) {
20545
											var custumFunc = rec.SelectFunction;
20546
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
20547
												Ext.Ajax.request({
20548
													async: false,
20549
													method: 'POST',
20550
													url: '/UserControl/GetStore',
20551
													params: {
20552
														tableName: 'PCMFUNC',
20553
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
20554
													},
20555
													success: function (response) {
20556
														var results = Ext.decode(response.responseText);
20557
														var dt = results.data[0];
20558
														if (dt != undefined) {
20559
															custumFunc = dt.FunctionCode;
20560
														}
20561
													}
20562
												});
20563
											}
20564
											if (custumFunc) {
20565
												eval(custumFunc)
20566
											}
20567
										}
20568
									}
20569
								}
20570
							});
20571
						}
20572
						break
20573
					}
20574
				} else {
20575
					cols.push({
20576
						text: rec.HeaderTitle,
20577
						hidden: Hidden_,
20578
						dataIndex: rec.FieldName,
20579
						isSummary: isSum,
20580
						hidden: true,
20581
						editor: {
20582
							allowBlank: true,
20583
							xtype: 'textfield',
20584
							readOnly: ReadOnly_,
20585
							id: tableName + rec.FieldName,
20586
							value: defaultValue,
20587
							vtype: 'validateMinovaXss' //// Tri 20210906
20588
						},
20589
						filter: {
20590
							itemDefaults: {
20591
								emptyText: 'Search for...'
20592
							}
20593
						}
20594
					});
20595
				}
20596
			});
20597
		};
20598
		addData = addData + "})";
20599
		Ext.applyIf(me, {
20600
			items: [{
20601
					xtype: 'grid',
20602
					autoScroll: true,
20603
					id: gridName,
20604
					name: gridName,
20605
					height: height,
20606
					store: Ext.create('Ext.data.Store', {
20607
						storeId: storeID,
20608
						fields: fieldStore,
20609
						proxy: {
20610
							method: 'POST',
20611
							type: 'ajax',
20612
							url: '',
20613
							reader: {
20614
								type: 'json',
20615
								root: 'data'
20616
							}
20617
						}
20618
					}),
20619
					dockedItems: [{
20620
							xtype: 'toolbar',
20621
							items: [{
20622
									text: 'Add',
20623
									hidden: hide_,
20624
									name: 'add' + tableName,
20625
									iconCls: 'fa-plus-circle',
20626
									style: 'font-family: FontAwesome',
20627
									handler: function () {
20628
										var store = Ext.StoreMgr.lookup(storeID);
20629
										var data = eval(addData);
20630
										if (me.transType == "FIN") {
20631
											var fp = Ext.ComponentQuery.query("[name=FiscalPeriod]")[0].getValue();
20632
											var fy = Ext.ComponentQuery.query("[name=FiscalYear]")[0].getValue();
20633
											var cp = Ext.ComponentQuery.query("[name=CompanyID]")[0].getValue();
20634
											var bu = Ext.ComponentQuery.query("[name=BusinessUnit]")[0].getValue();
20635
											var cc = Ext.ComponentQuery.query("[name=CostCenter]")[0].getValue();
20636
											// var desc = Ext.ComponentQuery.query("[name=Description]")[0].getValue();
20637
											data["FiscalPeriod"] = fp;
20638
											data["FiscalYear"] = fy;
20639
											data["CompanyID"] = cp;
20640
											data["BusinessUnit"] = bu;
20641
											// data["CostCenter"] = cc;
20642
											// data["Description"] = desc;
20643
										}
20644
										/*idx = store.getCount();
20645
										store.insert(idx, data);*/
20646
										
20647
										idx = store.getCount();
20648
										if(parseFloat(idx) <= 39) //// Tri 20210907
20649
										{
20650
											if(store.getCount() > 0 && me.transType == "FIN") //// Tri nwh 20211111, edit by Tri nwh 20220420
20651
											{	console.log('siwan'); 
20652
												var IsCostCenter = '';
20653
												var grid = Ext.getCmp(gridName);
20654
												var selection = grid.getView().getSelectionModel().getSelection()[0];
20655
												if( selection != undefined)   //// add by Tri nwh 20211124
20656
												{
20657
													var GLAccountID = selection.data.GLAccountID;
20658
													var CostCenter = selection.data.CostCenter;
20659
													MinovaUtil.ExecuteParamQuery({
20660
														ID: 'FINANCEITEMISCOSTCENTER',
20661
														GlAccountID: GLAccountID
20662
													}, function (s) {
20663
														var result = Ext.decode(s.responseText);
20664
														var dt = Ext.decode(Ext.decode(result.data));
20665
														IsCostCenter = dt[0].CostCenter;
20666
													});
20667
													
20668
													var AccountGroup = selection.data.AccountGroup;
20669
													var CashActivityType = selection.data.CashActivityType;
20670
													var CashActivityDetail = selection.data.CashActivityDetail;	
20671
												}
20672
												
20673
												if(IsCostCenter == '1')
20674
												{	console.log('chani');
20675
													var panelHead = Ext.ComponentQuery.query('[name=MainHeaderDocument]')[0];
20676
													var formheader = panelHead.getForm();
20677
													console.log(formheader.findField("DocStatus").getValue());
20678
													if(formheader.findField("DocStatus").getValue() == '9')
20679
													{
20680
														if(CostCenter == '' || CostCenter.isnull == true)
20681
														{	console.log('1');
20682
															alert('please fill field cost center'); 
20683
														}
20684
														else
20685
														{	console.log('2');
20686
															store.insert(idx, data);
20687
														}
20688
													}
20689
													else
20690
													{	console.log('3');
20691
														store.insert(idx, data);
20692
													}
20693
												}
20694
												else
20695
												{	
20696
													if(AccountGroup == 'CA')
20697
													{
20698
														if(CashActivityType == '' || CashActivityType.isnull == true || CashActivityDetail == '' || CashActivityDetail.isnull == true)
20699
														{
20700
															alert('Please fill field Cash Activity Type & Cash Activity Detail'); 
20701
														}
20702
														else
20703
														{
20704
															console.log('6');
20705
															store.insert(idx, data);
20706
														}
20707
													}
20708
													else
20709
													{
20710
														console.log('4');
20711
														store.insert(idx, data);
20712
													}
20713
												}
20714
											}
20715
											else
20716
											{	console.log('5');
20717
												store.insert(idx, data);
20718
											}
20719
											//alert('nwh');
20720
											
20721
										}
20722
										else if (parseFloat(idx) > 39)
20723
										{
20724
											var tb = Ext.ComponentQuery.query('[name=panelTab]')[0];
20725
											var activeTab = tb.activeTab;
20726
											var tbl = activeTab.tbl;
20727
											var btnadd = Ext.ComponentQuery.query('[name=add' + tbl + ']')[0].setDisabled(true);
20728
											//alert('Can not insert data, because row data has reached the maximum');
20729
											alert('Anda sudah melebihi batas maksimal penginputan');
20730
										}
20731
									}
20732
	
20733
								}, {
20734
									text: 'Delete',
20735
									hidden: hide_,
20736
									name: 'delete' + tableName,
20737
									iconCls: 'fa-trash-o',
20738
									style: 'font-family: FontAwesome',
20739
									handler: function () {
20740
										var me = this,
20741
										store = Ext.StoreMgr.lookup(storeID)
20742
											var grid = Ext.getCmp(gridName);
20743
										Ext.MessageBox.show({
20744
											title: 'Remove tab',
20745
											msg: "This will remove. Do you want to continue?",
20746
											buttons: Ext.MessageBox.YESNO,
20747
											fn: function (choice) {
20748
												if (choice === 'yes') {
20749
													var selection = grid.getView().getSelectionModel().getSelection()[0];
20750
													if (selection) {
20751
														store.remove(selection);
20752
														var amountdebet = selection.data.AmountDebetCompCurr;  ////// add by tri yooma
20753
														var amountcredit = selection.data.AmountCreditCompCurr;
20754
														var totdebetexist = Ext.ComponentQuery.query('[name=TotalDebet]')[0].getValue().toString();
20755
														var totdebet =  parseFloat(totdebetexist.toString().replace(',', '')) - parseFloat(amountdebet);
20756
														var totcredit = parseFloat(Ext.ComponentQuery.query('[name=TotalCredit]')[0].getValue().toString().replace(',', '')) - amountcredit;
20757
														Ext.ComponentQuery.query('[name=TotalDebet]')[0].setValue(totdebet);
20758
														Ext.ComponentQuery.query('[name=AmountDebet]')[0].setValue(Ext.util.Format.number(totdebet, '0,000.00'));	
20759
														Ext.ComponentQuery.query('[name=TotalCredit]')[0].setValue(totcredit);
20760
														Ext.ComponentQuery.query('[name=AmountCredit]')[0].setValue(Ext.util.Format.number(totcredit, '0,000.00'));
20761
														//alert('nwh');
20762
													}
20763
												}
20764
											}
20765
										});
20766
									}
20767
								}, {
20768
									xtype: 'filefield',
20769
									buttonOnly: true,
20770
									buttonConfig: {
20771
										width: 160,
20772
										text: 'Upload',
20773
										ui: 'default-toolbar',
20774
										iconCls: 'icon-arrow-up',
20775
										style: 'font-family: FontAwesome',
20776
										hidden: hideUploadDownload,
20777
										name: 'upload' + tableName,
20778
										html: "<input id='inputFile' type='file' name='uploaded'/>",
20779
									},
20780
									listeners: {
20781
										change: function (f, value) {
20782
											var store = Ext.StoreMgr.lookup(storeID);
20783
											var newValue = '';
20784
											var afterDot = '';
20785
											var files = event.target.files;
20786
											var fileName = files[0].name;
20787
											var fileType = fileName.substr(fileName.indexOf('.'));
20788
											if (!files || files.length == 0) {
20789
												MinovaMessageError("File Error", "FILOFILE", "");
20790
											} else {
20791
												if (fileType == '.xls' || fileType == '.xlsx') {
20792
													var reader = new FileReader();
20793

    
20794
													//For Browsers other than IE.
20795
													if (reader.readAsBinaryString) {
20796
														reader.onload = function (e) {
20797
															var data = e.target.result;
20798
															//Read the Excel File data.
20799
															var workbook = XLSX.read(data, {
20800
																	type: 'binary'
20801
																});
20802
															//Fetch the name of First Sheet.
20803
															var firstSheet = workbook.SheetNames[0];
20804

    
20805
															//Read all rows from First Sheet into an JSON array.
20806
															var excelRows = XLSX.utils.sheet_to_row_object_array(workbook.Sheets[firstSheet]);
20807
															var data = eval(excelRows);
20808
															var dataLength = data.length;
20809
															idx = store.getCount();
20810
															var seq = idx + 1;
20811
															var dn = Ext.ComponentQuery.query("[name=DocNo]")[0].getValue();
20812
															for (var i = 0; i < dataLength; i++) {
20813
																data[i]["DocNo"] = dn;
20814
																data[i]["DocItemID"] = seq;
20815
																if (me.transType == "MTR" || me.transType == "PUR") {
20816
																	data[i].ARAPID = "";
20817
																	data[i].DocItemRef = "";
20818
																}
20819
																if (me.transType == "MTR") {
20820
																	data[i].Storage = "";
20821
																}
20822
																seq = seq + 1;
20823
															}
20824

    
20825
															var fields = store.model.getFields();
20826
															var gridFields = []
20827
															for (var i = 0; i < fields.length; i++) {
20828
																gridFields.push(fields[i].name);
20829
															}
20830

    
20831
															var index = [];
20832
															// build the index
20833
															for (var x in excelRows[0]) {
20834
																index.push(x);
20835
															}
20836
															var excelFields = []
20837
															for (var i = 0; i < index.length; i++) {
20838
																excelFields.push(index[i]);
20839
															}
20840

    
20841
															var template = [];
20842
															for (var i = 0; i < excelFields.length; i++) {
20843
																for (var j = 0; j < gridFields.length; j++) {
20844
																	if (excelFields[i] === gridFields[j]) {
20845
																		template.push(excelFields[i]);
20846
																	}
20847
																}
20848
															}
20849
															if (excelFields.length === template.length) {
20850
																store.insert(idx, data);
20851
															} else {
20852
																MinovaMessageError("Template Error", "FILOFILETEMPLATE", "");
20853
															}
20854
														};
20855
														reader.readAsBinaryString(files[0]);
20856

    
20857
													} else {
20858
														MinovaMessageError("FileReader Error", "FILOFILEREADER", "");
20859
													}
20860
												} else {
20861
													MinovaMessageError("File Type Error", "FILOUPLOAD", "");
20862
												}
20863
											}
20864
										}
20865
									}
20866
								}, {
20867
									text: 'Download',
20868
									hidden: hideUploadDownload,
20869
									name: 'download' + tableName,
20870
									iconCls: 'icon-arrow-down',
20871
									style: 'font-family: FontAwesome',
20872
									handler: function (b, e) {
20873
										b.up('grid').downloadExcelXml();
20874
									}
20875
								}
20876
							]
20877
						}
20878
					],
20879
					columns: cols,
20880
					selType: 'cellmodel',
20881
					plugins: [
20882
						Ext.create('Ext.grid.plugin.CellEditing', {
20883
							clicksToEdit: 1
20884
						})
20885
					],
20886
					//Add For Auto Size Coloum Mode - Nana
20887
					viewConfig: {
20888
						emptyText: 'No Data Display',
20889
						deferEmptyText: false,
20890
						listeners: {
20891
							refresh: function (dataview) {
20892
								Ext.each(dataview.panel.columns, function (column) {
20893
									if (column.autoSizeColumn == true)
20894
									column.autoSize();
20895
								})
20896
							}
20897
						}
20898
					},
20899
					listeners: {
20900
						'edit': function (editor, e, eOpts) {
20901
							/*Update By Midi 13 Juni 2019*/
20902
							var sumPanel = Ext.ComponentQuery.query('[name=SUM' + tableName + ']')[0];
20903
							var sumForm = sumPanel.getForm();
20904
							var grid = Ext.ComponentQuery.query('[name=' + gridName + ']')[0];
20905
							var sumFields = sumForm.getFields();
20906
							for (var i = 0; i < sumFields.length; i++) {
20907
								var fField = sumFields.items[i].name;
20908
								var fldValue = 0;
20909
								Ext.each(grid.store.getRange(), function (r) {
20910
									var fValue = r.data[fField];
20911
									fldValue = fldValue + parseFloat(fValue);
20912
								});
20913
								
20914
								fldValue = Ext.util.Format.number(fldValue, '0,000.00');
20915
								sumForm.findField(fField).setValue(fldValue);
20916
								if (fField.toLowerCase().includes("cred")) {
20917
                                    if (Ext.ComponentQuery.query('[name=TotalCredit]')[0] != undefined) {
20918
                                        Ext.ComponentQuery.query('[name=TotalCredit]')[0].setValue(fldValue);
20919
                                    }
20920
                                }
20921
                                if (fField.toLowerCase().includes("deb")) {
20922
                                    if (Ext.ComponentQuery.query('[name=TotalDebet]')[0] != undefined) {
20923
                                        Ext.ComponentQuery.query('[name=TotalDebet]')[0].setValue(fldValue);
20924
                                    }
20925
                                }
20926
							}							
20927
							// var grid = Ext.ComponentQuery.query('[name=' + gridName + ']')[0];
20928
							// var fField = e.field;
20929
							// if (e.column.isSummary == '1') {
20930
								// var fldValue = 0;
20931
								// Ext.each(grid.store.getRange(), function (r) {
20932
									// var fValue = r.data[fField];
20933
									// fldValue = fldValue + parseFloat(fValue);
20934
								// });
20935
								// var sumPanel = Ext.ComponentQuery.query('[name=SUM' + tableName + ']')[0];
20936
								// var sumForm = sumPanel.getForm();
20937
								// fldValue = Ext.util.Format.number(fldValue, '0,000.00');
20938
								// sumForm.findField(fField).setValue(fldValue);
20939
							// }
20940
						}
20941
						// ,
20942
						/*Add By Midi For Store Combobox With Param In Grid */
20943
						// 'beforeedit': function (editor, e, eOpts) {
20944
							// if (e.colIdx == 1 && tableName == 'PTRPURCHITEM') {
20945
								// var store = Ext.StoreMgr.lookup('store_' + tableName + 'Material');
20946
								// var itemType = e.record.get('ItemType');
20947
								// store.clearFilter();
20948
								// store.filter('MaterialType', itemType);
20949
							// }
20950
							// // if (e.colIdx == 1 && tableName == 'PTRFINANCEITEM') {
20951
								// // var store = Ext.StoreMgr.lookup('store_' + tableName + 'GLAccountID');
20952
								// // var itemType = e.record.get('CompanyID');
20953
								// // store.clearFilter();
20954
								// // store.filter('CompanyID', itemType);
20955
							// // }
20956
						// }
20957
					}
20958
				}
20959
			]
20960
		});
20961
		me.callParent(arguments);
20962
	}
20963
});
20964
Ext.define('MinovaUtil.MinovaES.LookupDoc', {
20965
	extend : 'Ext.window.Window',
20966
	alias : 'widget.lookupdocument',
20967
	requires : [],
20968
	//height : '87%',
20969
	height : '73%',//saswanto28jan2022
20970
	width : '41%',
20971
	minWidth : '50%',
20972
	maxWidth : '100%',
20973
	bodyPadding : 0,
20974
	formname : undefined,
20975
	name : 'LookupDocumentTrans',
20976
	test : undefined,
20977
	vtype : 'validateMinovaXss',
20978
	targetField : undefined,
20979
	valueField : undefined,
20980
	tableName : undefined,
20981
	LookupFunction : undefined,
20982
	isGrid : undefined,
20983
	listeners : {
20984
		afterrender : function (f) {
20985
			f.setTitle('Lookup - Document');
20986
		}
20987
	},
20988
	initComponent : function () {
20989
		var me = this;
20990
		var targetField_ = me.targetField;
20991
		var valueField_ = me.valueField;
20992
		var form = me.test;
20993
		var tableName_ = me.tableName;
20994
		var isGrid = me.isGrid_;
20995
		var LookupFunction = me.LookupFunction;
20996
		param_ = null;
20997
		var filterParam_ = me.filterParam;
20998
		var fieldLabel_ = 'Document No';
20999
		Ext.applyIf(me, {
21000
			items : [{
21001
					items : [{
21002
							xtype : 'tabpanel',
21003
							items : [{
21004
									xtype : 'form',
21005
									title : 'Quick Search',
21006
									height : '70%',
21007
									items : [{
21008
											xtype : 'form',
21009
											name : 'frmSearch',
21010
											width : '100%',
21011
											height : 'auto',
21012
											dockedItems : [{
21013
													xtype : 'toolbar',
21014
													dock : 'top',
21015
													layout : 'vbox',
21016
													bodyPadding : 10,
21017
													border : 0,
21018
													items : [{
21019
															xtype : 'fieldset',
21020
															layout : 'hbox',
21021
															width : '100%',
21022
															border : 0,
21023
															padding : 0,
21024
															items : [{
21025
																	xtype : 'textfield',
21026
																	name : 'DocSearch',
21027
																	fieldLabel : fieldLabel_,
21028
																	width : 470,
21029
																	labelWidth : 185,
21030
																	enableKeyEvents : true,
21031
																	filterParam : filterParam_,
21032
																	listeners : {
21033
																		specialkey : function (f, e) {
21034
																			if (e.getKey() == e.ENTER) {
21035
																				var doc = Ext.ComponentQuery.query('[name=DocSearch]')[0];
21036
																				var docNo = doc.getValue();
21037
																				var store = Ext.data.StoreManager.lookup('storeQC');
21038
																				param_ = 'DocNo[like]' + docNo
21039
																					if (this.filterParam) {
21040
																						param_ = param_ + ',' + this.filterParam_
21041
																					}
21042
																					store.proxy.extraParams = {
21043
																					tableName : tableName_,
21044
																					param : param_,
21045
																					menuId : MinovaUtil.GetMenuID()
21046
																				};
21047
																				store.removeAll();
21048
																				store.reload();
21049
																				store.loadPage(1);
21050
																			}
21051
																		}
21052
																	}
21053
																}, {
21054
																	xtype : 'tbspacer',
21055
																	width : 5
21056
																}, {
21057
																	xtype : 'button',
21058
																	name : 'Search',
21059
																	text : 'Search',
21060
																	filterParam : filterParam_,
21061
																	handler : function () {
21062
																		var doc = Ext.ComponentQuery.query('[name=DocSearch]')[0];
21063
																		var docNo = doc.getValue();
21064
																		var store = Ext.data.StoreManager.lookup('storeQC');
21065
																		param_ = 'DocNo[like]' + docNo
21066
																			if (this.filterParam) {
21067
																				param_ = param_ + ',' + this.filterParam
21068
																			}
21069
																			store.proxy.extraParams = {
21070
																			tableName : tableName_,
21071
																			param : param_,
21072
																			menuId : MinovaUtil.GetMenuID()
21073
																		};
21074
																		store.removeAll();
21075
																		store.reload();
21076
																		store.loadPage(1);
21077
																	}
21078
																}
21079
															]
21080
														}
21081
													]
21082
												}
21083
											]
21084
										}, {
21085
											items : [{
21086
													xtype : "minovagrid1",
21087
													name : "GridDocNo",
21088
													storename : 'storeQC',
21089
													tableName : tableName_,
21090
													param : this.filterParam,
21091
													isLookup : true,
21092
													pagesize : 25,
21093
													height : 398,
21094
													LookupFunction : LookupFunction,
21095
													valueField : valueField_,
21096
													targetField : targetField_,
21097
													isGrid : true,
21098
													listeners : {
21099
														beforeedit : function () {
21100
															return false;
21101
														},
21102
														itemdblclick : function () {
21103
															var grid = Ext.ComponentQuery.query('[name=GridDocNo]')[0];
21104
															var selection = grid.getView().getSelectionModel().getSelection()[0];
21105
															var documentno = selection.data.DocNo;
21106
															LookupFunction = this.LookupFunction;
21107
															eval(LookupFunction);
21108
															var target = Ext.ComponentQuery.query('[name=LookupDocumentTrans]')[0].targetField;
21109
															Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(documentno);
21110
															Ext.ComponentQuery.query('[name=LookupDocumentTrans]')[0].hide();
21111
														}
21112
													},
21113
												}, {
21114
													xtype : 'pagingtoolbar',
21115
													store : 'storeQC',
21116
													dock : 'bottom',
21117
													displayInfo : true
21118
												}
21119
											]
21120
										}
21121
									]
21122
								}, {
21123
									title : 'Advance Search',
21124
									items : [{
21125
											xtype : 'form',
21126
											name : 'formlookup',
21127
											items : [{
21128
													xtype : 'minovaform',
21129
													name : 'frmlookup',
21130
													tableName : tableName_,
21131
													param : filterParam_,
21132
													isLookup : true,
21133
													buttons : [{
21134
															text : 'Search',
21135
															filterParam : filterParam_,
21136
															listeners : {
21137
																click : function () {
21138
																	var store = Ext.data.StoreManager.lookup('storeadvance');
21139
																	var form = Ext.ComponentQuery.query('[name=formlookup]')[0].getForm();
21140
																	grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
21141
																	var values_ = form.getValues();
21142
																	var fields_ = form.getFields().items;
21143
																	var param_ = '';
21144
																	for (var i = 0; i < fields_.length; i++) {
21145
																		var val_ = form.getFields().items[i].getValue();
21146
																		var xtype_ = form.getFields().items[i].xtype;
21147
																		var oprator_ = '[like]';
21148
																		if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
21149
																			oprator_ = '[Equal]';
21150
																		}
21151
																		if (xtype_ == 'datefield') {
21152
																			if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
21153
																				oprator_ = '[LessThanEqual]';
21154
																			} else {
21155
																				oprator_ = '[GreaterThanEqual]';
21156
																			}
21157
																		}
21158
																		if (val_ != 'undefined' && val_ != "" && val_ != null) {
21159
																			param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
21160
																		}
21161
																	}
21162
																	if (this.filterParam_) {
21163
																		param_ = param_ + ',' + this.filterParam_
21164
																	}
21165
																	store.proxy.extraParams = {
21166
																		tableName : grid.tableName,
21167
																		param : param_,
21168
																		menuId : MinovaUtil.GetMenuID()
21169
																	};
21170
																	store.removeAll();
21171
																	store.reload();
21172
																	store.loadPage(1);
21173
																}
21174
															}
21175
														}
21176
													]
21177
												}, {
21178
													xtype : 'minovagrid1',
21179
													name : 'gridlookup',
21180
													minHeight : 312,
21181
													height : 290,
21182
													tableName : tableName_,
21183
													param : this.filterParam,
21184
													isLookup : true,
21185
													storename : 'storeadvance',
21186
													pagesize : 25,
21187
													valueField : valueField_,
21188
													targetField : targetField_,
21189
													hidebutton : 0,
21190
													isGrid : true,
21191
													listeners : {
21192
														beforeedit : function () {
21193
															return false;
21194
														},
21195
														itemdblclick : function () {
21196
															var grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
21197
															var selection = grid.getView().getSelectionModel().getSelection()[0];
21198
															var documentno = selection.data.DocNo;
21199
															LookupFunction = this.LookupFunction;
21200
															eval(LookupFunction);
21201
															var target = Ext.ComponentQuery.query('[name=LookupDocumentTrans]')[0].targetField;
21202
															Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(documentno);
21203
															Ext.ComponentQuery.query('[name=LookupDocumentTrans]')[0].hide();
21204
														}
21205
													},
21206
													dockedItems : [{
21207
															xtype : 'pagingtoolbar',
21208
															store : 'storeadvance',
21209
															dock : 'bottom',
21210
															displayInfo : true
21211
														}
21212
													]
21213
												}
21214
											]
21215
										}
21216
									]
21217
								}
21218
							]
21219
						}
21220
					]
21221
				}
21222
			]
21223
		});
21224
		me.callParent(arguments);
21225
	}
21226
});
21227
Ext.define('MinovaUtil.MinovaES.MinovaSummaryDocForm', {
21228
	extend : 'Ext.form.Panel',
21229
	alias : ['widget.summarydocform'],
21230
	formname : this.name,
21231
	tableName : undefined,
21232
	docType : undefined,
21233
	transType : undefined,
21234
	resizable : true,
21235
	border : false,
21236
	autoScroll : true,
21237
	layout : 'column',
21238
	defaults : {
21239
		layout : 'form',
21240
		xtype : 'container',
21241
		defaultType : 'textfield',
21242
		style : 'width: 50%',
21243
	},
21244
	initComponent : function () {
21245
		var me = this;
21246
		var col1 = [];
21247
		var col2 = [];
21248
		var LangID = localStorage.LangId;
21249
		var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "',IsSummary=1";
21250
		var formname_ = me.name;
21251
		var nameTable_ = me.tableName;
21252
		Ext.Ajax.request({
21253
			async : false,
21254
			method : 'POST',
21255
			url : '/UserControl/GetStore',
21256
			params : {
21257
				tableName : 'PDSDOCFIELD',
21258
				param : parameter
21259
			},
21260
			success : function (response) {
21261
				var results = Ext.decode(response.responseText);
21262
				hasil = results.data;
21263
			}
21264
		});
21265
		if (hasil.length > 0) {
21266
			Ext.each(hasil, function (rec) {
21267
				var formfield = MinovaUtil.FieldGenerator.Form(me.name, rec, false, true, me.tableName, false);
21268
				var descField = undefined;
21269
				if (rec.ColumnNo == 1) {
21270
					col1.push(formfield);
21271
					if (descField) {
21272
						col1.push(descField)
21273
					}
21274
				} else {
21275
					col2.push(formfield);
21276
					if (descField) {
21277
						col2.push(descField)
21278
					}
21279
				}
21280
			});
21281
		}
21282
		Ext.applyIf(me, {
21283
			items : [{
21284
					style : 'width: 50%',
21285
					items : col1
21286
				}, {
21287
					style : 'width: 50%',
21288
					items : col2
21289
				}
21290
			]
21291
		});
21292
		this.callParent();
21293
	}
21294
});
21295

    
21296
Ext.define('MinovaUtil.MinovaES.LookupDocRef', {
21297
	extend: 'Ext.window.Window',
21298
	alias: 'widget.lookupdocumentref',
21299
	requires: [],
21300
	// height: '73%', //saswanto28jan2022
21301
	width: '50%',
21302
	minWidth: '50%',
21303
	maxWidth: '100%',
21304
	bodyPadding: 0,
21305
	formname: undefined,
21306
	name: 'LookupDocRef',
21307
	test: undefined,
21308
	vtype: 'validateMinovaXss',
21309
	targetField: undefined,
21310
	valueField: undefined,
21311
	tableName: 'PDSDOCREF',
21312
	transType: undefined,
21313
	docType: undefined,
21314
	LookupFunction: undefined,
21315
	datarecord: undefined,
21316
	isGrid: undefined,
21317
	filterParam: undefined,
21318
	listeners: {
21319
		afterrender: function (f) {
21320
			f.setTitle('Lookup - Document');
21321
		}
21322
	},
21323
	initComponent: function () {
21324
		var me = this;
21325
		var targetField_ = me.targetField;
21326
		var valueField_ = me.valueField;
21327
		var form = me.test;
21328
		var tableName_ = me.tableName;
21329
		var transType_ = ""; ////---- add by Tri nwh 20220413 status look up doc ref
21330
		MinovaUtil.ExecuteParamQuery({
21331
			ID: "FILOGetTransType",
21332
			MenuID: MinovaUtil.GetMenuID()
21333
		}, function (s) {
21334
			var result = Ext.decode(s.responseText);
21335
			var dt = Ext.decode(Ext.decode(result.data));
21336
			if (dt.length !== 0 || dt !== null) {
21337
				transType_ = dt[0].TransType;
21338
				if (transType_ == 'FIN') { tableName_ = 'PDSDOCREF'; }
21339
				else { tableName_ = 'PDSDOCREFLOG'; }
21340
			}
21341
		}, function (f) { });	////---- add by Tri nwh 20220413 status look up doc ref
21342
		var isGrid = me.isGrid_;
21343
		var LookupFunction = me.LookupFunction;
21344
		param_ = null;
21345
		var filterParam_ = me.filterParam;
21346
		var compselect = "";
21347
		var buselect = "";
21348
		Ext.applyIf(me, {
21349
			items: [{
21350
				xtype: 'form',
21351
				name: 'formlookup',
21352
				items: [{
21353
					xtype: 'minovaform',
21354
					bodyPadding:10,
21355
					name: 'frmlookup',
21356
					tableName: tableName_,
21357
					param: filterParam_,
21358
					isLookup: true,
21359
					buttons: [{
21360
						text: 'Search',
21361
						filterParam: filterParam_,
21362
						listeners: {
21363
							click: function () {
21364
								var store = Ext.data.StoreManager.lookup('storeadvance');
21365
								var form = Ext.ComponentQuery.query('[name=formlookup]')[0].getForm();
21366
								grid = Ext.ComponentQuery.query('[name=gridlookupdocref]')[0];
21367
								var values_ = form.getValues();
21368
								var fields_ = form.getFields().items;
21369
								var param_ = '';
21370
								for (var i = 0; i < fields_.length; i++) {
21371
									var val_ = form.getFields().items[i].getValue();
21372
									var xtype_ = form.getFields().items[i].xtype;
21373
									var oprator_ = '[like]';
21374
									if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
21375
										oprator_ = '[Equal]';
21376
									}
21377
									if (xtype_ == 'datefield') {
21378
										if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
21379
											oprator_ = '[LessThanEqual]';
21380
										} else {
21381
											oprator_ = '[GreaterThanEqual]';
21382
										}
21383
									}
21384
									if (val_ != 'undefined' && val_ != "" && val_ != null) {
21385
										param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
21386
									}
21387
								}
21388
								if (filterParam_) {
21389
									param_ = param_ + ',' + filterParam_
21390
								}
21391
								store.proxy.extraParams = {
21392
									tableName: grid.tableName,
21393
									param: param_,
21394
									menuId: MinovaUtil.GetMenuID()
21395
								};
21396
								store.removeAll();
21397
								store.reload();
21398
								store.loadPage(1);
21399
							}
21400
						}
21401
					}]
21402
				}, {
21403
					xtype: 'minovagrid1',
21404
					bodyPadding:10,
21405
					name: 'gridlookupdocref',
21406
					// minHeight: 312,
21407
					height: 290,
21408
					tableName: tableName_,
21409
					param: this.filterParam,
21410
					isLookup: true,
21411
					storename: 'storeadvance',
21412
					pagesize: 25,
21413
					valueField: valueField_,
21414
					targetField: targetField_,
21415
					multiSelect: true,
21416
					hidebutton: 0,
21417
					isGrid: true,
21418
					listeners: {
21419
						beforeedit: function () {
21420
							return false;
21421
						},
21422
						itemdblclick: function () { },
21423
						select: function (t, record, index, eOpts) {
21424
							if (compselect !== "") {
21425
								if (compselect !== record.data.CompanyID) {
21426
									// MinovaMessageError("", "FILO06", "");
21427
									return;
21428
								}
21429
							}
21430
							if (buselect !== "") {
21431
								if (buselect !== record.data.BusinessUnit) {
21432
									// MinovaMessageError("", "FILO07", "");
21433
									return;
21434
								}
21435
							}
21436
							compselect = record.data.CompanyID;
21437
							buselect = record.data.BusinessUnit;
21438
						}
21439
					},
21440
					dockedItems: [{
21441
						xtype: 'pagingtoolbar',
21442
						store: 'storeadvance',
21443
						dock: 'bottom',
21444
						displayInfo: true
21445
					}, {
21446
						xtype: 'button',
21447
						margin: '10 20 10 20',
21448
						name: 'select',
21449
						text: 'Select',
21450
						dock: 'bottom'
21451
					}]
21452
				}]
21453
			}]
21454
		});
21455
		me.callParent(arguments);
21456
	}
21457
});
21458

    
21459
var Base64 = (function () {
21460
	// Private property
21461
	var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
21462

    
21463
	// Private method for UTF-8 encoding
21464

    
21465
	function utf8Encode(string) {
21466
		string = string.replace(/\r\n/g, "\n");
21467
		var utftext = "";
21468
		for (var n = 0; n < string.length; n++) {
21469
			var c = string.charCodeAt(n);
21470
			if (c < 128) {
21471
				utftext += String.fromCharCode(c);
21472
			} else if ((c > 127) && (c < 2048)) {
21473
				utftext += String.fromCharCode((c >> 6) | 192);
21474
				utftext += String.fromCharCode((c & 63) | 128);
21475
			} else {
21476
				utftext += String.fromCharCode((c >> 12) | 224);
21477
				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
21478
				utftext += String.fromCharCode((c & 63) | 128);
21479
			}
21480
		}
21481
		return utftext;
21482
	}
21483

    
21484
	// Public method for encoding
21485
	return {
21486
		encode: (typeof btoa == 'function') ? function (input) {
21487
			return btoa(utf8Encode(input));
21488
		}
21489
		 : function (input) {
21490
			var output = "";
21491
			var chr1,
21492
			chr2,
21493
			chr3,
21494
			enc1,
21495
			enc2,
21496
			enc3,
21497
			enc4;
21498
			var i = 0;
21499
			input = utf8Encode(input);
21500
			while (i < input.length) {
21501
				chr1 = input.charCodeAt(i++);
21502
				chr2 = input.charCodeAt(i++);
21503
				chr3 = input.charCodeAt(i++);
21504
				enc1 = chr1 >> 2;
21505
				enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
21506
				enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
21507
				enc4 = chr3 & 63;
21508
				if (isNaN(chr2)) {
21509
					enc3 = enc4 = 64;
21510
				} else if (isNaN(chr3)) {
21511
					enc4 = 64;
21512
				}
21513
				output = output +
21514
					keyStr.charAt(enc1) + keyStr.charAt(enc2) +
21515
					keyStr.charAt(enc3) + keyStr.charAt(enc4);
21516
			}
21517
			return output;
21518
		}
21519
	};
21520
})();
21521
Ext.define('MyApp.view.override.Grid', {
21522
	override: 'Ext.grid.GridPanel',
21523
	requires: 'Ext.form.action.StandardSubmit',
21524

    
21525
	/*
21526
	Kick off process
21527
	 */
21528

    
21529
	downloadExcelXml: function (includeHidden, name) {
21530

    
21531
		if (!name)
21532
			title = this.name;
21533

    
21534
		var vExportContent = this.getExcelXml(includeHidden, title);
21535

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

    
21538
		/*
21539
		dynamically create and anchor tag to force download with suggested filename
21540
		note: download attribute is Google Chrome specific
21541
		 */
21542

    
21543
		if (Ext.isChrome) {
21544
			var gridEl = this.getEl();
21545

    
21546
			var el = Ext.DomHelper.append(gridEl, {
21547
					tag: "a",
21548
					download: title + "-" + Ext.Date.format(new Date(), 'Y-m-d Hi') + '.xls',
21549
					href: location
21550
				});
21551

    
21552
			el.click();
21553

    
21554
			Ext.fly(el).destroy();
21555

    
21556
		} else {
21557

    
21558
			var form = this.down('form#uploadForm');
21559
			if (form) {
21560
				form.destroy();
21561
			}
21562
			form = this.add({
21563
					xtype: 'form',
21564
					itemId: 'uploadForm',
21565
					hidden: true,
21566
					standardSubmit: true,
21567
					url: 'http://webapps.figleaf.com/dataservices/Excel.cfc?method=echo&mimetype=application/vnd.ms-excel&filename=' + escape(title + ".xls"),
21568
					items: [{
21569
							xtype: 'hiddenfield',
21570
							name: 'data',
21571
							value: vExportContent
21572
						}
21573
					]
21574
				});
21575

    
21576
			form.getForm().submit();
21577

    
21578
		}
21579
	},
21580

    
21581
	/*
21582

    
21583
	Welcome to XML Hell
21584
	See: http://msdn.microsoft.com/en-us/library/office/aa140066(v=office.10).aspx
21585
	for more details
21586

    
21587
	 */
21588
	getExcelXml: function (includeHidden, title) {
21589

    
21590
		var theTitle = title || this.title;
21591

    
21592
		var worksheet = this.createWorksheet(includeHidden, theTitle);
21593
		var totalWidth = this.columnManager.columns.length;
21594

    
21595
		return ''.concat(
21596
			'<?xml version="1.0"?>',
21597
			'<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">',
21598
			'<DocumentProperties xmlns="urn:schemas-microsoft-com:office:office"><Title>' + theTitle + '</Title></DocumentProperties>',
21599
			'<OfficeDocumentSettings xmlns="urn:schemas-microsoft-com:office:office"><AllowPNG/></OfficeDocumentSettings>',
21600
			'<ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">',
21601
			'<WindowHeight>' + worksheet.height + '</WindowHeight>',
21602
			'<WindowWidth>' + worksheet.width + '</WindowWidth>',
21603
			'<ProtectStructure>False</ProtectStructure>',
21604
			'<ProtectWindows>False</ProtectWindows>',
21605
			'</ExcelWorkbook>',
21606

    
21607
			'<Styles>',
21608

    
21609
			'<Style ss:ID="Default" ss:Name="Normal">',
21610
			'<Alignment ss:Vertical="Bottom"/>',
21611
			'<Borders/>',
21612
			'<Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="12" ss:Color="#000000"/>',
21613
			'<Interior/>',
21614
			'<NumberFormat/>',
21615
			'<Protection/>',
21616
			'</Style>',
21617

    
21618
			'<Style ss:ID="title">',
21619
			'<Borders />',
21620
			'<Font ss:Bold="1" ss:Size="18" />',
21621
			'<Alignment ss:Horizontal="Center" ss:Vertical="Center" ss:WrapText="1" />',
21622
			'<NumberFormat ss:Format="@" />',
21623
			'</Style>',
21624

    
21625
			'<Style ss:ID="headercell">',
21626
			'<Font ss:Bold="1" ss:Size="10" />',
21627
			'<Alignment ss:Horizontal="Center" ss:WrapText="1" />',
21628
			'<Interior ss:Color="#A3C9F1" ss:Pattern="Solid" />',
21629
			'</Style>',
21630

    
21631
			'<Style ss:ID="even">',
21632
			'<Interior ss:Color="#CCFFFF" ss:Pattern="Solid" />',
21633
			'</Style>',
21634

    
21635
			'<Style ss:ID="evendate" ss:Parent="even">',
21636
			'<NumberFormat ss:Format="yyyy-mm-dd" />',
21637
			'</Style>',
21638

    
21639
			'<Style ss:ID="evenint" ss:Parent="even">',
21640
			'<Numberformat ss:Format="0" />',
21641
			'</Style>',
21642

    
21643
			'<Style ss:ID="evenfloat" ss:Parent="even">',
21644
			'<Numberformat ss:Format="0.00" />',
21645
			'</Style>',
21646

    
21647
			'<Style ss:ID="odd">',
21648
			'<Interior ss:Color="#CCCCFF" ss:Pattern="Solid" />',
21649
			'</Style>',
21650

    
21651
			'<Style ss:ID="groupSeparator">',
21652
			'<Interior ss:Color="#D3D3D3" ss:Pattern="Solid" />',
21653
			'</Style>',
21654

    
21655
			'<Style ss:ID="odddate" ss:Parent="odd">',
21656
			'<NumberFormat ss:Format="yyyy-mm-dd" />',
21657
			'</Style>',
21658

    
21659
			'<Style ss:ID="oddint" ss:Parent="odd">',
21660
			'<NumberFormat Format="0" />',
21661
			'</Style>',
21662

    
21663
			'<Style ss:ID="oddfloat" ss:Parent="odd">',
21664
			'<NumberFormat Format="0.00" />',
21665
			'</Style>',
21666

    
21667
			'</Styles>',
21668
			worksheet.xml,
21669
			'</Workbook>');
21670
	},
21671

    
21672
	/*
21673

    
21674
	Support function to return field info from store based on fieldname
21675

    
21676
	 */
21677

    
21678
	getModelField: function (fieldName) {
21679

    
21680
		var fields = this.store.model.getFields();
21681
		for (var i = 0; i < fields.length; i++) {
21682
			if (fields[i].name === fieldName) {
21683
				return fields[i];
21684
			}
21685
		}
21686
	},
21687

    
21688
	/*
21689

    
21690
	Convert store into Excel Worksheet
21691

    
21692
	 */
21693
	generateEmptyGroupRow: function (dataIndex, value, cellTypes, includeHidden) {
21694

    
21695
		var cm = this.columnManager.columns;
21696
		var colCount = cm.length;
21697
		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>';
21698
		var visibleCols = 0;
21699

    
21700
		// rowXml += '<Cell ss:StyleID="groupSeparator">'
21701

    
21702
		for (var j = 0; j < colCount; j++) {
21703
			if (cm[j].xtype != 'actioncolumn' && (cm[j].dataIndex != '') && (includeHidden || !cm[j].hidden)) {
21704
				// rowXml += '<Cell ss:StyleID="groupSeparator"/>';
21705
				visibleCols++;
21706
			}
21707
		}
21708

    
21709
		// rowXml += "</Row>";
21710

    
21711
		return Ext.String.format(rowTpl, visibleCols - 1, value);
21712
	},
21713

    
21714
	createWorksheet: function (includeHidden, theTitle) {
21715
		// Calculate cell data types and extra class names which affect formatting
21716
		var cellType = [];
21717
		var cellTypeClass = [];
21718
		var cm = this.columnManager.columns;
21719

    
21720
		var totalWidthInPixels = 0;
21721
		var colXml = '';
21722
		var headerXml = '';
21723
		var visibleColumnCountReduction = 0;
21724
		var colCount = cm.length;
21725
		for (var i = 0; i < colCount; i++) {
21726
			if (cm[i].xtype != 'actioncolumn' && (cm[i].dataIndex != '') && (includeHidden || !cm[i].hidden)) {
21727
				var w = cm[i].getEl().getWidth();
21728
				totalWidthInPixels += w;
21729

    
21730
				if (cm[i].text === "") {
21731
					cellType.push("None");
21732
					cellTypeClass.push("");
21733
					++visibleColumnCountReduction;
21734
				} else {
21735
					colXml += '<Column ss:AutoFitWidth="1" ss:Width="' + w + '" />';
21736
					headerXml += '<Cell ss:StyleID="headercell">' +
21737
					'<Data ss:Type="String">' + cm[i].dataIndex + '</Data>' +
21738
					'<NamedCell ss:Name="Print_Titles"></NamedCell></Cell>';
21739

    
21740
					var fld = this.getModelField(cm[i].dataIndex);
21741
					switch (fld.type.type) {
21742
					case "int":
21743
						cellType.push("Number");
21744
						cellTypeClass.push("int");
21745
						break;
21746
					case "float":
21747
						cellType.push("Number");
21748
						cellTypeClass.push("float");
21749
						break;
21750

    
21751
					case "bool":
21752

    
21753
					case "boolean":
21754
						cellType.push("String");
21755
						cellTypeClass.push("");
21756
						break;
21757
					case "date":
21758
						cellType.push("DateTime");
21759
						cellTypeClass.push("date");
21760
						break;
21761
					default:
21762
						cellType.push("String");
21763
						cellTypeClass.push("");
21764
						break;
21765
					}
21766
				}
21767
			}
21768
		}
21769
		var visibleColumnCount = cellType.length - visibleColumnCountReduction;
21770

    
21771
		var result = {
21772
			height: 9000,
21773
			width: Math.floor(totalWidthInPixels * 30) + 50
21774
		};
21775

    
21776
		// Generate worksheet header details.
21777

    
21778
		// determine number of rows
21779
		var numGridRows = this.store.getCount() + 2;
21780
		if (!Ext.isEmpty(this.store.groupField)) {
21781
			numGridRows = numGridRows + this.store.getGroups().length;
21782
		}
21783

    
21784
		// create header for worksheet
21785
		var t = ''.concat(
21786
				'<Worksheet ss:Name="' + theTitle + '">',
21787

    
21788
				'<Names>',
21789
				'<NamedRange ss:Name="Print_Titles" ss:RefersTo="=\'' + theTitle + '\'!R1:R2">',
21790
				'</NamedRange></Names>',
21791

    
21792
				'<Table ss:ExpandedColumnCount="' + (visibleColumnCount + 2),
21793
				'" ss:ExpandedRowCount="' + numGridRows + '" x:FullColumns="1" x:FullRows="1" ss:DefaultColumnWidth="65" ss:DefaultRowHeight="15">',
21794
				colXml,
21795
				'<Row ss:AutoFitHeight="1">',
21796
				headerXml +
21797
				'</Row>');
21798

    
21799
		// Generate the data rows from the data in the Store
21800
		var groupVal = "";
21801
		var groupField = "";
21802

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

    
21805
			if (!Ext.isEmpty(groupField)) {
21806
				if (groupVal != this.store.getAt(i).get(groupField)) {
21807
					groupVal = this.store.getAt(i).get(groupField);
21808
					t += this.generateEmptyGroupRow(groupField, groupVal, cellType, includeHidden);
21809
				}
21810
			}
21811
			t += '<Row>';
21812
			var cellClass = (i & 1) ? 'odd' : 'even';
21813
			r = it[i].data;
21814
			var k = 0;
21815
			for (var j = 0; j < colCount; j++) {
21816
				if (cm[j].xtype != 'actioncolumn' && (cm[j].dataIndex != '') && (includeHidden || !cm[j].hidden)) {
21817
					var v = r[cm[j].dataIndex];
21818
					if (cellType[k] !== "None") {
21819
						t += '<Cell ss:StyleID="' + cellClass + cellTypeClass[k] + '"><Data ss:Type="' + cellType[k] + '">';
21820
						if (cellType[k] == 'DateTime') {
21821
							t += Ext.Date.format(v, 'Y-m-d');
21822
						} else {
21823
							t += v;
21824
						}
21825
						t += '</Data></Cell>';
21826
					}
21827
					k++;
21828
				}
21829
			}
21830
			t += '</Row>';
21831
		}
21832

    
21833
		result.xml = t.concat(
21834
				'</Table>',
21835
				'<WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">',
21836
				'<PageLayoutZoom>0</PageLayoutZoom>',
21837
				'<Selected/>',
21838
				'<Panes>',
21839
				'<Pane>',
21840
				'<Number>3</Number>',
21841
				'<ActiveRow>2</ActiveRow>',
21842
				'</Pane>',
21843
				'</Panes>',
21844
				'<ProtectObjects>False</ProtectObjects>',
21845
				'<ProtectScenarios>False</ProtectScenarios>',
21846
				'</WorksheetOptions>',
21847
				'</Worksheet>');
21848
		return result;
21849
	}
21850
});
21851

    
21852
/*Add Midi For Grid Mass Posting Filo*/
21853
Ext.define('MinovaUtil.MinovaES.MinovaEditAbleGridList', {
21854
    extend: 'Ext.form.Panel',
21855
    alias: ['widget.MinovaEditAbleGridList', 'widget.Minovaeditablegridlist', 'widget.minovaeditablegridlist'],
21856
    requires: [
21857
		'Ext.grid.plugin.CellEditing',
21858
		'Ext.grid.RowNumberer',
21859
		'Ext.grid.Panel',
21860
    ],
21861

    
21862
    //renderTo: 'panel-extjs',
21863
    anchor: '100%',
21864
    tableName: undefined,
21865
    hideButton: undefined,
21866
    multiSelect: undefined,
21867
    initComponent: function () {
21868
        var me = this;
21869
        var isLookup = me.isLookup;
21870
        var hide_ = false;
21871
        var widthLock = 250;
21872
        var checkSelection = '';
21873

    
21874
        if (me.hideButton == true) {
21875
            hide_ = true;
21876
        }
21877
        if (me.multiSelect) {
21878
            locking = false;
21879
            checkSelection = 'checkboxmodel';
21880
            widthLock = 40;
21881
        }
21882
        var tableName = me.tableName;
21883
        var cols = [];
21884
        var fieldStore = [];
21885
        var _url = 'GetAllField';
21886
        var hasil = null;
21887
        var height = me.height;
21888
        var storeID = 'store' + me.tableName;
21889
        var gridName = 'grid' + me.name;
21890
        if (me.storeName) {
21891
            storeID = me.storeName;
21892
        }
21893
        var LangID = MinovaUtil.GetLangID();
21894
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
21895
        Ext.Ajax.request({
21896
            async: false,
21897
            method: 'POST',
21898
            url: '/UserControl/GetStore',
21899
            params: {
21900
                tableName: 'PDSBS0007',
21901
                param: parameter
21902
            },
21903
            success: function (response) {
21904
                var results = Ext.decode(response.responseText);
21905
                hasil = results.data;
21906
            }
21907
        });
21908
        cols.push({
21909
            xtype: 'rownumberer'
21910
        });
21911
        var addData = 'var data={';
21912
        if (hasil.length > 0) {
21913
            Ext.each(hasil, function (rec) {
21914
                fieldStore.push(rec.FieldName);
21915
                if (rec.FieldName != 'Sequence') {
21916
                    addData = addData + rec.FieldName + ":" + "'',";
21917
                }
21918

    
21919
                var null_ = null;
21920
                var ReadOnly_ = false;
21921
                if (rec.IsPrimaryKey == true) {
21922
                    null_ = false;
21923
                }
21924
                if (rec.IsRequired == true) {
21925
                    null_ = false;
21926
                } else {
21927
                    null_ = true;
21928
                }
21929
                if (rec.ReadOnly == '1') {
21930
                    ReadOnly_ = true;
21931
                }
21932
                var Hidden_ = false;
21933
                if (rec.ReadOnly == '1') {
21934
                    ReadOnly_ = true;
21935
                }
21936

    
21937
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
21938
                    Hidden_ = true;
21939
                    null_ = true;
21940
                }
21941

    
21942
                if (rec.GridView == 1) {
21943
                    switch (rec.FormatRef) {
21944
                        case "date":
21945
                            cols.push({
21946
                                xtype: 'minovadatecolumn',
21947
                                hidden: Hidden_,
21948
                                text: rec.HeaderTitle,
21949
                                dataIndex: rec.FieldName,
21950
                                filter: {
21951
                                    itemDefaults: {
21952
                                        emptyText: 'Search for...',
21953

    
21954
                                    }
21955
                                },
21956
                                editor: {
21957
                                    allowBlank: null_,
21958
                                    xtype: 'datefield',
21959
                                    hideMode: 'visibility',
21960
                                    readOnly: ReadOnly_,
21961
                                    id: tableName + rec.FieldName,
21962
                                    fieldGrid: rec.FieldName,
21963
                                    nameTable: rec.TableName,
21964
                                }
21965
                            });
21966
                            break
21967
                        case "amount":
21968
                            cols.push({
21969
                                xtype: 'minovacurrancycolumn',
21970
                                //renderer: Ext.util.Format.numberRenderer("0,0"),
21971
                                text: rec.HeaderTitle,
21972
                                align: 'right',
21973
                                dataIndex: rec.FieldName,
21974
                                hidden: Hidden_,
21975
                                filter: {
21976
                                    itemDefaults: {
21977
                                        emptyText: 'Search for...'
21978
                                    }
21979
                                },
21980
                                editor: {
21981
                                    allowBlank: null_,
21982
                                    xtype: 'minovacurrencyfield',
21983
                                    //renderer: Ext.util.Format.numberRenderer("0,0"),
21984
                                    //vtype: 'validateDecimal',
21985
                                    readOnly: ReadOnly_,
21986
                                    id: tableName + rec.FieldName,
21987
                                    nameTable: rec.TableName,
21988
                                    fieldGrid: rec.FieldName,
21989
                                    fieldStyle: 'text-align:right;',
21990
                                    value: '0',
21991

    
21992
                                }
21993
                            });
21994
                            break
21995
                        case "time":
21996
                            var DefaultValue = rec.DefaultValue;
21997
                            if (DefaultValue == '') {
21998
                                defaultValue = '00:00';
21999
                            }
22000
                            cols.push({
22001
                                //xtype: 'minovatimecolumn',
22002
                                xtype: 'timefield',
22003
                                format: 'H:i',
22004
                                submitFormat: 'Hi',
22005
                                text: rec.HeaderTitle,
22006
                                dataIndex: rec.FieldName,
22007
                                hidden: Hidden_,
22008
                                //renderer: Ext.util.Format.dateRenderer('G:i'),
22009
                                filter: {
22010
                                    itemDefaults: {
22011
                                        emptyText: 'Search for...'
22012
                                    }
22013
                                },
22014
                                editor: {
22015
                                    allowBlank: null_,
22016
                                    xtype: 'timefield',
22017
                                    readOnly: ReadOnly_,
22018
                                    id: tableName + rec.FieldName,
22019
                                    format: 'H:i',
22020
                                    submitFormat: 'Hi',
22021
                                    increment: 5,
22022
                                    value: DefaultValue,
22023
                                    anchor: '100%',
22024
                                    listeners: {}
22025
                                    //renderer: Ext.util.Format.dateRenderer('G:i'),
22026
                                }
22027
                            });
22028
                            break
22029
                            //case "datetime":
22030
                            //    if (rec.DataRef != 'CREATEDT' && rec.DataRef != 'CHANGEDT') {
22031
                            //        cols.push({
22032
                            //            xtype: 'minovadatetimecolumn',
22033
                            //            text: rec.HeaderTitle,
22034
                            //            dataIndex: rec.FieldName,
22035
                            //            filter: {
22036
                            //                itemDefaults: {
22037
                            //                    emptyText: 'Search for...'
22038
                            //                }
22039
                            //            },
22040
                            //            editor: {
22041
                            //                allowBlank: null_,
22042
                            //                xtype: 'textfield',
22043
                            //            }
22044
                            //        });
22045
                            //    }
22046
                            //    break
22047
                        default:
22048
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
22049
                                cols.push({
22050
                                    text: rec.HeaderTitle,
22051
                                    dataIndex: rec.FieldName,
22052
                                    width: 100,
22053
                                    filter: {
22054
                                        type: 'string',
22055
                                        itemDefaults: {
22056
                                            emptyText: 'Search for...'
22057
                                        }
22058
                                    }
22059
                                });
22060
                            } else if (rec.SearchType == '0') {
22061
                                var valueField = null;
22062
                                var displayValue = null;
22063
                                var TableRef = undefined;
22064
                                if (rec.TableRef != '') {
22065
                                    TableRef = rec.TableRef;
22066

    
22067
                                    Ext.Ajax.request({
22068
                                        async: false,
22069
                                        method: 'POST',
22070
                                        url: '/UserControl/GetStore',
22071
                                        params: {
22072
                                            tableName: 'SDATATABLEFIELD',
22073
                                            param: 'TableName[equal]' + rec.TableRef
22074
                                        },
22075
                                        success: function (response) {
22076
                                            var results = Ext.decode(response.responseText);
22077
                                            data_ = results.data;
22078
                                            if (data_ != undefined) {
22079
                                                valueField_ = $.grep(data_, function (r) {
22080
                                                    return r.ValueField == '1'
22081
                                                });
22082
                                                valueField = valueField_[0].FieldName
22083
                                                displayValue_ = $.grep(data_, function (r) {
22084
                                                    return r.DisplayValue == '1'
22085
                                                });
22086
                                                displayValue = displayValue_[0].FieldName
22087
                                            }
22088
                                        }
22089
                                    });
22090

    
22091
                                    //create Store
22092
                                    Ext.create('Ext.data.Store', {
22093
                                        storeId: 'store_' + me.tableName + rec.FieldName,
22094
                                        autoLoad: true,
22095
                                        proxy: {
22096
                                            method: 'POST',
22097
                                            type: 'ajax',
22098
                                            url: '/UserControl/GetStoreAuth',
22099
                                            extraParams: {
22100
                                                tableName: TableRef,
22101
                                                param: rec.ParamCombo,
22102
                                                menuId: MinovaUtil.GetMenuID()
22103
                                            },
22104
                                            reader: {
22105
                                                type: 'json',
22106
                                                root: 'data',
22107
                                                totalProperty: 'data[0].TotalCount'
22108
                                            }
22109
                                        }
22110
                                    });
22111
                                } else if (rec.FixedValue != '') {
22112
                                    var storeData = [];
22113
                                    var str = rec.FixedValue;
22114
                                    var hasil = str.split('||');
22115
                                    hasil.forEach(function (h) {
22116
                                        store_ = h.split('=')
22117
                                        storeData.push({
22118
                                            code: store_[0],
22119
                                            desc: store_[1],
22120

    
22121
                                        });
22122
                                    });
22123

    
22124
                                    valueField = 'code';
22125
                                    displayValue = 'desc';
22126

    
22127
                                    Ext.create('Ext.data.Store', {
22128
                                        storeId: 'store_' + me.tableName + rec.FieldName,
22129
                                        autoLoad: true,
22130
                                        data: storeData
22131
                                    })
22132
                                }
22133

    
22134
                                cols.push({
22135
                                    xtype: 'minovacombocolumn',
22136
                                    hidden: Hidden_,
22137
                                    text: rec.HeaderTitle,
22138
                                    dataIndex: rec.FieldName,
22139
                                    valueField: valueField,
22140
                                    displayField: displayValue,
22141
                                    store: 'store_' + me.tableName + rec.FieldName,
22142
                                    editor: {
22143
                                        allowBlank: null_,
22144
                                        xtype: 'combobox',
22145
                                        readOnly: ReadOnly_,
22146
                                        id: tableName + rec.FieldName,
22147
                                        nameTable: rec.TableName,
22148
                                        fieldGrid: rec.FieldName,
22149
                                        valueField: valueField,
22150
                                        displayField: displayValue,
22151
                                        vtype: 'validateCombobox',
22152
                                        store: 'store_' + me.tableName + rec.FieldName,
22153
                                    },
22154
                                    filter: {
22155
                                        type: 'list',
22156
                                        itemDefaults: {
22157
                                            emptyText: 'Search for...'
22158
                                        }
22159
                                    }
22160
                                });
22161

    
22162
                            } else if (rec.SearchType == '5') {							
22163
                                var valueField = null;
22164
                                var displayValue = null;
22165
                                var AdditionaldisplayValue = null;
22166
                                var TableRef = undefined;
22167
                                if (rec.TableRef != '') {
22168
                                    TableRef = rec.TableRef;
22169
                                    Ext.Ajax.request({
22170
                                        async: false,
22171
                                        method: 'POST',
22172
                                        url: '/UserControl/GetStore',
22173
                                        params: {
22174
                                            tableName: 'SDATATABLEFIELD',
22175
                                            param: 'TableName[equal]' + rec.TableRef
22176
                                        },
22177
                                        success: function (response) {
22178
                                            var results = Ext.decode(response.responseText);
22179
                                            data_ = results.data;
22180
                                            if (data_ != undefined) {
22181
                                                valueField_ = $.grep(data_, function (r) {
22182
                                                    return r.ValueField == '1'
22183
                                                });
22184
                                                if (valueField_.length > 0) {
22185
                                                    valueField = valueField_[0].FieldName
22186
                                                }
22187

    
22188
                                                displayValue_ = $.grep(data_, function (r) {
22189
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
22190
                                                });
22191
                                                if (displayValue_.length > 0) {
22192
                                                    displayValue = displayValue_[0].FieldName;
22193
                                                }
22194
                                                if (displayValue_.length >= 2) {
22195
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
22196
                                                }
22197
                                            }
22198
                                        }
22199
                                    });
22200
                                }
22201
                                Ext.create('Ext.data.Store', {
22202
                                    storeId: 'store_' + me.tableName + rec.FieldName,
22203
                                    autoLoad: true,
22204
                                    proxy: {
22205
                                        method: 'POST',
22206
                                        type: 'ajax',
22207
                                        url: '/UserControl/GetStoreAuth',
22208
                                        extraParams: {
22209
                                            tableName: TableRef,
22210
                                            param: rec.ParamCombo,
22211
                                            menuId: MinovaUtil.GetMenuID()
22212
                                        },
22213
                                        reader: {
22214
                                            type: 'json',
22215
                                            root: 'data',
22216
                                            totalProperty: 'data[0].TotalCount'
22217
                                        }
22218
                                    }
22219
                                });
22220
                                cols.push({
22221
                                    xtype : 'minovacombocolumn',
22222
                                    hidden: Hidden_,
22223
                                    text: rec.HeaderTitle,
22224
                                    dataIndex: rec.FieldName,
22225
                                    valueField : valueField,
22226
                                    displayField : displayValue,
22227
                                    store : 'store_' + me.tableName + rec.FieldName,
22228
                                    tpl: Ext.create('Ext.XTemplate',
22229
                                            '<ul class="x-list-plain"><tpl for=".">',
22230
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
22231
                                            '</tpl></ul>'),
22232
                                    displayTpl: Ext.create('Ext.XTemplate',
22233
                                        '<tpl for=".">',
22234
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
22235
                                        '</tpl>'),
22236
                                    editor: {
22237
                                        allowBlank: null_,
22238
                                        xtype: 'combobox',
22239
                                        readOnly: ReadOnly_,
22240
                                        id: rec.TableName + rec.FieldName,
22241
                                        nameTable: rec.TableName,
22242
                                        fieldGrid: rec.FieldName,
22243
                                        valueField: valueField,
22244
                                        displayField: displayValue,
22245
                                        store: 'store_' + me.tableName + rec.FieldName,
22246
                                        value: rec.DefaultValue,
22247
                                        tpl: Ext.create('Ext.XTemplate',
22248
                                            '<ul class="x-list-plain"><tpl for=".">',
22249
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
22250
                                            '</tpl></ul>'),
22251
                                        displayTpl: Ext.create('Ext.XTemplate',
22252
                                            '<tpl for=".">',
22253
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
22254
                                            '</tpl>')
22255
                                    },
22256
                                    renderer: function (value) {
22257
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
22258
                                        var index = store.find(valueField, value);
22259
                                        var val = "";
22260
                                        if (index != -1) {
22261
                                            var rc = store.getAt(index);
22262
                                            //val = rc.get(displayValue);
22263
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
22264
                                        } else {
22265
                                            val = value;
22266
                                        }
22267
                                        return val;
22268
                                    },
22269
                                    filter: {
22270
                                        type: 'list',
22271
                                        itemDefaults: {
22272
                                            emptyText: 'Search for...'
22273
                                        }
22274
                                    }
22275
                                });
22276
                            } else if (rec.SearchType == '2') {
22277
                                var triger = (rec.TriggerCombo).split('$');
22278
                                var targetField_ = triger[0];
22279
                                var fieldValue_ = triger[1];
22280
                                cols.push({
22281
                                    text: rec.HeaderTitle,
22282
                                    hidden: Hidden_,
22283
                                    dataIndex: rec.FieldName,
22284
                                    filter: {
22285
                                        itemDefaults: {
22286
                                            emptyText: 'Search for...'
22287
                                        }
22288
                                    },
22289
                                    editor: {
22290
                                        allowBlank: null_,
22291
                                        xtype: 'minovalookupgrid',
22292
                                        readOnly: ReadOnly_,
22293
                                        isGrid: true,
22294
                                        fieldTarget: targetField_,
22295
                                        fieldValue: fieldValue_,
22296
                                        isGrid: true,
22297
                                        id: tableName + rec.FieldName,
22298
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
22299
                                        triggerCls: 'x-form-search-trigger',
22300
                                        vtype: 'alphanum', // disable space
22301
                                        nameTable: rec.TableName,
22302
                                        fieldGrid: rec.FieldName,
22303
                                        LookupFunction: rec.LookupFunction,
22304
                                        listeners: {
22305
                                            change: function (val) {
22306
                                                var custumFunc = rec.SelectFunction;
22307
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
22308
                                                    Ext.Ajax.request({
22309
                                                        async: false,
22310
                                                        method: 'POST',
22311
                                                        url: '/UserControl/GetStore',
22312
                                                        params: {
22313
                                                            tableName: 'PCMFUNC',
22314
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
22315
                                                        },
22316
                                                        success: function (response) {
22317
                                                            var results = Ext.decode(response.responseText);
22318
                                                            data_ = results.data[0];
22319
                                                            if (data_ != undefined) {
22320
                                                                custumFunc = data_.FunctionCode;
22321
                                                            }
22322
                                                        }
22323
                                                    });
22324
                                                }
22325
                                                if (custumFunc) {
22326
                                                    eval(custumFunc)
22327
                                                }
22328
                                            }
22329
                                        }
22330
                                    }
22331
                                });
22332
                            } else if (rec.SearchType == '3') {
22333
                                cols.push({
22334
                                    text: rec.HeaderTitle,
22335
                                    hidden: Hidden_,
22336
                                    dataIndex: rec.FieldName,
22337
                                    filter: {
22338
                                        itemDefaults: {
22339
                                            emptyText: 'Search for...'
22340
                                        }
22341
                                    },
22342
                                    editor: {
22343
                                        allowBlank: null_,
22344
                                        // xtype: 'minovalookuptreePopup',
22345
                                        xtype: 'MinovaLookupTree',
22346
                                        readOnly: ReadOnly_,
22347
                                        id: tableName + rec.FieldName,
22348
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
22349
                                        triggerCls: 'x-form-search-trigger',
22350
                                        vtype: 'alphanum', // disable space
22351
                                        treeSructure: rec.SearchFunction, //'O-O-P',
22352
                                        objClassValue: rec.ParamCombo, //'O',
22353
                                        nameTable: rec.TableName,
22354
                                        fieldGrid: rec.FieldName,
22355
                                        listeners: {
22356
                                            change: function (val) {
22357
                                                var custumFunc = rec.SelectFunction;
22358
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
22359
                                                    Ext.Ajax.request({
22360
                                                        async: false,
22361
                                                        method: 'POST',
22362
                                                        url: '/UserControl/GetStore',
22363
                                                        params: {
22364
                                                            tableName: 'PCMFUNC',
22365
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
22366
                                                        },
22367
                                                        success: function (response) {
22368
                                                            var results = Ext.decode(response.responseText);
22369
                                                            data_ = results.data[0];
22370
                                                            if (data_ != undefined) {
22371
                                                                custumFunc = data_.FunctionCode;
22372
                                                            }
22373
                                                        }
22374
                                                    });
22375
                                                }
22376
                                                if (custumFunc) {
22377
                                                    eval(custumFunc)
22378
                                                }
22379
                                            }
22380
                                        }
22381
                                    }
22382
                                });
22383
                            } 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) {
22384
                                var triger = (rec.TriggerCombo).split('&');
22385
                                var targetField_ = triger[0];
22386
                                var fieldValue_ = triger[0];
22387
                                cols.push({
22388
                                    text: rec.HeaderTitle,
22389
                                    hidden: Hidden_,
22390
                                    dataIndex: rec.FieldName,
22391
                                    filter: {
22392
                                        itemDefaults: {
22393
                                            emptyText: 'Search for...'
22394
                                        }
22395
                                    },
22396
                                    editor: {
22397
                                        allowBlank: null_,
22398
                                        xtype: 'lookupemployee',
22399
                                        readOnly: ReadOnly_,
22400
                                        isGrid: true,
22401
                                        fieldTarget: targetField_,
22402
                                        fieldValue: fieldValue_,
22403
                                        isGrid: true,
22404
                                        id: tableName + rec.FieldName,
22405
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
22406
                                        triggerCls: 'x-form-search-trigger',
22407
                                        vtype: 'alphanum', // disable space
22408
                                        nameTable: rec.TableName,
22409
                                        fieldGrid: rec.FieldName,
22410
                                        listeners: {
22411
                                            change: function (val) {
22412
                                                var custumFunc = rec.SelectFunction;
22413
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
22414
                                                    Ext.Ajax.request({
22415
                                                        async: false,
22416
                                                        method: 'POST',
22417
                                                        url: '/UserControl/GetStore',
22418
                                                        params: {
22419
                                                            tableName: 'PCMFUNC',
22420
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
22421
                                                        },
22422
                                                        success: function (response) {
22423
                                                            var results = Ext.decode(response.responseText);
22424
                                                            data_ = results.data[0];
22425
                                                            if (data_ != undefined) {
22426
                                                                custumFunc = data_.FunctionCode;
22427
                                                            }
22428
                                                        }
22429
                                                    });
22430
                                                }
22431
                                                if (custumFunc) {
22432
                                                    eval(custumFunc)
22433
                                                }
22434
                                            }
22435
                                        }
22436
                                    }
22437
                                });
22438
                            } else if (rec.SearchType == '4' && isLookup != true) {
22439
                                cols.push({
22440

    
22441
                                    text: rec.HeaderTitle,
22442
                                    hidden: Hidden_,
22443
                                    dataIndex: rec.FieldName,
22444
                                    filter: {
22445
                                        itemDefaults: {
22446
                                            emptyText: 'Search for...'
22447
                                        }
22448
                                    },
22449
                                    editor: {
22450
                                        allowBlank: null_,
22451
                                        xtype: 'lookupemployee',
22452
                                        readOnly: ReadOnly_,
22453
                                        isGrid: true,
22454
                                        fieldTarget: targetField_,
22455
                                        fieldValue: fieldValue_,
22456
                                        isGrid: true,
22457
                                        id: tableName + rec.FieldName,
22458
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
22459
                                        triggerCls: 'x-form-search-trigger',
22460
                                        vtype: 'alphanum', // disable space
22461
                                        nameTable: rec.TableName,
22462
                                        fieldGrid: rec.FieldName,
22463
                                        listeners: {
22464
                                            change: function (val) {
22465
                                                var custumFunc = rec.SelectFunction;
22466
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
22467
                                                    Ext.Ajax.request({
22468
                                                        async: false,
22469
                                                        method: 'POST',
22470
                                                        url: '/UserControl/GetStore',
22471
                                                        params: {
22472
                                                            tableName: 'PCMFUNC',
22473
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
22474
                                                        },
22475
                                                        success: function (response) {
22476
                                                            var results = Ext.decode(response.responseText);
22477
                                                            data_ = results.data[0];
22478
                                                            if (data_ != undefined) {
22479
                                                                custumFunc = data_.FunctionCode;
22480
                                                            }
22481
                                                        }
22482
                                                    });
22483
                                                }
22484
                                                if (custumFunc) {
22485
                                                    eval(custumFunc)
22486
                                                }
22487
                                            }
22488
                                        }
22489
                                    }
22490
                                });
22491
                            } else {
22492
                                if (rec.FieldDataType == 3) { //add by taufan
22493
                                    cols.push({
22494
                                        text: rec.HeaderTitle,
22495
                                        hidden: Hidden_,
22496
                                        dataIndex: rec.FieldName,
22497
                                        filter: {
22498
                                            itemDefaults: {
22499
                                                emptyText: 'Search for...'
22500
                                            }
22501
                                        },
22502
                                        editor: {
22503
                                            allowBlank: null_,
22504
                                            xtype: 'textfield',
22505
                                            readOnly: ReadOnly_,
22506
                                            id: tableName + rec.FieldName,
22507
                                            nameTable: rec.TableName,
22508
                                            fieldGrid: rec.FieldName,
22509
                                            vtype: 'validateDecimal',
22510
                                            maxLength: rec.Length,
22511
                                            precision: rec.Prec,
22512
                                            fieldStyle: 'text-align:right;',
22513
                                            listeners: {
22514
                                                change: function (val) {
22515
                                                    var custumFunc = null;
22516
                                                    Ext.Ajax.request({
22517
                                                        async: false,
22518
                                                        method: 'POST',
22519
                                                        url: '/UserControl/GetStore',
22520
                                                        params: {
22521
                                                            tableName: 'SDATATABLEFIELD',
22522
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
22523
                                                        },
22524
                                                        success: function (response) {
22525
                                                            var results = Ext.decode(response.responseText);
22526
                                                            data_ = results.data[0];
22527
                                                            if (data_ != undefined) {
22528
                                                                custumFunc = data_.SelectFunction;
22529
                                                                //console.log(data_)
22530
                                                            }
22531
                                                        }
22532
                                                    });
22533

    
22534
                                                    if (custumFunc) {
22535
                                                        eval(custumFunc)
22536
                                                    }
22537
                                                }
22538
                                            }
22539
                                        }
22540
                                    });
22541
                                } else {
22542
                                    cols.push({
22543
                                        text: rec.HeaderTitle,
22544
                                        hidden: Hidden_,
22545
                                        dataIndex: rec.FieldName,
22546
                                        filter: {
22547
                                            itemDefaults: {
22548
                                                emptyText: 'Search for...'
22549
                                            }
22550
                                        },
22551
                                        editor: {
22552
                                            allowBlank: null_,
22553
                                            xtype: 'textfield',
22554
                                            readOnly: ReadOnly_,
22555
                                            id: tableName + rec.FieldName,
22556
                                            nameTable: rec.TableName,
22557
                                            fieldGrid: rec.FieldName,
22558
                                            listeners: {
22559
                                                change: function (val) {
22560
                                                    var custumFunc = null;
22561
                                                    Ext.Ajax.request({
22562
                                                        async: false,
22563
                                                        method: 'POST',
22564
                                                        url: '/UserControl/GetStore',
22565
                                                        params: {
22566
                                                            tableName: 'SDATATABLEFIELD',
22567
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
22568
                                                        },
22569
                                                        success: function (response) {
22570
                                                            var results = Ext.decode(response.responseText);
22571
                                                            data_ = results.data[0];
22572
                                                            if (data_ != undefined) {
22573
                                                                custumFunc = data_.SelectFunction;
22574
                                                                //console.log(data_)
22575
                                                            }
22576
                                                        }
22577
                                                    });
22578

    
22579
                                                    if (custumFunc) {
22580
                                                        eval(custumFunc)
22581
                                                    }
22582
                                                }
22583
                                            }
22584
                                        }
22585
                                    });
22586
                                }
22587
                            }
22588

    
22589
                            break
22590

    
22591
                    }
22592
                } else {
22593
                    cols.push({
22594
                        text: rec.HeaderTitle,
22595
                        hidden: Hidden_,
22596
                        dataIndex: rec.FieldName,
22597
                        hidden: true,
22598
                        editor: {
22599
                            allowBlank: true,
22600
                            xtype: 'textfield',
22601
                            readOnly: ReadOnly_,
22602
                            id: tableName + rec.FieldName,
22603
                            nameTable: rec.TableName,
22604
                            fieldGrid: rec.FieldName,
22605
                        },
22606
                        filter: {
22607
                            itemDefaults: {
22608
                                emptyText: 'Search for...'
22609
                            }
22610
                        }
22611
                    });
22612
                }
22613
            });
22614

    
22615
        };
22616
        addData = addData + "}";
22617
        Ext.applyIf(me, {
22618
            items: [{
22619
                xtype: 'grid',
22620
                id: gridName,
22621
                name: gridName,
22622
                height: height,
22623
                viewConfig: {
22624
                    emptyText: 'No Data Display',
22625
                    deferEmptyText: false,
22626
                    //Add Nana For Autosize Column Mode
22627
                    listeners: {
22628
                        refresh: function (dataview) {
22629
                            Ext.each(dataview.panel.columns, function (column) {
22630
                                //if (column.autoSizeColumn == false)
22631
                                //	column.autoSizeColumn = true;
22632
                                column.autoSize();
22633
                                //dataview.store.reload();
22634
                            })
22635
                        }
22636
                    },
22637
                    render: function (comp) {
22638
                        comp.getStore().reload();
22639
                        console.log(comp);
22640
                    }
22641
                },
22642
                //store: 'gridStore',
22643
                store: Ext.create('Ext.data.Store', {
22644
                    storeId: storeID,
22645
                    fields: fieldStore,
22646
                    proxy: {
22647
                        method: 'POST',
22648
                        type: 'ajax',
22649
                        url: '',
22650
                        reader: {
22651
                            type: 'json',
22652
                            root: 'data'
22653
                        }
22654
                    }
22655
                }),
22656
                dockedItems: [{
22657
                    xtype: 'toolbar',
22658
                    items: [{
22659
                        text: 'Add',
22660
                        hidden: hide_,
22661
                        name: tableName + 'Add',
22662
                        iconCls: 'fa-plus-circle',
22663
                        style: 'font-family: FontAwesome',
22664
                        handler: function () {
22665
                            var store = Ext.StoreMgr.lookup(storeID)
22666
                            idx = store.getCount();
22667
                            var action = getParam('action');
22668
                            var data = '';
22669
                            var Sequence = 0;
22670
                            if (idx == 0) {
22671
                                Sequence = 1;
22672
                            } else {
22673
                                Sequence = 1 + idx;
22674
                            }
22675
                            //data = {
22676
                            //    Sequence: Sequence
22677
                            //};
22678

    
22679
                            var seq = 'Sequence';
22680
                            var SequenceValue = Sequence;
22681
                            eval(addData);
22682
                            data[seq] = SequenceValue;
22683

    
22684
                            store.insert(idx, data);
22685
                        }
22686

    
22687
                    }, {
22688
                        text: 'Delete',
22689
                        hidden: hide_,
22690
                        name: tableName + 'DeleteText',
22691
                        iconCls: 'fa-trash-o',
22692
                        style: 'font-family: FontAwesome',
22693
                        //disabled: true
22694
                        handler: function () {
22695
                            var me = this,
22696
                            store = Ext.StoreMgr.lookup(storeID)
22697

    
22698
                            var grid = Ext.getCmp(gridName);
22699

    
22700
                            Ext.MessageBox.show({
22701
                                title: 'Remove tab',
22702
                                msg: "This will remove. Do you want to continue?",
22703
                                buttons: Ext.MessageBox.YESNO,
22704
                                fn: function (choice) {
22705
                                    console.log(choice);
22706
                                    if (choice === 'yes') {
22707
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
22708
                                        if (selection) {
22709
                                            store.remove(selection);
22710
                                        }
22711
                                    }
22712
                                    //delete panel.pendingClose;
22713
                                }
22714
                            });
22715
                        }
22716

    
22717
                    }
22718
                    ]
22719
                }
22720
                ],
22721
                columns: cols,
22722
                selType: checkSelection,
22723
                //selType: 'rowmodel',
22724
                plugins: {
22725
                    ptype: 'rowediting',
22726
                    pluginId: 'rowEditing',
22727
                    clicksToEdit: 1,
22728
                    listeners: {
22729
                        //edit: 'onGridEditorEdit'
22730
                    }
22731
                }
22732
            }, ]
22733

    
22734
        });
22735

    
22736
        me.callParent(arguments);
22737
    }
22738
});
22739

    
22740
/*Add by Midi ( Tab List Mass Posting ERP DocType AR)*/
22741
Ext.define('MinovaUtil.MinovaES.MinovaTabListDocTransAR', {
22742
	extend: 'Ext.tab.Panel',
22743
	alias: ['widget.doctablistAR'],
22744
	transType: undefined,
22745
	docType: undefined,
22746
	docNo: undefined,
22747
	langId: undefined,
22748
	param: undefined,
22749
	layout: 'fit',
22750
	name: 'panelTabAR',
22751
	id: 'mainTabAR',
22752
	action: undefined,
22753
	initComponent: function () {
22754
		var me = this;
22755
		var documentType = me.docType;
22756
		var transactionType = me.transType;
22757
		var hasil = null;
22758
		var _items = [];
22759
		Ext.Ajax.request({
22760
			async: false,
22761
			method: 'POST',
22762
			url: '/UserControl/GetStore',
22763
			params: {
22764
				tableName: 'PCMBSTRANSLIST',
22765
				param: 'TransType[=]' + me.transType + ',' + 'DocType[=]' + me.docType // add Tri nwh 20240220
22766
			},
22767
			success: function (response) {
22768
				var results = Ext.decode(response.responseText);
22769
				hasil = results.data;
22770
			}
22771
		});
22772
		hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
22773
		if (hasil.length > 0) {
22774
			Ext.each(hasil, function (rec) {
22775
				if (rec.LayoutType == "L004") { // L004=Custom
22776
					var pnl = Ext.create(rec.CustomLayout, {
22777
							title: rec.Title,
22778
							tableName: rec.TableName,
22779
							height: 400,
22780
							name: 'panelTab' + rec.TableName,
22781
							tbl: rec.TableName,
22782
							layoutType: rec.LayoutType
22783
						});
22784
					_items.push(pnl)
22785
				} else if (rec.LayoutType == "L002" || rec.LayoutType == "L003") {
22786
					_items.push({
22787
						xtype: 'panel',
22788
						title: rec.Title,
22789
						name: 'panelTab' + rec.TableName,
22790
						tbl: rec.TableName,
22791
						layoutType: rec.LayoutType,
22792
						items: [{
22793
								xtype: 'docgrid',
22794
								height: 400,
22795
								tableName: rec.TableName,
22796
								docType: me.docType,
22797
								transType: me.transType,
22798
								storename: 'store' + rec.TableName,
22799
								pagesize: 25,
22800
								name: 'GRID' + rec.TableName,
22801
								margin: '0 0 10 0',
22802
								autoLoad: false,
22803
								tbar: [{
22804
										xtype: 'button',
22805
										text: 'Action',
22806
										name: 'actionGrid' + rec.TableName,
22807
										menu: [{
22808
												text: 'Add',
22809
												name: 'add' + rec.TableName,
22810
												tbl: rec.TableName,
22811
												style: 'font-family: FontAwesome',
22812
												iconCls: 'fa-plus-circle',
22813
												handler: function () {
22814
													var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22815
													var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22816
													var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22817
													frmDisplay.reset();
22818
													frmForm.reset();
22819
													frmDisplay.setHidden(true);
22820
													frmForm.setHidden(false);
22821
													grdPanel.setHidden(true);
22822
													action = "0";
22823
												}
22824
											}, {
22825
												text: 'Delete',
22826
												name: 'delete' + rec.TableName,
22827
												tbl: rec.TableName,
22828
												iconCls: 'fa-trash-o',
22829
												style: 'font-family: FontAwesome',
22830
												handler: function () {
22831
													var me = this;
22832
													var store = Ext.StoreMgr.lookup('store' + rec.TableName);
22833
													var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22834
													Ext.MessageBox.show({
22835
														title: 'Remove tab',
22836
														msg: "This will remove. Do you want to continue?",
22837
														buttons: Ext.MessageBox.YESNO,
22838
														fn: function (choice) {
22839
															console.log(choice);
22840
															if (choice === 'yes') {
22841
																var selection = grdPanel.getView().getSelectionModel().getSelection()[0];
22842
																if (selection) {
22843
																	store.remove(selection);
22844
																}
22845
															}
22846
														}
22847
													});
22848
												}
22849
											}
22850
										]
22851
									}, {
22852
										xtype: 'tbfill'
22853
									}, {
22854
										text: 'Clear Filters',
22855
										tooltip: 'Clear all filters',
22856
										name: 'clearbtn',
22857
										handler: function () {}
22858
									}
22859
								],
22860
								dockedItems: [{
22861
										xtype: 'pagingtoolbar',
22862
										store: 'store' + rec.TableName,
22863
										dock: 'bottom',
22864
										pageSize: me.pagesize,
22865
										displayInfo: true
22866
									}
22867
								],
22868
								listeners: {
22869
									'itemdblclick': function (me, record, item, index, e, eOpts) {
22870
										var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22871
										var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22872
										var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22873
										frmDisplay.reset();
22874
										frmForm.reset();
22875
										frmDisplay.getForm().setValues(record.data);
22876
										frmForm.getForm().setValues(record.data);
22877
										frmDisplay.setHidden(false);
22878
										frmForm.setHidden(true);
22879
										grdPanel.setHidden(true);
22880
										me.action = "1";
22881
									}
22882
								}
22883
							}, {
22884
								xtype: 'minovadocform',
22885
								name: 'DISPLAY' + rec.TableName,
22886
								id: 'DISPLAY' + rec.TableName,
22887
								itemId: 'DISPLAY' + rec.TableName,
22888
								tableName: rec.TableName,
22889
								docType: me.docType,
22890
								transType: me.transType,
22891
								isDisplay: true,
22892
								hidden: true,
22893
								buttons: [{
22894
										text: 'Edit',
22895
										name: 'editDISPLAY' + rec.TableName,
22896
										handler: function () {
22897
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22898
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22899
											var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22900
											frmDisplay.setHidden(true);
22901
											frmForm.setHidden(false);
22902
											grdPanel.setHidden(true);
22903
										}
22904
									}, {
22905
										text: 'Cancel',
22906
										name: 'cancelDISPLAY' + rec.TableName,
22907
										handler: function () {
22908
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22909
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22910
											var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22911
											frmDisplay.setHidden(true);
22912
											frmForm.setHidden(true);
22913
											grdPanel.setHidden(false);
22914
											grdPanel.getStore().reload();
22915
										}
22916
									}
22917
								]
22918
							}, {
22919
								xtype: 'minovadocform',
22920
								name: 'FORM' + rec.TableName,
22921
								id: 'FORM' + rec.TableName,
22922
								itemId: 'FORM' + rec.TableName,
22923
								tableName: rec.TableName,
22924
								docType: me.docType,
22925
								transType: me.transType,
22926
								isDisplay: false,
22927
								hidden: true,
22928
								buttons: [{
22929
										text: 'Submit',
22930
										name: 'submitFORM' + rec.TableName,
22931
										handler: function () {
22932
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22933
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22934
											var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22935
											var frm = frmForm.getForm();
22936
											if (frm.isValid()) {
22937
												var table = rec.TableName;
22938
												var data = frmForm.getValues();
22939
												var token = MinovaUtil.SESSIONS.Token;
22940
												var str = grdPanel.getStore();
22941
												var idx = str.getCount();
22942
												str.insert(idx, data);
22943
												frmDisplay.setHidden(true);
22944
												frmForm.setHidden(true);
22945
												grdPanel.setHidden(false);
22946
											}
22947
										}
22948
									}, {
22949
										text: 'Cancel',
22950
										name: 'cancelFORM' + rec.TableName,
22951
										handler: function () {
22952
											MinovaMessage('Message', '000011', '', 'C', function (respone) {
22953
												if (respone == "yes") {
22954
													var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22955
													var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22956
													var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22957
													frmDisplay.setHidden(true);
22958
													frmForm.setHidden(true);
22959
													grdPanel.setHidden(false);
22960
												}
22961
											});
22962
										}
22963
									}
22964
								]
22965
							}
22966
						]
22967
					});
22968
				} else if (rec.LayoutType == "L005") { // Grid View Only
22969
					_items.push({
22970
						xtype: 'panel',
22971
						title: rec.Title,
22972
						name: 'panelTab' + rec.TableName,
22973
						tbl: rec.TableName,
22974
						layoutType: rec.LayoutType,
22975
						items: [{
22976
								xtype: 'docgrid',
22977
								height: 400,
22978
								tableName: rec.TableName,
22979
								docType: me.docType,
22980
								transType: me.transType,
22981
								storename: 'store' + rec.TableName,
22982
								pagesize: 25,
22983
								name: 'GRID' + rec.TableName,
22984
								margin: '0 0 10 0',
22985
								autoLoad: false,
22986
								tbar: [{
22987
										xtype: 'tbfill'
22988
									}, {
22989
										text: 'Clear Filters',
22990
										tooltip: 'Clear all filters',
22991
										name: 'clearbtn',
22992
										handler: function () {}
22993
									}
22994
								],
22995
								dockedItems: [{
22996
										xtype: 'pagingtoolbar',
22997
										store: 'store' + rec.TableName,
22998
										dock: 'bottom',
22999
										pageSize: me.pagesize,
23000
										displayInfo: true
23001
									}
23002
								]
23003
							}
23004
						]
23005
					});
23006
				} else if (rec.LayoutType == "L006") {
23007
					_items.push({
23008
						xtype: 'panel',
23009
						title: rec.Title,
23010
						name: 'panelTab' + rec.TableName,
23011
						tbl: rec.TableName,
23012
						layoutType: rec.LayoutType,
23013
						items: [{
23014
								xtype: 'docgridcelledit',
23015
								name: 'CELLGRID' + rec.TableName,
23016
								tableName: rec.TableName,
23017
								docType: me.docType,
23018
								transType: me.transType,
23019
								docNo: me.docNo,
23020
								height: 400,
23021
								hideButton: false,
23022
								margin: '0 0 10 0'
23023
							}
23024
						]
23025
					});
23026
				} else if (rec.LayoutType == "L007") {
23027
					_items.push({
23028
						xtype: 'panel',
23029
						title: rec.Title,
23030
						name: 'panelTab' + rec.TableName,
23031
						tbl: rec.TableName,
23032
						layoutType: rec.LayoutType,
23033
						items: [{
23034
								xtype: 'docgridcelleditsum',
23035
								name: 'CELLGRID' + rec.TableName,
23036
								tableName: rec.TableName,
23037
								docType: me.docType,
23038
								transType: me.transType,
23039
								docNo: me.docNo,
23040
								height: 400,
23041
								hideButton: false,
23042
								margin: '0 0 10 0'
23043
							}, {
23044
								xtype: 'summarydocform',
23045
								name: 'SUM' + rec.TableName,
23046
								id: 'SUM' + rec.TableName,
23047
								itemId: 'SUM' + rec.TableName,
23048
								tableName: rec.TableName,
23049
								docType: me.docType,
23050
								transType: me.transType,
23051
							}
23052
						]
23053
					});
23054
				} else { // L001=Default Form Only
23055
					_items.push({
23056
						xtype: 'panel',
23057
						title: rec.LabelName,
23058
						name: 'panelTab' + rec.TableName,
23059
						tbl: rec.TableName,
23060
						layoutType: rec.LayoutType,
23061
						items: [{
23062
								xtype: 'minovadocform',
23063
								name: 'DISPLAY' + rec.TableName,
23064
								id: 'DISPLAY' + rec.TableName,
23065
								itemId: 'DISPLAY' + rec.TableName,
23066
								tableName: rec.TableName,
23067
								docType: me.docType,
23068
								transType: me.transType,
23069
								isDisplay: true,
23070
								hidden: false,
23071
								buttons: [{
23072
										text: 'Edit',
23073
										name: 'editDISPLAY' + rec.TableName,
23074
										iconCls: 'fa-edit',
23075
										style: 'font-family: FontAwesome',
23076
										handler: function () {
23077
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23078
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23079
											frmDisplay.setHidden(true);
23080
											frmForm.setHidden(false);
23081
											me.action = "1";
23082
										}
23083
									}, {
23084
										text: 'Cancel',
23085
										name: 'cancelDISPLAY' + rec.TableName,
23086
										iconCls: 'fa-reply',
23087
										style: 'font-family: FontAwesome',
23088
										hidden: true
23089
									}
23090
								]
23091
							}, {
23092
								xtype: 'minovadocform',
23093
								name: 'FORM' + rec.TableName,
23094
								id: 'FORM' + rec.TableName,
23095
								itemId: 'FORM' + rec.TableName,
23096
								tableName: rec.TableName,
23097
								docType: me.docType,
23098
								transType: me.transType,
23099
								isDisplay: false,
23100
								hidden: true,
23101
								buttons: [{
23102
										text: 'Save',
23103
										name: 'saveDISPLAY' + rec.TableName,
23104
										iconCls: 'fa-save',
23105
										style: 'font-family: FontAwesome',
23106
										handler: function () {
23107
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23108
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23109
											 var headerDisplay =undefined;
23110
											if(rec.TableName=="PTRPRODUCTIONHEAD"){
23111
												headerDisplay=Ext.ComponentQuery.query('[name=MainHeaderDocument]')[0];
23112
												frmForm.getForm().findField("DocNo").setValue(headerDisplay.getForm().findField("DocNo").getValue());
23113
										frmForm.getForm().findField("DocType").setValue(headerDisplay.getForm().findField("DocType").getValue());
23114
										frmForm.getForm().findField("ProcessID").setValue(headerDisplay.getForm().findField("ProcessID").getValue());
23115
										frmForm.getForm().findField("DocDate").setValue(headerDisplay.getForm().findField("DocDate").getValue());
23116
										frmForm.getForm().findField("DocStatus").setValue(headerDisplay.getForm().findField("DocStatus").getValue());
23117
										frmForm.getForm().findField("OrderDate").setValue(headerDisplay.getForm().findField("OrderDate").getValue());
23118
										frmForm.getForm().findField("Description").setValue(headerDisplay.getForm().findField("Description").getValue());	
23119
										frmForm.getForm().findField("FinishGoods").setValue(headerDisplay.getForm().findField("FinishGoods").getValue());	
23120
											}else{
23121
												headerDisplay=Ext.ComponentQuery.query('[name=MainHeaderMDLogistic]')[0];	
23122
											}
23123
											var frm = frmForm.getForm();
23124
											if (frm.isValid()) {
23125
												
23126
												
23127
												var table = rec.TableName;
23128
												var data = Ext.encode(frmForm.getValues());
23129
												var token = MinovaUtil.SESSIONS.Token;
23130
												var action=action;
23131
												if(action==undefined){action=0};
23132
												var params = {
23133
													apiController: 'api/Devt',
23134
													methodName: 'SaveTableMaster',
23135
													parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
23136
												};
23137
												MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
23138
													var result = Ext.decode(xhr.responseText);
23139
													var r = Ext.decode(result.data);
23140
													if (r.success) {
23141
														headerDisplay.mask("Loading...");
23142
														var idNo = r.data;
23143
														frmForm.getForm().findField("DocNo").setValue(idNo);
23144
														frmDisplay.getForm().setValues(frmForm.getValues());
23145
												headerDisplay.getForm().setValues(frmForm.getValues());
23146
														frmDisplay.setHidden(false);
23147
														frmForm.setHidden(true);
23148
														MinovaMessage('Not Null', '000006', '', 'S');
23149
														headerDisplay.unmask();
23150
													} else {
23151
														MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
23152
													}
23153
												});
23154
											}
23155
										}
23156
									}, {
23157
										text: 'Delete',
23158
										name: 'deleteDISPLAY' + rec.TableName,
23159
										iconCls: 'fa-trash-o',
23160
										style: 'font-family: FontAwesome',
23161
										handler: function () {}
23162
									}, {
23163
										text: 'Cancel',
23164
										name: 'cancelDISPLAY' + rec.TableName,
23165
										iconCls: 'fa-reply',
23166
										style: 'font-family: FontAwesome',
23167
										handler: function () {
23168
											MinovaMessage('Message', '000011', '', 'C', function (respone) {
23169
												if (respone == "yes") {
23170
													var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23171
													var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23172
													frmDisplay.setHidden(false);
23173
													frmForm.setHidden(true);
23174
												}
23175
											});
23176
										}
23177
									}
23178
								]
23179
							}
23180
						]
23181
					});
23182
				}
23183
			});
23184
		}
23185
		Ext.applyIf(me, {
23186
			items: _items
23187
		});
23188
		me.callParent(arguments);
23189
	}
23190
});
23191

    
23192
/*Add by YN ( Tab List for PA on Top)*/
23193
Ext.define('MinovaUtil.MinovaES.MinovaHeaderMDNew', {
23194
    extend: 'Ext.form.Panel',
23195
    alias: ['widget.MinovaHeadermdNew', 'widget.MinovaHeaderMDNew'],
23196
    allTableName: undefined,
23197
    param: undefined,
23198
    //frame: true,
23199
    resizable: true,
23200
    autoScroll: true,
23201
    minHeight: 20,
23202
    layout: 'column',
23203
    name: 'HeaderMD',
23204
    getAllTableName: function () {
23205
        return this.allTableName;
23206
    },
23207
    setAllTableName: function (value) {
23208
        var me = this;
23209
        me.allTableName = value;
23210
        return me;
23211
    },
23212
    listeners: {
23213
        afterrender: function (me) {
23214
            var nowDate = MinovaUtil.GetNowDate()
23215
            var allTbl = me.getAllTableName();
23216
            //alert(allTbl);
23217
            var splitTable = allTbl.split(',')
23218
            splitTable.forEach(function (tbl) {
23219
                // console.log(tbl);
23220
                //set values form
23221
                var nowDate = MinovaUtil.GetNowDate();
23222
                parameter = null;
23223
                if (me.isEmployee == true) {
23224
                    parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("EmployeeID")
23225
                } else {
23226
                    parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
23227
                }
23228
                Ext.Ajax.request({
23229
                    method: 'POST',
23230
                    //async: false,
23231
                    url: '/UserControl/GetStore',
23232
                    params: {
23233
                        tableName: tbl,
23234
                        param: parameter
23235
                    },
23236
                    success: function (response) {
23237
                        var results = Ext.decode(response.responseText);
23238
                        hasil = results.data;
23239
                        if (hasil.length > 0) {
23240
                            me.getForm().setValues(hasil[0]);
23241

    
23242
                            //console.log(me)
23243
                        }
23244

    
23245
                    }
23246
                });
23247
            });
23248

    
23249
            //setTimeout(function () {
23250
            //    // var me_ = Ext.ComponentQuery.query('[name=Header]')[0];
23251
            //    // me_.setTitle(me_.getTitle() + ' - ' + Ext.ComponentQuery.query('[name=FullName]')[0].getValue());
23252
            //}, 100);
23253

    
23254
        },
23255

    
23256
    },
23257

    
23258
    initComponent: function () {
23259
        var me = this;
23260
        var col1 = [];
23261
        var col2 = [];
23262
        var hasil = null;
23263
        //get moduletype
23264
        //var ModuleType = 'PA';
23265
        //var ModuleType = MinovaUtil.GetModuleType()
23266
        //get Lang
23267
        var LangId = localStorage.LangId;
23268
        var allTable = null;
23269
        var tbl = null;
23270
        var tblTemp = null;
23271
        var nowDate = MinovaUtil.GetNowDate();
23272
        //var Photo_ = 'nophoto.gif';
23273
        var Photo = 'nophoto.gif';
23274
        tableName = null;
23275
        parameter = null;
23276
        // get Photo
23277
        //hamid200916
23278
        if (me.isEmployee == true) {
23279
            tableName = 'PHRPA0001';
23280
            parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("EmployeeID");
23281
        } else {
23282
            tableName = 'PHRRC0001';
23283
            parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
23284
        }
23285
        Ext.Ajax.request({
23286
            method: 'POST',
23287
            async: false,
23288
            url: '/UserControl/GetStore',
23289
            params: {
23290
                tableName: tableName,
23291
                param: parameter
23292
            },
23293
            success: function (response) {
23294
                var results = Ext.decode(response.responseText);
23295
                hasil = results.data;
23296
                if (hasil.length > 0) {
23297
                    dataPhoto = hasil[0].Picture
23298
                    if (dataPhoto != "") {
23299
                        Photo = dataPhoto;
23300
                    }
23301
                }
23302

    
23303
            }
23304
        });
23305

    
23306
        var hasil = undefined;
23307
        Ext.Ajax.request({
23308
            async: false,
23309
            method: 'POST',
23310
            url: '/UserControl/GetStore',
23311
            params: {
23312
                tableName: 'PDSBS0009',
23313
                param: 'MenuID[=]' + MinovaUtil.GetMenuID() + ',LangId[=]' + LangId
23314
            },
23315
            success: function (response) {
23316
                hasil = Ext.decode(response.responseText).data;
23317

    
23318
            }
23319
        });
23320

    
23321
        //sorting results
23322
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
23323
        if (hasil.length > 0) {
23324
            Ext.each(hasil, function (rec) {
23325
                tblTemp = rec.TableName;
23326
                if (tbl != tblTemp) {
23327
                    tbl = tblTemp;
23328
                    if (allTable == null) {
23329
                        allTable = tbl
23330
                    } else {
23331
                        allTable = allTable + ',' + tbl
23332
                    }
23333

    
23334
                }
23335
                // build form
23336
                if (rec.TableRef != '') {
23337
                    valueField = null;
23338
                    displayValue = null;
23339
                    Ext.Ajax.request({
23340
                        async: false,
23341
                        method: 'POST',
23342
                        url: '/UserControl/GetStore',
23343
                        params: {
23344
                            tableName: 'SDATATABLEFIELD',
23345
                            param: 'TableName[equal]' + rec.TableRef
23346
                        },
23347
                        success: function (response) {
23348
                            var results = Ext.decode(response.responseText);
23349
                            data_ = results.data;
23350
                            if (data_ != undefined) {
23351
                                valueField_ = $.grep(data_, function (r) {
23352
                                    return r.ValueField == '1'
23353
                                });
23354
                                if (valueField_.length > 0) {
23355
                                    valueField = valueField_[0].FieldName
23356
                                }
23357

    
23358
                                displayValue_ = $.grep(data_, function (r) {
23359
                                    return r.DisplayValue == '1'
23360
                                });
23361
                                if (displayValue_.length > 0) {
23362
                                    displayValue = displayValue_[0].FieldName
23363
                                }
23364
                            }
23365
                        }
23366
                    });
23367

    
23368
                    formfield = new Ext.form.Display({
23369
                        fieldLabel: rec.ScreenCaption,
23370
                        name: rec.FieldName,
23371
                        //value: rec.DefaultValue,
23372
                        padding: 0,
23373
                        labelCls: 'label-minova',
23374
                        labelWidth: 150,
23375
                        anchor: '80%',
23376
                        store: Ext.create('Ext.data.Store', {
23377
                            storeId: 'storeDisplay' + rec.FieldName,
23378
                            //autoLoad: true,
23379
                            proxy: {
23380
                                method: 'POST',
23381
                                type: 'ajax',
23382
                                extraParams: {
23383
                                    tableName: rec.TableRef,
23384
                                    param: ''
23385
                                },
23386
                                reader: {
23387
                                    type: 'json',
23388
                                    root: 'data',
23389
                                    totalProperty: 'data[0].TotalCount'
23390
                                }
23391
                            }
23392
                        }),
23393
                        listeners: {
23394
                            afterrender: function (f) {
23395
                                var store = Ext.StoreMgr.lookup('storeDisplay' + rec.FieldName);
23396
                                var ParamCombo = rec.ParamCombo;
23397
                                var param = '';
23398
                                //if (ParamCombo != '') {
23399
                                if ((rec.TableRef).toLowerCase() == 'phrom0001') {
23400
                                    var splitParam = ParamCombo.split(']');
23401
                                    switch (rec.FieldName) {
23402
                                        case 'Position':
23403
                                            ParamCombo = 'P'
23404
                                            break;
23405
                                        case 'CostCenter':
23406
                                            ParamCombo = 'CC'
23407
                                            break;
23408
                                        case 'Organization':
23409
                                            ParamCombo = 'O'
23410
                                            break;
23411
                                        case 'Job':
23412
                                            ParamCombo = 'J'
23413
                                            break;
23414
                                    }
23415
                                    //if (splitParam.length == 1) {
23416
                                    param = 'StartDate[<=]' + MinovaUtil.GetNowDate() + 'EndDate[>=]' + MinovaUtil.GetNowDate() + ',ObjectClass[=]' + ParamCombo
23417
                                    //} else {
23418
                                    //    param = ParamCombo;
23419
                                    //}
23420
                                }
23421
                                //}
23422
                                Ext.Ajax.request({
23423
                                    method: 'POST',
23424
                                    async: false,
23425
                                    url: '/UserControl/GetStore',
23426
                                    params: {
23427
                                        tableName: rec.TableRef,
23428
                                        param: param
23429
                                    },
23430
                                    success: function (response) {
23431
                                        var results = Ext.decode(response.responseText);
23432

    
23433
                                        //dt = results.data;
23434
                                        store.loadData(results.data);
23435

    
23436
                                    }
23437
                                });
23438
                            },
23439
                            change: function (f) {
23440
                                //alert(this.valueField, value);
23441
                                var display = this.displayField;
23442
                                var value = this.getValue();
23443
                                var st = f.store
23444
                                var r = st.findRecord(f.valueField, f.value)
23445
                                if (r != null) {
23446
                                    f.setRawValue(r.get(f.displayField))
23447
                                } else {
23448
                                    f.setRawValue(f.value);
23449

    
23450
                                }
23451
                            }
23452
                        },
23453
                        queryMode: 'local',
23454
                        displayField: displayValue,
23455
                        valueField: valueField,
23456
                    });
23457
                }
23458
                else {
23459
                    formfield = new Ext.form.Display({
23460
                        fieldLabel: rec.ScreenCaption,
23461
                        name: rec.FieldName,
23462
                        labelCls: 'label-minova',
23463
                        labelWidth: 150,
23464
                        //value: rec.DefaultValue,
23465
                        padding: 0,
23466
                        anchor: '80%'
23467
                    });
23468
                }
23469
                if (isDesk) {
23470
                    if (rec.Column == 1) {
23471
                        col1.push(formfield);
23472
                    } else {
23473
                        col2.push(formfield);
23474
                    }
23475
                } else {
23476
                    col1.push(formfield);
23477
                }
23478

    
23479
            });
23480
            //set allTable
23481
            this.setAllTableName(allTable);
23482
        }
23483

    
23484
        Ext.applyIf(me, {
23485
            items: [
23486
                {
23487
                    width: 150,
23488
                    //margin: '10 5 3 30',
23489
                    margin: '5 0 0 30',
23490
                    height: 130,
23491
                    items: [
23492
                        {
23493
                            xtype: 'image',
23494
                            id: 'imageusermd',
23495
                            name: 'imageusermd',
23496
                            width: 120,
23497
                            height: 120,
23498
                            padding: 5,
23499
                            border: true,
23500
                            src: '/Devt/GetFileData?FileName=' + Photo + '&download=false',
23501
                        }
23502
                    ]
23503
                },
23504
                {
23505
                    bodyPadding: 0,
23506
                    width: 300,
23507
                    margin: '15 0 0 30', //margin: '10 5 3 30',
23508
                    items: col1
23509
                },
23510
                {
23511
                    bodyPadding: 0,
23512
                    //width: 350,
23513
                    margin: '15 0 0 30', //margin: '10 5 3 30',
23514
                    items: col2
23515
                }
23516
            ],
23517
        });
23518

    
23519
        me.callParent(arguments);
23520

    
23521
    }
23522
});
23523

    
23524
//panelTab->panelTab+TableName->GRID+TableName | DISPLAY+TableName | FORM+TableName 
23525
Ext.define('MinovaUtil.MinovaES.MinovaTabListMDNew', {
23526
    extend: 'Ext.tab.Panel',
23527
    alias: ['widget.MinovaTabListMDNew'],
23528
    mixins: [
23529
        'Ext.util.StoreHolder'
23530
    ],
23531
    config: {
23532
        titleField: 'title'
23533
    },
23534
    name: 'gridMenuMD',
23535
    id: 'mainTab',
23536
    moduleType: undefined,
23537
    tablenameheader: undefined,
23538
    langId: undefined,
23539
    param: undefined,
23540
    frame: true,
23541
    //style: {
23542
    //    background: '#ffc'
23543
    //},
23544
    //cls: 'modern-tabpanel',
23545
    //bodyStyle: {
23546
    //    background: '#ffc',
23547
    //    padding: '10px'
23548
    //},
23549
    defaults: {
23550
        scrollable: true,
23551
        iconAlign: 'top',
23552
        userSelectable: {
23553
            bodyElement: true
23554
        }
23555
    },
23556
    tabBar: {
23557
        layout: { pack: 'center' }
23558
    },
23559
    initComponent: function () {
23560
        var me = this;
23561
        var hasil = null;
23562
        var _items = [];
23563

    
23564
        // Ambil Daftar Master Data dari PCMEPMDLIST untuk ditampilkan di Tab
23565
        Ext.Ajax.request({
23566
            async: false,
23567
            method: 'POST',
23568
            url: '/UserControl/GetStore',
23569
            params: {
23570
                tableName: 'PCMEPMDLIST',
23571
                param: 'ModuleType[=]' + me.moduleType + ',Language[=]' + me.langId
23572
            },
23573
            success: function (response) {
23574
                var results = Ext.decode(response.responseText);
23575
                hasil = results.data;
23576
            }
23577
        });
23578
        hasil = hasil.sort(MinovaUtil.SortBySeq("Sequence"));
23579

    
23580
        // Jika Daftar Master ada, Load dari Table PA satu persatu ke setiap Tab
23581
        if (hasil.length > 0) {
23582
            Ext.each(hasil, function (rec) {
23583
                if ((rec.LayoutType == "L003") || (rec.LayoutType == "L004"))  { // L003=GRID, DISPLAY, FORM
23584
                    //panelTab+TableName
23585
                    _items.push({
23586
                        xtype: 'panel',
23587
                        iconCls: rec.IconCls, //"fa fa-address-book-o",
23588
                        title: rec.LabelName,
23589
                        name: 'panelTab' + rec.TableName,
23590
                        record: rec, //dipanggil di mainNew1Controller.js
23591
                        tbl: rec.TableName,
23592
                        //layout: 'center', //bikin layout kacau
23593
                        //cls: 'card',
23594
                        //items: [
23595
                        //    //GRID+TableName (minovagrid1)
23596
                        //    {
23597
                        //        xtype: 'minovagrid1new',
23598
                        //        height: 450,
23599
                        //        tableName: rec.TableName,
23600
                        //        storename: 'store' + rec.TableName,
23601
                        //        pagesize: 25,
23602
                        //        name: 'GRID' + rec.TableName,
23603
                        //        margin: '0 0 10 0',
23604
                        //        autoLoad: false,
23605
                        //        param: 'EmployeeID[=]' + getParam("EmployeeID"),
23606
                        //        //Top Toolbar
23607
                        //        tbar: [
23608
                        //            //tbfill
23609
                        //            {
23610
                        //                xtype: 'tbfill'
23611
                        //            },
23612
                        //            //Combo Action
23613
                        //            {
23614
                        //                xtype: 'button',
23615
                        //                text: 'Action',
23616
                        //                name: 'actionGrid' + rec.TableName,
23617
                        //                menu: [
23618
                        //                    //Add
23619
                        //                    {
23620
                        //                        text: 'Add',
23621
                        //                        name: 'add' + rec.TableName,
23622
                        //                        tbl: rec.TableName,
23623
                        //                        style: 'font-family: FontAwesome',
23624
                        //                        iconCls: 'fa-plus-circle',
23625
                        //                        handler: function () {
23626
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23627
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23628
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23629
                        //                            var keyField = getParam("KeyID");
23630
                        //                            var keyValue = getParam("KeyValue");
23631
                        //                            frmDisplay.reset();
23632
                        //                            frmForm.reset();
23633
                        //                            var idseq = 0;
23634
                        //                            var params = {
23635
                        //                                apiController: 'api/Devt',
23636
                        //                                methodName: 'GetLastSeqID',
23637
                        //                                parameter: 'tableName=' + rec.TableName + '&keyField=' + keyField + '&keyValue=' + keyValue
23638
                        //                            };
23639
                        //                            MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
23640
                        //                                var result = Ext.decode(xhr.responseText);
23641
                        //                                var r = Ext.decode(result.data);
23642
                        //                                idseq = r.data + 1;
23643
                        //                                frmForm.getForm().findField(keyField).setValue(keyValue);
23644
                        //                                frmForm.getForm().findField("SeqID").setValue(idseq);
23645
                        //                            });
23646
                        //                            frmDisplay.setHidden(true);
23647
                        //                            frmForm.setHidden(false);
23648
                        //                            grdPanel.setHidden(true);
23649
                        //                            action = "0";
23650
                        //                        }
23651
                        //                    },
23652
                        //                    //Copy
23653
                        //                    {
23654
                        //                        text: 'Copy',
23655
                        //                        name: 'copy' + rec.TableName,
23656
                        //                        tbl: rec.TableName,
23657
                        //                        iconCls: 'fa-copy',
23658
                        //                        style: 'font-family: FontAwesome',
23659
                        //                        handler: function () {
23660
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23661
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23662
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23663
                        //                            var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
23664
                        //                            var keyField = getParam("KeyID");
23665
                        //                            if (dtrec) {
23666
                        //                                frmDisplay.reset();
23667
                        //                                frmForm.reset();
23668
                        //                                frmForm.getForm().setValues(dtrec.data);
23669
                        //                                frmDisplay.setHidden(true);
23670
                        //                                frmForm.setHidden(false);
23671
                        //                                grdPanel.setHidden(true);
23672
                        //                                action = "0";
23673
                        //                                frmForm.getForm().findField(keyField).setValue("");
23674
                        //                            }
23675
                        //                        }
23676
                        //                    },
23677
                        //                    //Edit
23678
                        //                    {
23679
                        //                        text: 'Edit',
23680
                        //                        name: 'edit' + rec.TableName,
23681
                        //                        tbl: rec.TableName,
23682
                        //                        iconCls: 'fa-edit',
23683
                        //                        style: 'font-family: FontAwesome',
23684
                        //                        handler: function () {
23685
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23686
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23687
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23688
                        //                            var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
23689
                        //                            if (dtrec) {
23690
                        //                                frmDisplay.reset();
23691
                        //                                frmForm.reset();
23692
                        //                                frmForm.getForm().setValues(dtrec.data);
23693
                        //                                frmDisplay.setHidden(true);
23694
                        //                                frmForm.setHidden(false);
23695
                        //                                grdPanel.setHidden(true);
23696
                        //                                action = "1";
23697
                        //                            }
23698
                        //                        }
23699
                        //                    }
23700
                        //                ]
23701
                        //            },
23702
                        //            //Btn Clear Filter
23703
                        //            {
23704
                        //                text: 'Clear Filters',
23705
                        //                tooltip: 'Clear all filters',
23706
                        //                name: 'clearbtn',
23707
                        //                handler: function () { }
23708
                        //            }
23709
                        //        ],
23710
                        //        //Paging Toolbar
23711
                        //        dockedItems: [
23712
                        //            {
23713
                        //                xtype: 'pagingtoolbar',
23714
                        //                store: 'store' + rec.TableName,
23715
                        //                dock: 'bottom',
23716
                        //                pageSize: me.pagesize,
23717
                        //                displayInfo: true
23718
                        //            }
23719
                        //        ],
23720
                        //        //Event Event itemdblclick
23721
                        //        listeners: {
23722
                        //            'itemdblclick': function (me, record, item, index, e, eOpts) {
23723
                        //                var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23724
                        //                var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23725
                        //                var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23726
                        //                frmDisplay.reset();
23727
                        //                frmForm.reset();
23728
                        //                frmDisplay.getForm().setValues(record.data);
23729
                        //                frmForm.getForm().setValues(record.data);
23730
                        //                frmDisplay.setHidden(false);
23731
                        //                frmForm.setHidden(true);
23732
                        //                grdPanel.setHidden(true);
23733
                        //                action = "1";
23734
                        //            }
23735
                        //        }
23736
                        //    },
23737
                        //    //DISPLAY+TableName (minovaform)
23738
                        //    {
23739
                        //        xtype: 'minovaformnew',
23740
                        //        name: 'DISPLAY' + rec.TableName,
23741
                        //        id: 'DISPLAY' + rec.TableName,
23742
                        //        itemId: 'DISPLAY' + rec.TableName,
23743
                        //        tableName: rec.TableName,
23744
                        //        isDisplay: true,
23745
                        //        hidden: true,
23746
                        //        buttons: [
23747
                        //            {
23748
                        //                text: 'Edit',
23749
                        //                name: 'editDISPLAY' + rec.TableName,
23750
                        //                iconCls: 'fa-edit',
23751
                        //                style: 'font-family: FontAwesome',
23752
                        //                handler: function () {
23753
                        //                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23754
                        //                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23755
                        //                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23756
                        //                    frmDisplay.setHidden(true);
23757
                        //                    frmForm.setHidden(false);
23758
                        //                    grdPanel.setHidden(true);
23759
                        //                }
23760
                        //            },
23761
                        //            {
23762
                        //                text: 'Cancel',
23763
                        //                name: 'cancelDISPLAY' + rec.TableName,
23764
                        //                iconCls: 'fa-reply',
23765
                        //                style: 'font-family: FontAwesome',
23766
                        //                handler: function () {
23767
                        //                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23768
                        //                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23769
                        //                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23770
                        //                    frmDisplay.setHidden(true);
23771
                        //                    frmForm.setHidden(true);
23772
                        //                    grdPanel.setHidden(false);
23773
                        //                }
23774
                        //            }
23775
                        //        ]
23776
                        //    },
23777
                        //    //FORM+TableName (minovaform)
23778
                        //    {
23779
                        //        xtype: 'minovaformnew',
23780
                        //        name: 'FORM' + rec.TableName,
23781
                        //        id: 'FORM' + rec.TableName,
23782
                        //        itemId: 'FORM' + rec.TableName,
23783
                        //        tableName: rec.TableName,
23784
                        //        isDisplay: false,
23785
                        //        hidden: true,
23786
                        //        buttons: [
23787
                        //            {
23788
                        //                text: 'Save',
23789
                        //                name: 'saveFORM' + rec.TableName,
23790
                        //                iconCls: 'fa-save',
23791
                        //                style: 'font-family: FontAwesome',
23792
                        //                handler: function () {
23793
                        //                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23794
                        //                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23795
                        //                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23796
                        //                    var frm = frmForm.getForm();
23797
                        //                    if (frm.isValid()) {
23798
                        //                        var keyField = getParam("KeyID");
23799
                        //                        var table = rec.TableName;
23800
                        //                        var data = Ext.encode(frmForm.getValues());
23801
                        //                        var token = MinovaUtil.SESSIONS.Token;
23802
                        //                        var params = {
23803
                        //                            apiController: 'api/Devt',
23804
                        //                            methodName: 'SaveTableMaster',
23805
                        //                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
23806
                        //                        };
23807
                        //                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
23808
                        //                            var result = Ext.decode(xhr.responseText);
23809
                        //                            var r = Ext.decode(result.data);
23810
                        //                            if (r.success) {
23811
                        //                                frmDisplay.setHidden(true);
23812
                        //                                frmForm.setHidden(true);
23813
                        //                                grdPanel.setHidden(false);
23814
                        //                                grdPanel.getStore().reload();
23815
                        //                                MinovaMessage('Not Null', '000006', '', 'S');
23816
                        //                            } else {
23817
                        //                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
23818
                        //                            }
23819
                        //                        });
23820
                        //                    }
23821
                        //                }
23822
                        //            },
23823
                        //            {
23824
                        //                text: 'Delete',
23825
                        //                name: 'deleteFORM' + rec.TableName,
23826
                        //                iconCls: 'fa-trash-o',
23827
                        //                style: 'font-family: FontAwesome ',
23828
                        //                handler: function () {
23829
                        //                    MinovaMessage(' Message ', ' 000007 ', ' ', 'C', function (respone) {
23830
                        //                        if (respone == "yes") {
23831
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23832
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23833
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23834
                        //                            var frm = frmForm.getForm();
23835
                        //                            if (frm.isValid()) {
23836
                        //                                var keyField = getParam("KeyID");
23837
                        //                                var table = rec.TableName;
23838
                        //                                var data = Ext.encode(frmForm.getValues());
23839
                        //                                var token = MinovaUtil.SESSIONS.Token;
23840
                        //                                action = "2";
23841
                        //                                var params = {
23842
                        //                                    apiController: 'api/Devt',
23843
                        //                                    methodName: 'SaveTableMaster',
23844
                        //                                    parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
23845
                        //                                };
23846
                        //                                MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
23847
                        //                                    var result = Ext.decode(xhr.responseText);
23848
                        //                                    var r = Ext.decode(result.data);
23849
                        //                                    if (r.success) {
23850
                        //                                        frmDisplay.setHidden(true);
23851
                        //                                        frmForm.setHidden(true);
23852
                        //                                        grdPanel.setHidden(false);
23853
                        //                                        grdPanel.getStore().reload();
23854
                        //                                        MinovaMessage('Not Null', '000006', '', 'S');
23855
                        //                                    } else {
23856
                        //                                        MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
23857
                        //                                    }
23858
                        //                                });
23859
                        //                            }
23860
                        //                        }
23861
                        //                    });
23862
                        //                }
23863
                        //            },
23864
                        //            {
23865
                        //                text: 'Cancel',
23866
                        //                name: 'cancelFORM' + rec.TableName,
23867
                        //                iconCls: 'fa-reply',
23868
                        //                style: 'font-family: FontAwesome',
23869
                        //                handler: function () {
23870
                        //                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
23871
                        //                        if (respone == "yes") {
23872
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23873
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23874
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23875
                        //                            frmDisplay.setHidden(true);
23876
                        //                            frmForm.setHidden(true);
23877
                        //                            grdPanel.setHidden(false);
23878
                        //                            grdPanel.getStore().reload();
23879
                        //                        }
23880
                        //                    });
23881
                        //                }
23882
                        //            }
23883
                        //        ]
23884
                        //    }
23885
                        //]
23886
                        layoutType: rec.LayoutType //dikomen kalau mau test hilangkan items, bikin layout kacau                       
23887
                    })
23888
                }
23889
            })
23890
        }
23891
        Ext.applyIf(me, {
23892
            items: _items,
23893
            store: hasil
23894
        });
23895
        me.callParent(arguments);
23896
        this.bindStore(this.store, true);
23897
    },
23898

    
23899
    getStoreListeners: function () {
23900
        var me = this;
23901

    
23902
        return {
23903
            refresh: me.onDataRefresh,
23904
            /*replace: me.onReplace,
23905
            add: me.onAdd,
23906
            remove: me.onRemove,
23907
            update: me.onUpdate,
23908
            clear: me.onDataRefresh,
23909
            beginupdate: me.onBeginUpdate,
23910
            endupdate: me.onEndUpdate*/
23911
        };
23912
    },
23913

    
23914
    onBindStore: function (store) {
23915
        //this.onDataRefresh(store);
23916
    },
23917

    
23918
    onDataRefresh: function (store) {
23919
        var me = this,
23920
            titleField = me.getTitleField();
23921

    
23922
        store.each(function (record) {
23923
            var tab = me.getTabByRecord(record);
23924

    
23925
            if (!tab) {
23926
                me.add({
23927
                    title: record.get(titleField)
23928
                });
23929
            }
23930
        });
23931

    
23932
        if (!me.getActiveTab()) {
23933
            me.setActiveTab(0);
23934
        }
23935
    },
23936

    
23937
    getTabByRecord: function (record) {
23938
        var items = this.items,
23939
            tab;
23940

    
23941
        items.each(function (item) {
23942
            if (item.$record === record) {
23943
                tab = item;
23944

    
23945
                return false;
23946
            }
23947
        });
23948

    
23949
        return tab;
23950
    }
23951
});
23952

    
23953
Ext.define('MinovaUtil.MinovaES.MinovaTabListORMNew', {
23954
    extend: 'Ext.tab.Panel',
23955
    alias: ['widget.MinovaTabListORMNew'],
23956
    mixins: [
23957
        'Ext.util.StoreHolder'
23958
    ],
23959
    config: {
23960
        titleField: 'title'
23961
    },
23962
    id: 'mainTab',
23963
    //moduleType: undefined,
23964
    //tablenameheader: undefined,
23965
    //langId: undefined,
23966
    //param: undefined,
23967
    //frame: true,
23968
    //style: {
23969
    //    background: '#ffc'
23970
    //},
23971
    //cls: 'modern-tabpanel',
23972
    //bodyStyle: {
23973
    //    background: '#ffc',
23974
    //    padding: '10px'
23975
    //},
23976
    defaults: {
23977
        scrollable: true,
23978
        iconAlign: 'top',
23979
        userSelectable: {
23980
            bodyElement: true
23981
        }
23982
    },
23983
    tabBar: {
23984
        layout: { pack: 'center' }
23985
    },
23986
    initComponent: function () {
23987
        var me = this;
23988
        var hasil = null;
23989
        var _items = [];
23990
        Ext.applyIf(me, {
23991
            items: _items,
23992
            //store: hasil
23993
            store: Ext.create('Ext.data.Store', {
23994
                storeId: 'gridMenuMDOrm',
23995
                autoLoad: false,
23996
                proxy: {
23997
                    method: 'POST',
23998
                    type: 'ajax',
23999
                    //url: '../../extended/data/menu_md_orm.js',
24000
                    reader: {
24001
                        type: 'json',
24002
                        root: 'data'
24003
                    }
24004
                }
24005
            }),
24006
        });
24007
        me.callParent(arguments);
24008
        this.bindStore(this.store, true);
24009
    },
24010

    
24011
    //listeners: {
24012
    //    'viewready': function (grid) {
24013
    //        grid.getSelectionModel().select(0);
24014
    //        grid.fireEvent('rowClick', grid, 0);
24015
    //    }
24016
    //},
24017
    getStoreListeners: function () {
24018
        var me = this;
24019

    
24020
        return {
24021
            refresh: me.onDataRefresh,
24022
            /*replace: me.onReplace,
24023
            add: me.onAdd,
24024
            remove: me.onRemove,
24025
            update: me.onUpdate,
24026
            clear: me.onDataRefresh,
24027
            beginupdate: me.onBeginUpdate,
24028
            endupdate: me.onEndUpdate*/
24029
        };
24030
    },
24031

    
24032
    onBindStore: function (store) {
24033
        this.onDataRefresh(store);
24034
    },
24035

    
24036
    onDataRefresh: function (store) {
24037
        var me = this,
24038
            titleField = me.getTitleField();
24039
        me.removeAll();
24040
        store.each(function (record) {
24041
            var tab = me.getTabByRecord(record);
24042

    
24043
            if (!tab) {
24044
                me.add({
24045
                    iconCls: 'fa fa-address-book-o', //record.get('IconCls')
24046
                    title: record.get('LabelName'),
24047
                    name: 'panelTab' + record.get('TableName'),
24048
                    record: record, //dipanggil di mainNew1Controller.js
24049
                    tbl: record.get('TableName'),
24050
                    layoutType: record.get('LayoutType')
24051
                });
24052
            }
24053
        });
24054

    
24055
        if (!me.getActiveTab()) {
24056
            me.setActiveTab(0);
24057
        }
24058
    },
24059

    
24060
    getTabByRecord: function (record) {
24061
        var items = this.items,
24062
            tab;
24063

    
24064
        items.each(function (item) {
24065
            //if (item.$record === record) {
24066
            if (item.record === record) {
24067
                tab = item;
24068

    
24069
                return false;
24070
            }
24071
        });
24072

    
24073
        return tab;
24074
    }
24075
});
24076

    
24077
/* BEGIN YN 20211216 */
24078
/*NonEditableGrid ESS Generator YN 20211216 */
24079
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowNonEditableGrid', {
24080
    extend: 'Ext.form.Panel',
24081
    alias: ['widget.minovaworkflownoneditablegrid'],
24082
    requires: [
24083
        'Ext.grid.plugin.CellEditing',
24084
        'Ext.grid.RowNumberer',
24085
        'Ext.grid.Panel',
24086
    ],
24087
    cls: 'grid-ess',
24088
    anchor: '100%',
24089
    tableName: undefined,
24090
    tableNameT: undefined,
24091
    tableNameKey: undefined,
24092
    tableNameTKey: undefined,
24093
    hideButton: undefined,
24094
    multiSelect: undefined,
24095
    formname: this.name,
24096
    bizprocid: undefined,
24097
    bizflowid: undefined,
24098
    taskid: undefined,
24099
    features: undefined,
24100
    //height: 400,
24101
    minHeight: 20,
24102
    maxHeight: 500,
24103
    headerLayout: undefined,
24104
    summaryType: undefined,
24105
    labelText: undefined,
24106
    find: function (searchData, target, accum = []) {
24107
        target.forEach((f) => {
24108
            if (f.columns) {
24109
                //find(searchData, f.columns, accum)
24110
                //console.log(f.columns);
24111
                const newf = f.columns.map(o => {
24112
                    if (o.dataIndex == searchData.dataIndex) {
24113
                        searchData.menuDisabled = true;
24114
                        return searchData;
24115
                    } else {
24116
                        o.menuDisabled = true;
24117
                        return o
24118
                    }
24119
                });                
24120
                accum.push({
24121
                    header: f.header,
24122
                    //columns: {
24123
                    //    defaults: {
24124
                    //        menuDisabled: true
24125
                    //    },
24126
                    //    items: newf
24127
                    //}
24128
                    columns: newf
24129
                });
24130
            } else {
24131
                if (f.dataIndex.includes(searchData.dataIndex)) {
24132
                    accum.push(searchData);
24133
                }
24134
                else {
24135
                    accum.push(f);
24136
                }
24137
            }
24138
        })
24139
        return accum;
24140

    
24141
    },
24142
    initComponent: function () {
24143
        var me = this;
24144
        var isLookup = me.isLookup;
24145
        var hide_ = false;
24146
        var widthLock = 250;
24147
        var checkSelection = '';
24148
        if (me.hideButton == true) {
24149
            hide_ = true;
24150
        }
24151
        if (me.multiSelect) {
24152
            locking = false;
24153
            checkSelection = 'checkboxmodel';
24154
            widthLock = 40;
24155
        }
24156
        var tableName = me.tableName;
24157
        var features = me.features;
24158
        var cols = [];
24159
        var fieldStore = [];
24160
        var _url = 'GetAllField';
24161
        var hasil = null;
24162
        var height = me.height;
24163
        var storeID = 'store' + me.tableName;
24164
        var gridName = 'grid' + me.name;
24165
        if (me.storeName) {
24166
            storeID = me.storeName;
24167
        }
24168
        var LangID = MinovaUtil.GetLangID();
24169
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
24170
        Ext.Ajax.request({
24171
            async: false,
24172
            method: 'POST',
24173
            url: '/UserControl/GetStore',
24174
            params: {
24175
                tableName: 'PDSWFSTRUCTUREFIELD',
24176
                param: parameter
24177
            },
24178
            success: function (response) {
24179
                var results = Ext.decode(response.responseText);
24180
                hasil = results.data;
24181
            }
24182
        });
24183
        //cols.push({
24184
        //    xtype: 'rownumberer'
24185
        //});
24186
        var addData = 'var data={';
24187
        if (hasil.length > 0) {
24188
            Ext.each(hasil, function (rec) {
24189
                fieldStore.push(rec.FieldName);
24190
                if (rec.FieldName != 'Sequence') {
24191
                    addData = addData + rec.FieldName + ":" + "'',";
24192
                }
24193
                var null_ = null;
24194
                var ReadOnly_ = false;
24195
                if (rec.IsRequired == '1') {
24196
                    null_ = false;
24197
                } else {
24198
                    null_ = true;
24199
                }
24200
                var Hidden_ = false;
24201
                if (rec.IsReadOnly == '1') {
24202
                    ReadOnly_ = true;
24203
                }
24204
                if (rec.IsVisible == '1') {
24205
                    switch (rec.FormatRef) {
24206
                        case "date":
24207
                            cols.push({
24208
                                xtype: 'minovadatecolumn',
24209
                                hidden: Hidden_,
24210
                                text: rec.HeaderTitle,
24211
                                dataIndex: rec.FieldName,
24212
                                filter: {
24213
                                    itemDefaults: {
24214
                                        emptyText: 'Search for...',
24215
                                    }
24216
                                }
24217
                            });
24218
                            break
24219
                        case "amount":
24220
                            cols.push({
24221
                                xtype: 'minovacurrancycolumn',
24222
                                align: 'right',
24223
                                text: rec.HeaderTitle,
24224
                                dataIndex: rec.FieldName,
24225
                                hidden: Hidden_,
24226
                                filter: {
24227
                                    itemDefaults: {
24228
                                        emptyText: 'Search for...'
24229
                                    }
24230
                                }
24231
                            });
24232
                            break
24233
                        default:
24234
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
24235
                                cols.push({
24236
                                    text: rec.HeaderTitle,
24237
                                    dataIndex: rec.FieldName,
24238
                                    width: 100,
24239
                                    filter: {
24240
                                        type: 'string',
24241
                                        itemDefaults: {
24242
                                            emptyText: 'Search for...'
24243
                                        }
24244
                                    }
24245
                                });
24246
                            } else if (rec.SearchType == '0') {
24247
                                var valueField = null;
24248
                                var displayValue = null;
24249
                                var TableRef = undefined;
24250
                                if (rec.TableRef != '') {
24251
                                    TableRef = rec.TableRef;
24252
                                    Ext.Ajax.request({
24253
                                        async: false,
24254
                                        method: 'POST',
24255
                                        url: '/UserControl/GetStore',
24256
                                        params: {
24257
                                            tableName: 'SDATATABLEFIELD',
24258
                                            param: 'TableName[equal]' + rec.TableRef
24259
                                        },
24260
                                        success: function (response) {
24261
                                            var results = Ext.decode(response.responseText);
24262
                                            data_ = results.data;
24263
                                            if (data_ != undefined) {
24264
                                                valueField_ = $.grep(data_, function (r) {
24265
                                                    return r.ValueField == '1'
24266
                                                });
24267
                                                valueField = valueField_[0].FieldName
24268
                                                displayValue_ = $.grep(data_, function (r) {
24269
                                                    return r.DisplayValue == '1'
24270
                                                });
24271
                                                displayValue = displayValue_[0].FieldName
24272
                                            }
24273
                                        }
24274
                                    });
24275
                                }
24276
                                Ext.create('Ext.data.Store', {
24277
                                    storeId: 'store_' + me.tableName + rec.FieldName,
24278
                                    autoLoad: true,
24279
                                    proxy: {
24280
                                        method: 'POST',
24281
                                        type: 'ajax',
24282
                                        url: '/UserControl/GetStoreAuth',
24283
                                        extraParams: {
24284
                                            tableName: TableRef,
24285
                                            param: rec.ParamCombo,
24286
                                            menuId: MinovaUtil.GetMenuID()
24287
                                        },
24288
                                        reader: {
24289
                                            type: 'json',
24290
                                            root: 'data',
24291
                                            totalProperty: 'data[0].TotalCount'
24292
                                        }
24293
                                    }
24294
                                });
24295
                                cols.push({
24296
                                    //xtype : 'minovacombocolumn',
24297
                                    hidden: Hidden_,
24298
                                    text: rec.HeaderTitle,
24299
                                    dataIndex: rec.FieldName,
24300
                                    width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
24301
                                    summaryType: function (records) {
24302
                                        var suma = 0;
24303
                                        if (me.summaryType == 'average') {
24304
                                            // Sumar en la columna solo las lineas que estan marcadas para ser sumadas a los totales
24305
                                            Ext.each(records, function (record, index) {
24306
                                                if (record.get(rec.FieldName)) {
24307
                                                    suma = suma + parseFloat(record.get(rec.FieldName).replace(",", "."));
24308
                                                }
24309
                                            });
24310
                                            (records.length == 0) ? suma = 0 : suma = suma / records.length;
24311
                                        }
24312
                                        else if (me.summaryType == 'sum') {
24313
                                            // Sumar en la columna solo las lineas que estan marcadas para ser sumadas a los totales
24314
                                            Ext.each(records, function (record, index) {
24315
                                                if (record.get(rec.FieldName)) {
24316
                                                    suma = suma + parseFloat(record.get(rec.FieldName).replace(",", "."));
24317
                                                }
24318
                                            });
24319
                                        }
24320
                                        
24321
                                        return suma;
24322
                                    },
24323
                                    //valueField : valueField,
24324
                                    //displayField : displayValue,
24325
                                    //store : 'store_' + me.tableName + rec.FieldName,
24326
                                    //renderer: function (value) {
24327
                                    //    var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
24328
                                    //    var index = store.find(valueField, value);
24329
                                    //    var val = "";
24330
                                    //    if (index != -1) {
24331
                                    //        var rc = store.getAt(index);
24332
                                    //        val = rc.get(displayValue);
24333
                                    //    } else {
24334
                                    //        val = value;
24335
                                    //    }
24336
                                    //    return val;
24337
                                    //},
24338
                                    //filter: {
24339
                                    //    type: 'list',
24340
                                    //    itemDefaults: {
24341
                                    //        emptyText: 'Search for...'
24342
                                    //    }
24343
                                    //}
24344
                                });
24345
                            } else if (rec.SearchType == '5') {
24346
                                var valueField = null;
24347
                                var displayValue = null;
24348
                                var AdditionaldisplayValue = null;
24349
                                var TableRef = undefined;
24350
                                if (rec.TableRef != '') {
24351
                                    TableRef = rec.TableRef;
24352
                                    Ext.Ajax.request({
24353
                                        async: false,
24354
                                        method: 'POST',
24355
                                        url: '/UserControl/GetStore',
24356
                                        params: {
24357
                                            tableName: 'SDATATABLEFIELD',
24358
                                            param: 'TableName[equal]' + rec.TableRef
24359
                                        },
24360
                                        success: function (response) {
24361
                                            var results = Ext.decode(response.responseText);
24362
                                            data_ = results.data;
24363
                                            if (data_ != undefined) {
24364
                                                valueField_ = $.grep(data_, function (r) {
24365
                                                    return r.ValueField == '1'
24366
                                                });
24367
                                                if (valueField_.length > 0) {
24368
                                                    valueField = valueField_[0].FieldName
24369
                                                }
24370

    
24371
                                                displayValue_ = $.grep(data_, function (r) {
24372
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
24373
                                                });
24374
                                                if (displayValue_.length > 0) {
24375
                                                    displayValue = displayValue_[0].FieldName;
24376
                                                }
24377
                                                if (displayValue_.length >= 2) {
24378
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
24379
                                                }
24380
                                            }
24381
                                        }
24382
                                    });
24383
                                }
24384
                                Ext.create('Ext.data.Store', {
24385
                                    storeId: 'store_' + me.tableName + rec.FieldName,
24386
                                    autoLoad: true,
24387
                                    proxy: {
24388
                                        method: 'POST',
24389
                                        type: 'ajax',
24390
                                        url: '/UserControl/GetStoreAuth',
24391
                                        extraParams: {
24392
                                            tableName: TableRef,
24393
                                            param: rec.ParamCombo,
24394
                                            menuId: MinovaUtil.GetMenuID()
24395
                                        },
24396
                                        reader: {
24397
                                            type: 'json',
24398
                                            root: 'data',
24399
                                            totalProperty: 'data[0].TotalCount'
24400
                                        }
24401
                                    }
24402
                                });
24403
                                cols.push({
24404
                                    //xtype : 'minovacombocolumn',
24405
                                    hidden: Hidden_,
24406
                                    text: rec.HeaderTitle,
24407
                                    dataIndex: rec.FieldName,
24408
                                    //valueField : valueField,
24409
                                    //displayField : displayValue,
24410
                                    //store : 'store_' + me.tableName + rec.FieldName,
24411
                                    tpl: Ext.create('Ext.XTemplate',
24412
                                        '<ul class="x-list-plain"><tpl for=".">',
24413
                                        '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
24414
                                        '</tpl></ul>'),
24415
                                    displayTpl: Ext.create('Ext.XTemplate',
24416
                                        '<tpl for=".">',
24417
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
24418
                                        '</tpl>'),
24419
                                    renderer: function (value) {
24420
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
24421
                                        var index = store.find(valueField, value);
24422
                                        var val = "";
24423
                                        if (index != -1) {
24424
                                            var rc = store.getAt(index);
24425
                                            //val = rc.get(displayValue);
24426
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
24427
                                        } else {
24428
                                            val = value;
24429
                                        }
24430
                                        return val;
24431
                                    },
24432
                                    filter: {
24433
                                        type: 'list',
24434
                                        itemDefaults: {
24435
                                            emptyText: 'Search for...'
24436
                                        }
24437
                                    }
24438
                                });
24439
                            } else if (rec.SearchType == '2') {
24440
                                var triger = (rec.TriggerCombo).split('$');
24441
                                var targetField_ = triger[0];
24442
                                var fieldValue_ = triger[1];
24443
                                cols.push({
24444
                                    text: rec.HeaderTitle,
24445
                                    hidden: Hidden_,
24446
                                    dataIndex: rec.FieldName,
24447
                                    filter: {
24448
                                        itemDefaults: {
24449
                                            emptyText: 'Search for...'
24450
                                        }
24451
                                    }
24452
                                });
24453
                            } else if (rec.SearchType == '3') {
24454
                                cols.push({
24455
                                    text: rec.HeaderTitle,
24456
                                    hidden: Hidden_,
24457
                                    dataIndex: rec.FieldName,
24458
                                    filter: {
24459
                                        itemDefaults: {
24460
                                            emptyText: 'Search for...'
24461
                                        }
24462
                                    }
24463
                                });
24464
                            } 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) {
24465
                                var triger = (rec.TriggerCombo).split('&');
24466
                                var targetField_ = triger[0];
24467
                                var fieldValue_ = triger[0];
24468
                                cols.push({
24469
                                    text: rec.HeaderTitle,
24470
                                    hidden: Hidden_,
24471
                                    dataIndex: rec.FieldName,
24472
                                    filter: {
24473
                                        itemDefaults: {
24474
                                            emptyText: 'Search for...'
24475
                                        }
24476
                                    }
24477
                                });
24478
                            } else if (rec.SearchType == '4' && isLookup != true) {
24479
                                cols.push({
24480
                                    text: rec.HeaderTitle,
24481
                                    hidden: Hidden_,
24482
                                    dataIndex: rec.FieldName,
24483
                                    filter: {
24484
                                        itemDefaults: {
24485
                                            emptyText: 'Search for...'
24486
                                        }
24487
                                    }
24488
                                });
24489
                            } else if (rec.FixedValue != '') { // add by taufan
24490
                                cols.push({
24491
                                    text: rec.HeaderTitle,
24492
                                    hidden: Hidden_,
24493
                                    dataIndex: rec.FieldName,
24494
                                    filter: {
24495
                                        itemDefaults: {
24496
                                            emptyText: 'Search for...'
24497
                                        }
24498
                                    },
24499
                                    renderer: function (value) {
24500
                                        var val = "";
24501
                                        var storeData = [];
24502
                                        var str = rec.FixedValue;
24503
                                        var hasil = str.split('||');
24504
                                        hasil.forEach(function (h) {
24505
                                            store_ = h.split('=')
24506
                                            storeData.push({
24507
                                                code: store_[0],
24508
                                                desc: store_[1]
24509
                                            });
24510
                                        });
24511
                                        var item = storeData.find(x => x.code == value);
24512
                                        if (item != undefined) {
24513
                                            val = item.desc;
24514
                                        }
24515
                                        return val;
24516
                                    }
24517
                                });
24518
                            } else {
24519
                                _xtype = 'textfield';
24520
                                if (rec.Length > 250) {
24521
                                    _xtype = 'textareafield';
24522
                                }
24523
                                var _custumFunc = null;
24524
                                Ext.Ajax.request({
24525
                                    async: false,
24526
                                    method: 'POST',
24527
                                    url: '/UserControl/GetStore',
24528
                                    params: {
24529
                                        tableName: 'SDATATABLEFIELD',
24530
                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
24531
                                    },
24532
                                    success: function (response) {
24533
                                        var results = Ext.decode(response.responseText);
24534
                                        data_ = results.data[0];
24535
                                        if (data_ != undefined) {
24536
                                            _custumFunc = data_.SelectFunction;
24537
                                        }
24538
                                    }
24539
                                });
24540
                                cols.push({
24541
                                    text: rec.HeaderTitle,
24542
                                    xtype: 'gridcolumn',
24543
                                    hidden: Hidden_,
24544
                                    dataIndex: rec.FieldName,
24545
                                    filter: {
24546
                                        itemDefaults: {
24547
                                            emptyText: 'Search for...'
24548
                                        }
24549
                                    },
24550
                                    cellWrap: true,
24551
                                    //autoSizeColumn: true,
24552
                                    width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
24553
                                    flex: (rec.Length == 'EISelfComent') ? 1 : 0,
24554
                                    renderer: function (v) {
24555
                                        result = v.replace(/\r\n\r\n/g, "</p><p>").replace(/\n\n/g, "</p><p>");
24556
                                        result = result.replace(/\r\n/g, "<br />").replace(/\n/g, "<br />");
24557
                                        return result
24558
                                    }
24559
                                });
24560
                            }
24561
                            break
24562
                    }
24563
                } else {
24564
                    cols.push({
24565
                        text: rec.HeaderTitle,
24566
                        hidden: Hidden_,
24567
                        dataIndex: rec.FieldName,
24568
                        hidden: true,
24569
                        filter: {
24570
                            itemDefaults: {
24571
                                emptyText: 'Search for...'
24572
                            }
24573
                        }
24574
                    });
24575
                }
24576
            });
24577

    
24578
        };
24579
        //Sesuaikan Header Layout
24580
        var col = me.headerLayout;
24581
        if (me.headerLayout != undefined) {
24582
            cols.forEach((f) => {
24583
                col = me.find(f, col);
24584
            })
24585
            cols = col;
24586
        }
24587
        addData = addData + "}";
24588
        Ext.applyIf(me, {            
24589
            items: [{
24590
                xtype: 'grid',
24591
                id: gridName,
24592
                name: gridName,
24593
                tableName: me.tableName,
24594
                tableNameT: me.tableNameT,
24595
                tableNameKey: me.tableNameKey,
24596
                tableNameTKey: me.tableNameTKey,
24597
                minHeight: me.minHeight,
24598
                maxHeight: me.maxHeight,
24599
                //height: me.height,                
24600
                //scrollable: true,
24601
                //flex: 1,
24602
                addFlag: true,
24603
                deleteFlag: true,
24604
                store: Ext.create('Ext.data.Store', {
24605
                    storeId: storeID,
24606
                    fields: fieldStore,
24607
                    //groupField: 'QuestionGroup',
24608
                    grouper: {
24609
                        sortProperty: 'SeqQuest',
24610
                        groupFn: function (record) {
24611
                            return record.get('QuestionGroup');
24612
                        }
24613
                    },
24614
                    proxy: {
24615
                        method: 'POST',
24616
                        type: 'ajax',
24617
                        url: '',
24618
                        reader: {
24619
                            type: 'json',
24620
                            root: 'data'
24621
                        }
24622
                    }
24623
                }),
24624
                dockedItems: [{
24625
                    xtype: 'toolbar',
24626
                    dock: 'bottom',
24627
                    items: [
24628
                        {
24629
                            xtype: 'label',
24630
                            html: me.labelText,
24631
                            margin: '0 0 10 0'
24632
                        },
24633
                        {
24634
                            text: 'Add',
24635
                            hidden: hide_,
24636
                            name: tableName + 'Add',
24637
                            iconCls: 'fa-plus-circle',
24638
                            style: 'font-family: FontAwesome',
24639
                            handler: function () {
24640
                                var grid = Ext.getCmp(gridName);
24641
                                if (grid.addFlag === true) {
24642
                                    var store = Ext.StoreMgr.lookup(storeID)
24643
                                    idx = store.getCount();
24644
                                    var action = getParam('action');
24645
                                    var data = '';
24646
                                    var Sequence = 0;
24647
                                    if (idx == 0) {
24648
                                        Sequence = 1;
24649
                                    } else {
24650
                                        Sequence = 1 + idx;
24651
                                    }
24652
                                    var seq = 'Sequence';
24653
                                    var SequenceValue = Sequence;
24654
                                    eval(addData);
24655
                                    data[seq] = SequenceValue;
24656
                                    store.insert(idx, data);
24657
                                }
24658
                            }
24659
                        },
24660
                        {
24661
                            text: 'Delete',
24662
                            hidden: hide_,
24663
                            name: tableName + 'DeleteText',
24664
                            iconCls: 'fa-trash-o',
24665
                            style: 'font-family: FontAwesome',
24666
                            handler: function () {
24667
                                var grid = Ext.getCmp(gridName);
24668
                                if (grid.deleteFlag === true) {
24669
                                    var me = this,
24670
                                        store = Ext.StoreMgr.lookup(storeID)
24671
                                    var grid = Ext.getCmp(gridName);
24672
                                    Ext.MessageBox.show({
24673
                                        title: 'Remove tab',
24674
                                        msg: "This will remove. Do you want to continue?",
24675
                                        buttons: Ext.MessageBox.YESNO,
24676
                                        fn: function (choice) {
24677
                                            console.log(choice);
24678
                                            if (choice === 'yes') {
24679
                                                var selection = grid.getView().getSelectionModel().getSelection()[0];
24680
                                                if (selection) {
24681
                                                    store.remove(selection);
24682
                                                }
24683
                                            }
24684
                                        }
24685
                                    });
24686
                                }
24687
                            }
24688
                        },
24689
                        {
24690
                            text: 'Edit',
24691
                            hidden: hide_,
24692
                            name: tableName + 'EditText',
24693
                            bizprocid: me.bizprocid,
24694
                            taskid: me.taskid,
24695
                            TableName: tableName,
24696
                            iconCls: 'fa-edit',
24697
                            style: 'font-family: FontAwesome',
24698
                            handler: function () {
24699
                                ////var frmDisplay = Ext.ComponentQuery.query('[name=display' + me.name + ']')[0];
24700
                                //var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24701
                                //var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24702
                                //var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24703
                                //if (frmForm == undefined) {
24704
                                //    frmForm = Ext.create('MinovaUtil.MinovaES.MinovaWorkflowFormGrid', {
24705
                                //        bizprocid: this.bizprocid,
24706
                                //        taskid: this.taskid,
24707
                                //        name: 'form' + this.TableName,
24708
                                //        tableName: this.TableName,
24709
                                //    });
24710
                                //}
24711
                                ////frmForm.reset();
24712
                                ////frmForm.down('form').getForm().loadRecord(dtrec.data);
24713
                                //frmForm.show();
24714

    
24715
                                var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24716
                                var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24717
                                var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24718
                                if (dtrec) {
24719
                                    //frmDisplay.reset();
24720
                                    frmForm.reset();
24721
                                    frmForm.getForm().setValues(dtrec.data);
24722
                                    //frmDisplay.setHidden(true);
24723
                                    frmForm.setHidden(false);
24724
                                    //grdPanel.setHidden(true);
24725
                                    me.action = "1";
24726
                                }
24727

    
24728
                                //var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24729
                                //var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24730
                                //if (dtrec) {
24731
                                //    var pnlT = Ext.ComponentQuery.query('[name=panel' + me.tableNameT + ']')[0];
24732
                                //    var grdPanelT = Ext.ComponentQuery.query('[name=grid' + me.tableNameT + ']')[0];
24733
                                //    var dtrecT = grdPanelT.getStore().filter(me.tableNameTKey, dtrec.data[me.tableNameKey]);
24734
                                //    pnlT.setHidden(false);                                   
24735
                                //}
24736
                            }
24737
                        }
24738
                    ]
24739
                }
24740
                ],
24741
                columns: {
24742
                    defaults: {
24743
                        menuDisabled: true
24744
                    },
24745
                    items: cols
24746
                },
24747
                //selType: checkSelection,
24748
                //plugins: {
24749
                //    ptype: 'actionColumnRowEditing', //rowediting
24750
                //    pluginId: 'rowEditing',
24751
                //    hiddenColumnsOnEdit: ['startEditActionColumn'],
24752
                //    clicksToEdit: 2,
24753
                //    saveButtonIconCls: 'x-fa fa-floppy-o',
24754
                //    listeners: {}
24755
                //},
24756
                listeners: {
24757
                    //'beforeedit': function (editor) {
24758
                    //    editor.getEditor().floatingButtons.items.items[0].hide();
24759
                    //    editor.getEditor().floatingButtons.items.items[1].hide();
24760
                    //}
24761
                    'itemdblclick': function (this_, record, item, index, e, eOpts) {
24762
                        var me = this;
24763
                        var frmForm = Ext.ComponentQuery.query('[name=form' + me.tableName + ']')[0];
24764
                        var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.tableName + ']')[0];
24765
                        var dtrec = record;
24766
                        if (dtrec) {
24767
                            //frmDisplay.reset();
24768
                            //frmForm.reset();
24769
                            frmForm.getForm().setValues(dtrec.data);
24770
                            //grdPanel.setHeight(0);
24771
                            //frmDisplay.setHidden(true);
24772
                            frmForm.setHidden(false);
24773
                            //grdPanel.setHidden(true);
24774

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

    
24781
                            me.action = "1";
24782
                        }
24783
                    },
24784
                    'itemclickx': function (this_, record, item, index, e, eOpts) {
24785
                        var me = this;
24786
                        var frmForm = Ext.ComponentQuery.query('[name=form' + me.tableName + ']')[0];
24787
                        frmForm.setHidden(true);
24788
                        ////var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.tablename + ']')[0];
24789
                        //var dtrec = record;
24790
                        //if (dtrec) {
24791
                        //    //frmDisplay.reset();
24792
                        //    //frmForm.reset();
24793
                        //    frmForm.getForm().setValues(dtrec.data);
24794
                        //    //grdPanel.setHeight(0);
24795
                        //    //frmDisplay.setHidden(true);
24796
                        //    frmForm.setHidden(false);
24797
                        //    //grdPanel.setHidden(true);
24798
                        //    action = "1";
24799
                        //}
24800
                        var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.tableName + ']')[0];
24801
                        var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24802
                        if (dtrec) {
24803
                            var pnlT = Ext.ComponentQuery.query('[name=panel' + me.tableNameT + ']')[0];
24804
                            var grdPanelT = Ext.ComponentQuery.query('[name=grid' + me.tableNameT + ']')[0];
24805
                            var dtrecT = grdPanelT.getStore().filter(me.tableNameTKey, dtrec.data[me.tableNameKey]);
24806
                            pnlT.setTitle('<div style=\"font-size:14px; font-weight: bold;\">Goal ' + dtrec.data[me.tableNameKey] + '-Tasks</div>');
24807
                            pnlT.setHidden(false);
24808
                        }
24809
                    }
24810
                },
24811
                features: features,
24812
                viewConfig: {
24813
                    listeners: {
24814
                        refresh: function (dataview) {
24815
                            Ext.each(dataview.panel.columns, function (column) {
24816
                                //column.autoSize();
24817
                            })
24818
                        }
24819
                    }
24820
                }
24821
            }
24822
            ]
24823
        });
24824
        me.callParent(arguments);  
24825
    },
24826
    listeners: {
24827
        boxready: function (dataview) {
24828
            var grd = Ext.ComponentQuery.query('[name=grid' + this.tableName + ']')[0];
24829
            grd.reconfigure(); //YN 20211217 - Solusi Layout rapih
24830
        }
24831
    }
24832
});
24833

    
24834
/*NonEditableGridT ESS Generator YN 20211216 */
24835
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowNonEditableGridT', {
24836
    extend: 'Ext.form.Panel',
24837
    alias: ['widget.minovaworkflownoneditablegridT'],
24838
    requires: [
24839
        'Ext.grid.plugin.CellEditing',
24840
        'Ext.grid.RowNumberer',
24841
        'Ext.grid.Panel',
24842
    ],
24843
    anchor: '100%',
24844
    tableName: undefined,
24845
    tableNameP: undefined,
24846
    tableNameKey: undefined,
24847
    tableNameFKey: undefined,
24848
    tableNamePKey: undefined,
24849
    parentKey: undefined,
24850
    hideButton: undefined,
24851
    multiSelect: undefined,
24852
    formname: this.name,
24853
    bizprocid: undefined,
24854
    bizflowid: undefined,
24855
    taskid: undefined,
24856
    features: undefined,
24857
    height: 400,
24858
    minHeight: 20,
24859
    maxHeight: 400,
24860
    initComponent: function () {
24861
        var me = this;
24862
        var isLookup = me.isLookup;
24863
        var hide_ = false;
24864
        var widthLock = 250;
24865
        var checkSelection = '';
24866
        if (me.hideButton == true) {
24867
            hide_ = true;
24868
        }
24869
        if (me.multiSelect) {
24870
            locking = false;
24871
            checkSelection = 'checkboxmodel';
24872
            widthLock = 40;
24873
        }
24874
        var tableName = me.tableName;
24875
        var features = me.features;
24876
        var cols = [];
24877
        var fieldStore = [];
24878
        var _url = 'GetAllField';
24879
        var hasil = null;
24880
        var height = me.height;
24881
        var storeID = 'store' + me.tableName + '_' + me.parentKey;
24882
        var gridName = 'grid' + me.name;
24883
        if (me.storeName) {
24884
            storeID = me.storeName;
24885
        }
24886
        var LangID = MinovaUtil.GetLangID();
24887
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
24888
        Ext.Ajax.request({
24889
            async: false,
24890
            method: 'POST',
24891
            url: '/UserControl/GetStore',
24892
            params: {
24893
                tableName: 'PDSWFSTRUCTUREFIELD',
24894
                param: parameter
24895
            },
24896
            success: function (response) {
24897
                var results = Ext.decode(response.responseText);
24898
                hasil = results.data;
24899
            }
24900
        });
24901
        //cols.push({
24902
        //    xtype: 'rownumberer'
24903
        //});
24904
        var addData = 'var data={';
24905
        if (hasil.length > 0) {
24906
            Ext.each(hasil, function (rec) {
24907
                fieldStore.push(rec.FieldName);
24908
                if (rec.FieldName != 'Sequence') {
24909
                    addData = addData + rec.FieldName + ":" + "'',";
24910
                }
24911
                var null_ = null;
24912
                var ReadOnly_ = false;
24913
                if (rec.IsRequired == '1') {
24914
                    null_ = false;
24915
                } else {
24916
                    null_ = true;
24917
                }
24918
                var Hidden_ = false;
24919
                if (rec.IsReadOnly == '1') {
24920
                    ReadOnly_ = true;
24921
                }
24922
                if (rec.IsVisible == '1') {
24923
                    switch (rec.FormatRef) {
24924
                        case "date":
24925
                            cols.push({
24926
                                xtype: 'minovadatecolumn',
24927
                                hidden: Hidden_,
24928
                                text: rec.HeaderTitle,
24929
                                dataIndex: rec.FieldName,
24930
                                filter: {
24931
                                    itemDefaults: {
24932
                                        emptyText: 'Search for...',
24933
                                    }
24934
                                }
24935
                            });
24936
                            break
24937
                        case "amount":
24938
                            cols.push({
24939
                                xtype: 'minovacurrancycolumn',
24940
                                align: 'right',
24941
                                text: rec.HeaderTitle,
24942
                                dataIndex: rec.FieldName,
24943
                                hidden: Hidden_,
24944
                                filter: {
24945
                                    itemDefaults: {
24946
                                        emptyText: 'Search for...'
24947
                                    }
24948
                                }
24949
                            });
24950
                            break
24951
                        default:
24952
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
24953
                                cols.push({
24954
                                    text: rec.HeaderTitle,
24955
                                    dataIndex: rec.FieldName,
24956
                                    width: 100,
24957
                                    filter: {
24958
                                        type: 'string',
24959
                                        itemDefaults: {
24960
                                            emptyText: 'Search for...'
24961
                                        }
24962
                                    }
24963
                                });
24964
                            } else if (rec.SearchType == '0') {
24965
                                var valueField = null;
24966
                                var displayValue = null;
24967
                                var TableRef = undefined;
24968
                                if (rec.TableRef != '') {
24969
                                    TableRef = rec.TableRef;
24970
                                    Ext.Ajax.request({
24971
                                        async: false,
24972
                                        method: 'POST',
24973
                                        url: '/UserControl/GetStore',
24974
                                        params: {
24975
                                            tableName: 'SDATATABLEFIELD',
24976
                                            param: 'TableName[equal]' + rec.TableRef
24977
                                        },
24978
                                        success: function (response) {
24979
                                            var results = Ext.decode(response.responseText);
24980
                                            data_ = results.data;
24981
                                            if (data_ != undefined) {
24982
                                                valueField_ = $.grep(data_, function (r) {
24983
                                                    return r.ValueField == '1'
24984
                                                });
24985
                                                valueField = valueField_[0].FieldName
24986
                                                displayValue_ = $.grep(data_, function (r) {
24987
                                                    return r.DisplayValue == '1'
24988
                                                });
24989
                                                displayValue = displayValue_[0].FieldName
24990
                                            }
24991
                                        }
24992
                                    });
24993
                                }
24994
                                Ext.create('Ext.data.Store', {
24995
                                    storeId: 'store_' + me.tableName + rec.FieldName,
24996
                                    autoLoad: true,
24997
                                    proxy: {
24998
                                        method: 'POST',
24999
                                        type: 'ajax',
25000
                                        url: '/UserControl/GetStoreAuth',
25001
                                        extraParams: {
25002
                                            tableName: TableRef,
25003
                                            param: rec.ParamCombo,
25004
                                            menuId: MinovaUtil.GetMenuID()
25005
                                        },
25006
                                        reader: {
25007
                                            type: 'json',
25008
                                            root: 'data',
25009
                                            totalProperty: 'data[0].TotalCount'
25010
                                        }
25011
                                    }
25012
                                });
25013
                                cols.push({
25014
                                    //xtype : 'minovacombocolumn',
25015
                                    hidden: Hidden_,
25016
                                    text: rec.HeaderTitle,
25017
                                    dataIndex: rec.FieldName,
25018
                                    width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
25019
                                    //valueField : valueField,
25020
                                    //displayField : displayValue,
25021
                                    //store : 'store_' + me.tableName + rec.FieldName,
25022
                                    renderer: function (value) {
25023
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
25024
                                        var index = store.find(valueField, value);
25025
                                        var val = "";
25026
                                        if (index != -1) {
25027
                                            var rc = store.getAt(index);
25028
                                            val = rc.get(displayValue);
25029
                                        } else {
25030
                                            val = value;
25031
                                        }
25032
                                        return val;
25033
                                    },
25034
                                    filter: {
25035
                                        type: 'list',
25036
                                        itemDefaults: {
25037
                                            emptyText: 'Search for...'
25038
                                        }
25039
                                    }
25040
                                });
25041
                            } else if (rec.SearchType == '5') {
25042
                                var valueField = null;
25043
                                var displayValue = null;
25044
                                var AdditionaldisplayValue = null;
25045
                                var TableRef = undefined;
25046
                                if (rec.TableRef != '') {
25047
                                    TableRef = rec.TableRef;
25048
                                    Ext.Ajax.request({
25049
                                        async: false,
25050
                                        method: 'POST',
25051
                                        url: '/UserControl/GetStore',
25052
                                        params: {
25053
                                            tableName: 'SDATATABLEFIELD',
25054
                                            param: 'TableName[equal]' + rec.TableRef
25055
                                        },
25056
                                        success: function (response) {
25057
                                            var results = Ext.decode(response.responseText);
25058
                                            data_ = results.data;
25059
                                            if (data_ != undefined) {
25060
                                                valueField_ = $.grep(data_, function (r) {
25061
                                                    return r.ValueField == '1'
25062
                                                });
25063
                                                if (valueField_.length > 0) {
25064
                                                    valueField = valueField_[0].FieldName
25065
                                                }
25066

    
25067
                                                displayValue_ = $.grep(data_, function (r) {
25068
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
25069
                                                });
25070
                                                if (displayValue_.length > 0) {
25071
                                                    displayValue = displayValue_[0].FieldName;
25072
                                                }
25073
                                                if (displayValue_.length >= 2) {
25074
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
25075
                                                }
25076
                                            }
25077
                                        }
25078
                                    });
25079
                                }
25080
                                Ext.create('Ext.data.Store', {
25081
                                    storeId: 'store_' + me.tableName + rec.FieldName,
25082
                                    autoLoad: true,
25083
                                    proxy: {
25084
                                        method: 'POST',
25085
                                        type: 'ajax',
25086
                                        url: '/UserControl/GetStoreAuth',
25087
                                        extraParams: {
25088
                                            tableName: TableRef,
25089
                                            param: rec.ParamCombo,
25090
                                            menuId: MinovaUtil.GetMenuID()
25091
                                        },
25092
                                        reader: {
25093
                                            type: 'json',
25094
                                            root: 'data',
25095
                                            totalProperty: 'data[0].TotalCount'
25096
                                        }
25097
                                    }
25098
                                });
25099
                                cols.push({
25100
                                    //xtype : 'minovacombocolumn',
25101
                                    hidden: Hidden_,
25102
                                    text: rec.HeaderTitle,
25103
                                    dataIndex: rec.FieldName,
25104
                                    //valueField : valueField,
25105
                                    //displayField : displayValue,
25106
                                    //store : 'store_' + me.tableName + rec.FieldName,
25107
                                    tpl: Ext.create('Ext.XTemplate',
25108
                                        '<ul class="x-list-plain"><tpl for=".">',
25109
                                        '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
25110
                                        '</tpl></ul>'),
25111
                                    displayTpl: Ext.create('Ext.XTemplate',
25112
                                        '<tpl for=".">',
25113
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
25114
                                        '</tpl>'),
25115
                                    renderer: function (value) {
25116
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
25117
                                        var index = store.find(valueField, value);
25118
                                        var val = "";
25119
                                        if (index != -1) {
25120
                                            var rc = store.getAt(index);
25121
                                            //val = rc.get(displayValue);
25122
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
25123
                                        } else {
25124
                                            val = value;
25125
                                        }
25126
                                        return val;
25127
                                    },
25128
                                    filter: {
25129
                                        type: 'list',
25130
                                        itemDefaults: {
25131
                                            emptyText: 'Search for...'
25132
                                        }
25133
                                    }
25134
                                });
25135
                            } else if (rec.SearchType == '2') {
25136
                                var triger = (rec.TriggerCombo).split('$');
25137
                                var targetField_ = triger[0];
25138
                                var fieldValue_ = triger[1];
25139
                                cols.push({
25140
                                    text: rec.HeaderTitle,
25141
                                    hidden: Hidden_,
25142
                                    dataIndex: rec.FieldName,
25143
                                    filter: {
25144
                                        itemDefaults: {
25145
                                            emptyText: 'Search for...'
25146
                                        }
25147
                                    }
25148
                                });
25149
                            } else if (rec.SearchType == '3') {
25150
                                cols.push({
25151
                                    text: rec.HeaderTitle,
25152
                                    hidden: Hidden_,
25153
                                    dataIndex: rec.FieldName,
25154
                                    filter: {
25155
                                        itemDefaults: {
25156
                                            emptyText: 'Search for...'
25157
                                        }
25158
                                    }
25159
                                });
25160
                            } 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) {
25161
                                var triger = (rec.TriggerCombo).split('&');
25162
                                var targetField_ = triger[0];
25163
                                var fieldValue_ = triger[0];
25164
                                cols.push({
25165
                                    text: rec.HeaderTitle,
25166
                                    hidden: Hidden_,
25167
                                    dataIndex: rec.FieldName,
25168
                                    filter: {
25169
                                        itemDefaults: {
25170
                                            emptyText: 'Search for...'
25171
                                        }
25172
                                    }
25173
                                });
25174
                            } else if (rec.SearchType == '4' && isLookup != true) {
25175
                                cols.push({
25176
                                    text: rec.HeaderTitle,
25177
                                    hidden: Hidden_,
25178
                                    dataIndex: rec.FieldName,
25179
                                    filter: {
25180
                                        itemDefaults: {
25181
                                            emptyText: 'Search for...'
25182
                                        }
25183
                                    }
25184
                                });
25185
                            } else if (rec.FixedValue != '') { // add by taufan
25186
                                cols.push({
25187
                                    text: rec.HeaderTitle,
25188
                                    hidden: Hidden_,
25189
                                    dataIndex: rec.FieldName,
25190
                                    filter: {
25191
                                        itemDefaults: {
25192
                                            emptyText: 'Search for...'
25193
                                        }
25194
                                    },
25195
                                    renderer: function (value) {
25196
                                        var val = "";
25197
                                        var storeData = [];
25198
                                        var str = rec.FixedValue;
25199
                                        var hasil = str.split('||');
25200
                                        hasil.forEach(function (h) {
25201
                                            store_ = h.split('=')
25202
                                            storeData.push({
25203
                                                code: store_[0],
25204
                                                desc: store_[1]
25205
                                            });
25206
                                        });
25207
                                        var item = storeData.find(x => x.code == value);
25208
                                        if (item != undefined) {
25209
                                            val = item.desc;
25210
                                        }
25211
                                        return val;
25212
                                    }
25213
                                });
25214
                            } else {
25215
                                _xtype = 'textfield';
25216
                                if (rec.Length > 250) {
25217
                                    _xtype = 'textareafield';
25218
                                }
25219
                                var _custumFunc = null;
25220
                                Ext.Ajax.request({
25221
                                    async: false,
25222
                                    method: 'POST',
25223
                                    url: '/UserControl/GetStore',
25224
                                    params: {
25225
                                        tableName: 'SDATATABLEFIELD',
25226
                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
25227
                                    },
25228
                                    success: function (response) {
25229
                                        var results = Ext.decode(response.responseText);
25230
                                        data_ = results.data[0];
25231
                                        if (data_ != undefined) {
25232
                                            _custumFunc = data_.SelectFunction;
25233
                                        }
25234
                                    }
25235
                                });
25236
                                cols.push({
25237
                                    text: rec.HeaderTitle,
25238
                                    xtype: 'gridcolumn',
25239
                                    hidden: Hidden_,
25240
                                    dataIndex: rec.FieldName,
25241
                                    filter: {
25242
                                        itemDefaults: {
25243
                                            emptyText: 'Search for...'
25244
                                        }
25245
                                    },
25246
                                    cellWrap: true,
25247
                                    width: (rec.Length * 8) > 400 ? 400 : rec.Length * 8,
25248
                                    renderer: function (v) {
25249
                                        result = v.replace(/\r\n\r\n/g, "</p><p>").replace(/\n\n/g, "</p><p>");
25250
                                        result = result.replace(/\r\n/g, "<br />").replace(/\n/g, "<br />");
25251
                                        return result
25252
                                    }
25253
                                });
25254
                            }
25255
                            break
25256
                    }
25257
                } else {
25258
                    cols.push({
25259
                        text: rec.HeaderTitle,
25260
                        hidden: Hidden_,
25261
                        dataIndex: rec.FieldName,
25262
                        hidden: true,
25263
                        filter: {
25264
                            itemDefaults: {
25265
                                emptyText: 'Search for...'
25266
                            }
25267
                        }
25268
                    });
25269
                }
25270
            });
25271

    
25272
        };
25273

    
25274
        addData = addData + "}";
25275
        Ext.applyIf(me, {
25276
            items: [{
25277
                xtype: 'grid',
25278
                id: gridName,
25279
                name: gridName,
25280
                tablename: me.tableName,
25281
                minHeight: me.minHeight,
25282
                maxHeight: me.maxHeight,
25283
                addFlag: true,
25284
                deleteFlag: true,
25285
                store: Ext.create('Ext.data.Store', {
25286
                    storeId: storeID,
25287
                    fields: fieldStore,
25288
                    //groupField: 'QuestionGroup',
25289
                    grouper: {
25290
                        sortProperty: 'SeqQuest',
25291
                        groupFn: function (record) {
25292
                            return record.get('QuestionGroup');
25293
                        }
25294
                    },
25295
                    proxy: {
25296
                        method: 'POST',
25297
                        type: 'ajax',
25298
                        url: '',
25299
                        reader: {
25300
                            type: 'json',
25301
                            root: 'data'
25302
                        }
25303
                    }
25304
                }),
25305
                dockedItems: [{
25306
                    xtype: 'toolbar',
25307
                    items: [
25308
                        {
25309
                            text: 'Add',
25310
                            hidden: hide_,
25311
                            name: tableName + 'Add',
25312
                            iconCls: 'fa-plus-circle',
25313
                            style: 'font-family: FontAwesome',
25314
                            handler: function () {
25315
                                var grid = Ext.getCmp(gridName);
25316
                                if (grid.addFlag === true) {
25317
                                    var store = Ext.StoreMgr.lookup(storeID)
25318
                                    idx = store.getCount();
25319
                                    var action = getParam('action');
25320
                                    var data = '';
25321
                                    var Sequence = 0;
25322
                                    if (idx == 0) {
25323
                                        Sequence = 1;
25324
                                    } else {
25325
                                        Sequence = 1 + idx;
25326
                                    }
25327
                                    var seq = 'Sequence';
25328
                                    var SequenceValue = Sequence;
25329
                                    eval(addData);
25330
                                    var grdParent = Ext.ComponentQuery.query('[name=grid' + me.tableNameP + ']')[0];
25331
                                    var dtParent = grdParent.getView().getSelectionModel().getSelection()[0];
25332
                                    if (dtParent == undefined) {
25333
                                        grdParent.getView().getSelectionModel().select(0);
25334
                                        dtParent = grdParent.getView().getSelectionModel().getSelection()[0];
25335
                                    }
25336
                                    data[seq] = SequenceValue;
25337
                                    data[me.tableNameFKey] = dtParent.data[me.tableNamePKey];
25338
                                    data[me.tableNameKey] = SequenceValue.toString();
25339
                                    store.insert(idx, data);
25340
                                    grid.getView().getSelectionModel().select(idx);
25341
                                    var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
25342
                                    frmForm.reset();
25343
                                    frmForm.getForm().setValues(data);
25344
                                    //frmDisplay.setHidden(true);
25345
                                    frmForm.setHidden(false);
25346
                                }
25347
                            }
25348
                        },
25349
                        {
25350
                            text: 'Delete',
25351
                            hidden: hide_,
25352
                            name: tableName + 'DeleteText',
25353
                            iconCls: 'fa-trash-o',
25354
                            style: 'font-family: FontAwesome',
25355
                            handler: function () {
25356
                                var grid = Ext.getCmp(gridName);
25357
                                if (grid.deleteFlag === true) {
25358
                                    //var me = this,
25359
                                    store = Ext.StoreMgr.lookup(storeID)
25360
                                    var grid = Ext.getCmp(gridName);
25361
                                    Ext.MessageBox.show({
25362
                                        title: 'Remove tab',
25363
                                        msg: "This will remove. Do you want to continue?",
25364
                                        buttons: Ext.MessageBox.YESNO,
25365
                                        fn: function (choice) {
25366
                                            console.log(choice);
25367
                                            if (choice === 'yes') {
25368
                                                var selection = grid.getView().getSelectionModel().getSelection()[0];
25369
                                                if (selection) {
25370
                                                    store.remove(selection);
25371
                                                    var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
25372
                                                    frmForm.reset();
25373
                                                    //frmDisplay.setHidden(true);
25374
                                                    frmForm.setHidden(true);
25375
                                                }
25376
                                            }
25377
                                        }
25378
                                    });
25379
                                }
25380
                            }
25381
                        },
25382
                        {
25383
                            text: 'Edit',
25384
                            hidden: hide_,
25385
                            name: tableName + 'EditText',
25386
                            bizprocid: me.bizprocid,
25387
                            taskid: me.taskid,
25388
                            TableName: tableName,
25389
                            iconCls: 'fa-edit',
25390
                            style: 'font-family: FontAwesome',
25391
                            handler: function () {
25392
                                ////var frmDisplay = Ext.ComponentQuery.query('[name=display' + me.name + ']')[0];
25393
                                //var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
25394
                                //var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
25395
                                //var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
25396
                                //if (frmForm == undefined) {
25397
                                //    frmForm = Ext.create('MinovaUtil.MinovaES.MinovaWorkflowFormGrid', {
25398
                                //        bizprocid: this.bizprocid,
25399
                                //        taskid: this.taskid,
25400
                                //        name: 'form' + this.TableName,
25401
                                //        tableName: this.TableName,
25402
                                //    });
25403
                                //}
25404
                                ////frmForm.reset();
25405
                                ////frmForm.down('form').getForm().loadRecord(dtrec.data);
25406
                                //frmForm.show();
25407

    
25408
                                var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
25409
                                var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
25410
                                var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
25411
                                if (dtrec) {
25412
                                    //frmDisplay.reset();
25413
                                    frmForm.reset();
25414
                                    frmForm.getForm().setValues(dtrec.data);
25415
                                    //frmDisplay.setHidden(true);
25416
                                    frmForm.setHidden(false);
25417
                                    //grdPanel.setHidden(true);
25418
                                    me.action = "1";
25419
                                }
25420
                            }
25421
                        }
25422
                    ]
25423
                }
25424
                ],
25425
                columns: cols,
25426
                //selType: checkSelection,
25427
                //plugins: {
25428
                //    ptype: 'actionColumnRowEditing', //rowediting
25429
                //    pluginId: 'rowEditing',
25430
                //    hiddenColumnsOnEdit: ['startEditActionColumn'],
25431
                //    clicksToEdit: 2,
25432
                //    saveButtonIconCls: 'x-fa fa-floppy-o',
25433
                //    listeners: {}
25434
                //},
25435
                listeners: {
25436
                    //'beforeedit': function (editor) {
25437
                    //    editor.getEditor().floatingButtons.items.items[0].hide();
25438
                    //    editor.getEditor().floatingButtons.items.items[1].hide();
25439
                    //}
25440
                    'itemdblclick': function (this_, record, item, index, e, eOpts) {
25441
                        //var me = this;
25442
                        var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
25443
                        //var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.tablename + ']')[0];
25444
                        var dtrec = record;
25445
                        if (dtrec) {
25446
                            //frmDisplay.reset();
25447
                            //frmForm.reset();
25448
                            frmForm.getForm().setValues(dtrec.data);
25449
                            //grdPanel.setHeight(0);
25450
                            //frmDisplay.setHidden(true);
25451
                            frmForm.setHidden(false);
25452
                            //grdPanel.setHidden(true);
25453
                            me.action = "1";
25454
                        }
25455
                    }
25456
                },
25457
                features: features,
25458
                viewConfig: {
25459
                    listeners: {
25460
                        refresh: function (dataview) {
25461
                            Ext.each(dataview.panel.columns, function (column) {
25462
                                //column.autoSize();
25463
                            })
25464
                        }
25465
                    }
25466
                }
25467
            }
25468
            ]
25469
        });
25470
        me.callParent(arguments);
25471
    },
25472
    listeners: {
25473
        boxready: function (dataview) {
25474
            var grd = Ext.ComponentQuery.query('[name=grid' + this.name + ']')[0];
25475
            grd.reconfigure(); //YN 20211217 - Solusi Layout rapih
25476
        }
25477
    }
25478
});
25479

    
25480
/*Form ESS Generator YN 20211216*/
25481
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowFormGrid', {
25482
    extend: 'Ext.form.Panel',
25483
    alias: ['widget.MinovaWorkflowFormGrid', 'widget.minovaworkflowformgrid', 'widget.workflowformgrid'],
25484
    controller: 'workflowformgrid',
25485
    formname: this.name,
25486
    bizprocid: undefined,
25487
    bizflowid: undefined,
25488
    taskid: undefined,
25489
    tableName: undefined,
25490
    tableNameT: undefined,
25491
    titleform: undefined,
25492
    labelWidth: 150,
25493
    //resizable: true,
25494
    border: true,
25495
    autoScroll: true,
25496
    minHeight: 20,
25497
    layout: {
25498
        type: 'hbox'
25499
    },
25500
    listeners: {
25501
        render: function () {
25502
            if (this.titleform != undefined) {
25503
                this.setTitle(this.titleform);
25504
            }
25505
        },
25506
    },
25507
    buttonAlign: 'left',
25508
    defaults: {
25509
        layout: 'anchor',
25510
        xtype: 'container',
25511
        flex: 1,
25512
        margin: '10px',
25513
        //defaultType: 'textfield',
25514
        //anchor: '100%',
25515
        ////style: 'width: 50%',
25516
    },
25517
    initComponent: function () {
25518
        var col1 = [];
25519
        var col2 = [];
25520
        var me = this;
25521
        var LangID = localStorage.LangId;
25522
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
25523
        var formname_ = me.name;
25524
        var nameTable_ = me.tableName;
25525
        //var labelWidth = 150;
25526
        Ext.Ajax.request({
25527
            async: false,
25528
            method: 'POST',
25529
            url: '/UserControl/GetStore',
25530
            params: {
25531
                tableName: 'PDSWFSTRUCTUREFIELD',
25532
                param: parameter
25533
            },
25534
            success: function (response) {
25535
                var results = Ext.decode(response.responseText);
25536
                hasil = results.data;
25537
            }
25538
        });
25539
        if (hasil.length > 0) {
25540
            Ext.each(hasil, function (rec) {
25541
                var formfield = undefined;
25542
                var readonly = false;
25543
                var ishidden = false;
25544
                var allowblank = true;
25545
                var startDt = null;
25546
                var endDt = null;
25547
                if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
25548
                    startDt = 'StartDate';
25549
                    endDt = 'EndDate';
25550
                }
25551
                if (rec.IsReadOnly == '1') {
25552
                    readonly = true;
25553
                }
25554
                if (rec.IsRequired == '1') {
25555
                    allowblank = false;
25556
                }
25557
                if (rec.IsVisible == '0') {
25558
                    ishidden = true;
25559
                }
25560
                if (rec.SearchType == "") //textfield
25561
                {
25562
                    switch (rec.FormatRef) {
25563
                        case "date":
25564
                            if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
25565
                                formfield = new Ext.form.DateField({
25566
                                    allowBlank: allowblank,
25567
                                    fieldLabel: rec.ScreenCaption,
25568
                                    readOnly: readonly,
25569
                                    msgTarget: 'side',
25570
                                    //labelCls: 'label-minova',
25571
                                    labelWidth: me.labelWidth,
25572
                                    hidden: ishidden,
25573
                                    name: rec.FieldName,
25574
                                    submitFormat: 'Ymd',
25575
                                    value: rec.DefaultValue,
25576
                                    anchor: '100%',
25577
                                    vtype: 'daterange',
25578
                                    start: startDt,
25579
                                    end: endDt,
25580
                                    formname: formname_,
25581
                                    nameTable: nameTable_,
25582
                                    hideMode: 'visibility',
25583
                                    listeners: {
25584
                                        change: function (val) {
25585
                                            var _label = val.name;
25586
                                            var _form = val.formname;
25587
                                            var _Value = val.getValue();
25588
                                            var target = rec.TriggerCombo;
25589
                                            var custumFunc = rec.SelectFunction;
25590
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25591
                                                Ext.Ajax.request({
25592
                                                    async: false,
25593
                                                    method: 'POST',
25594
                                                    url: '/UserControl/GetStore',
25595
                                                    params: {
25596
                                                        tableName: 'PCMFUNC',
25597
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25598
                                                    },
25599
                                                    success: function (response) {
25600
                                                        var results = Ext.decode(response.responseText);
25601
                                                        data_ = results.data[0];
25602
                                                        if (data_ != undefined) {
25603
                                                            custumFunc = data_.FunctionCode;
25604
                                                        }
25605
                                                    }
25606
                                                });
25607
                                            }
25608
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25609
                                            if (frm) {
25610
                                                if (custumFunc) {
25611
                                                    eval(custumFunc)
25612
                                                }
25613
                                            }
25614
                                        }
25615
                                    }
25616
                                });
25617
                            } else {
25618
                                formfield = new Ext.form.DateField({
25619
                                    allowBlank: allowblank,
25620
                                    fieldLabel: rec.ScreenCaption,
25621
                                    readOnly: readonly,
25622
                                    msgTarget: 'side',
25623
                                    //labelCls: 'label-minova',
25624
                                    labelWidth: me.labelWidth,
25625
                                    hidden: ishidden,
25626
                                    name: rec.FieldName,
25627
                                    submitFormat: 'Ymd',
25628
                                    value: rec.DefaultValue,
25629
                                    anchor: '100%',
25630
                                    formname: formname_,
25631
                                    nameTable: nameTable_,
25632
                                    hideMode: 'visibility',
25633
                                    listeners: {
25634
                                        change: function (val) {
25635
                                            var _label = val.name;
25636
                                            var _form = val.formname;
25637
                                            var _Value = val.getValue();
25638
                                            var target = rec.TriggerCombo;
25639
                                            var custumFunc = rec.SelectFunction;
25640
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25641
                                                Ext.Ajax.request({
25642
                                                    async: false,
25643
                                                    method: 'POST',
25644
                                                    url: '/UserControl/GetStore',
25645
                                                    params: {
25646
                                                        tableName: 'PCMFUNC',
25647
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25648
                                                    },
25649
                                                    success: function (response) {
25650
                                                        var results = Ext.decode(response.responseText);
25651
                                                        data_ = results.data[0];
25652
                                                        if (data_ != undefined) {
25653
                                                            custumFunc = data_.FunctionCode;
25654
                                                        }
25655
                                                    }
25656
                                                });
25657
                                            }
25658
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25659
                                            if (frm) {
25660
                                                if (custumFunc) {
25661
                                                    eval(custumFunc)
25662
                                                }
25663
                                            }
25664
                                        }
25665
                                    }
25666
                                });
25667
                            }
25668
                            break;
25669
                        case "time":
25670
                            formfield = new Ext.form.TimeField({
25671
                                allowBlank: allowblank,
25672
                                fieldLabel: rec.ScreenCaption,
25673
                                readOnly: readonly,
25674
                                //labelCls: 'label-minova',
25675
                                labelWidth: me.labelWidth,
25676
                                hidden: ishidden,
25677
                                name: rec.FieldName,
25678
                                msgTarget: 'side',
25679
                                format: 'Hi',
25680
                                submitFormat: 'Hi',
25681
                                increment: 5,
25682
                                value: rec.DefaultValue,
25683
                                anchor: '100%',
25684
                                formname: formname_,
25685
                                nameTable: nameTable_,
25686
                                listeners: {
25687
                                    change: function (val) {
25688
                                        var _label = val.name;
25689
                                        var _form = val.formname;
25690
                                        var _Value = val.getValue();
25691
                                        var target = rec.TriggerCombo;
25692
                                        var custumFunc = rec.SelectFunction;
25693
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25694
                                            Ext.Ajax.request({
25695
                                                async: false,
25696
                                                method: 'POST',
25697
                                                url: '/UserControl/GetStore',
25698
                                                params: {
25699
                                                    tableName: 'PCMFUNC',
25700
                                                    param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
25701
                                                },
25702
                                                success: function (response) {
25703
                                                    var results = Ext.decode(response.responseText);
25704
                                                    data_ = results.data[0];
25705
                                                    if (data_ != undefined) {
25706
                                                        custumFunc = data_.FunctionCode;
25707
                                                    }
25708
                                                }
25709
                                            });
25710
                                        }
25711
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25712
                                        if (frm) {
25713
                                            if (custumFunc) {
25714
                                                eval(custumFunc)
25715
                                            }
25716
                                        }
25717
                                    }
25718
                                }
25719
                            });
25720
                            break;
25721
                        case "amount":
25722
                            formfield = new Ext.form.TextField({
25723
                                allowBlank: allowblank,
25724
                                fieldLabel: rec.ScreenCaption,
25725
                                readOnly: readonly,
25726
                                //labelCls: 'label-minova',
25727
                                labelWidth: me.labelWidth,
25728
                                hidden: ishidden,
25729
                                name: rec.FieldName,
25730
                                msgTarget: 'side',
25731
                                value: rec.DefaultValue,
25732
                                maxLength: rec.Length,
25733
                                anchor: '100%',
25734
                                formname: formname_,
25735
                                nameTable: nameTable_,
25736
                                fieldStyle: 'text-align:right;',
25737
                                listeners: {
25738
                                    change: function (val) {
25739
                                        var _label = val.name;
25740
                                        var _form = val.formname;
25741
                                        var _Value = val.getValue();
25742
                                        var target = rec.TriggerCombo;
25743
                                        var custumFunc = rec.SelectFunction;
25744
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25745
                                            Ext.Ajax.request({
25746
                                                async: false,
25747
                                                method: 'POST',
25748
                                                url: '/UserControl/GetStore',
25749
                                                params: {
25750
                                                    tableName: 'PCMFUNC',
25751
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25752
                                                },
25753
                                                success: function (response) {
25754
                                                    var results = Ext.decode(response.responseText);
25755
                                                    data_ = results.data[0];
25756
                                                    if (data_ != undefined) {
25757
                                                        custumFunc = data_.FunctionCode;
25758
                                                    }
25759
                                                }
25760
                                            });
25761
                                        }
25762
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25763
                                        if (frm) {
25764
                                            if (custumFunc) {
25765
                                                eval(custumFunc)
25766
                                            }
25767
                                        }
25768
                                    }
25769
                                }
25770
                            });
25771
                            break;
25772
                        case "file":
25773
                            formfield = new MinovaUtil.MinovaES.UploadFile({
25774
                                allowBlank: allowblank,
25775
                                fieldLabel: rec.ScreenCaption,
25776
                                readOnly: readonly,
25777
                                readOnlyCls: 'minova-readonly',
25778
                                hidden: ishidden,
25779
                                //labelCls: 'label-minova',
25780
                                name: rec.FieldName,
25781
                                msgTarget: 'side',
25782
                                fieldname: rec.FieldName,
25783
                                IsPrimaryKey: rec.IsPrimaryKey,
25784
                                tableName: rec.TableRef,
25785
                                triggerCls: 'x-form-search-trigger',
25786
                                formtarget: me.formname,
25787
                                anchor: '100%',
25788
                                formname: formname_,
25789
                                nameTable: nameTable_,
25790
                                listeners: {
25791
                                    change: function (val) {
25792
                                        var _label = val.name;
25793
                                        var _form = val.formname;
25794
                                        var _Value = val.getValue();
25795
                                        var target = rec.TriggerCombo;
25796
                                        var custumFunc = rec.SelectFunction;
25797
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25798
                                            Ext.Ajax.request({
25799
                                                async: false,
25800
                                                method: 'POST',
25801
                                                url: '/UserControl/GetStore',
25802
                                                params: {
25803
                                                    tableName: 'PCMFUNC',
25804
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25805
                                                },
25806
                                                success: function (response) {
25807
                                                    var results = Ext.decode(response.responseText);
25808
                                                    data_ = results.data[0];
25809
                                                    if (data_ != undefined) {
25810
                                                        custumFunc = data_.FunctionCode;
25811
                                                    }
25812
                                                }
25813
                                            });
25814
                                        }
25815
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25816
                                        if (frm) {
25817
                                            if (target) {
25818
                                                var f = frm.getForm().findField(target)
25819
                                                _store = f.getStore();
25820
                                                var _tbl = _store.proxy.extraParams.tableName;
25821
                                                var oldParam = _store.proxy.extraParams.param;
25822
                                                _store.proxy.extraParams = {
25823
                                                    tableName: _tbl,
25824
                                                    param: _label + '[=]' + _Value
25825
                                                };
25826
                                                _store.load();
25827
                                            }
25828
                                            if (custumFunc) {
25829
                                                eval(custumFunc)
25830
                                            }
25831
                                        }
25832
                                    }
25833
                                }
25834
                            });
25835
                            break;
25836
                        default:
25837
                            if (rec.DataType == 0) {
25838
                                if (rec.Length > 250) {
25839
                                    formfield = new Ext.form.TextArea({
25840
                                        allowBlank: allowblank,
25841
                                        fieldLabel: rec.ScreenCaption,
25842
                                        readOnly: readonly,
25843
                                        ////labelCls: 'label-minova',
25844
                                        labelWidth: me.labelWidth,
25845
                                        hidden: ishidden,
25846
                                        name: rec.FieldName,
25847
                                        msgTarget: 'side',
25848
                                        value: rec.DefaultValue,
25849
                                        maxLength: rec.Length,
25850
                                        anchor: '100%',
25851
                                        grow: true,
25852
                                        formname: formname_,
25853
                                        nameTable: nameTable_,
25854
                                        listeners: {
25855
                                            change: function (val) {
25856
                                                var _label = val.name;
25857
                                                var _form = val.formname;
25858
                                                var _Value = val.getValue();
25859
                                                var target = rec.TriggerCombo;
25860
                                                var custumFunc = rec.SelectFunction;
25861
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25862
                                                    Ext.Ajax.request({
25863
                                                        async: false,
25864
                                                        method: 'POST',
25865
                                                        url: '/UserControl/GetStore',
25866
                                                        params: {
25867
                                                            tableName: 'PCMFUNC',
25868
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25869
                                                        },
25870
                                                        success: function (response) {
25871
                                                            var results = Ext.decode(response.responseText);
25872
                                                            data_ = results.data[0];
25873
                                                            if (data_ != undefined) {
25874
                                                                custumFunc = data_.FunctionCode;
25875
                                                            }
25876
                                                        }
25877
                                                    });
25878
                                                }
25879
                                                var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25880
                                                if (frm) {
25881
                                                    if (custumFunc) {
25882
                                                        eval(custumFunc)
25883
                                                    }
25884
                                                }
25885
                                            }
25886
                                        }
25887
                                    });
25888
                                } else {
25889
                                    if (rec.FixedValue != '') {
25890
                                        var storeData = [];
25891
                                        var str = rec.FixedValue;
25892
                                        var hasil = str.split('||');
25893
                                        hasil.forEach(function (h) {
25894
                                            store_ = h.split('=')
25895
                                            storeData.push({
25896
                                                code: store_[0],
25897
                                                desc: store_[1],
25898
                                            });
25899
                                        });
25900
                                        formfield = new Ext.form.ComboBox({
25901
                                            allowBlank: allowblank,
25902
                                            fieldLabel: rec.ScreenCaption,
25903
                                            forceSelection: true,
25904
                                            readOnly: readonly,
25905
                                            //labelCls: 'label-minova',
25906
                                            labelWidth: me.labelWidth,
25907
                                            hidden: ishidden,
25908
                                            name: rec.FieldName,
25909
                                            msgTarget: 'side',
25910
                                            value: rec.DefaultValue,
25911
                                            anchor: '100%',
25912
                                            formname: formname_,
25913
                                            nameTable: nameTable_,
25914
                                            formtarget: me.formname,
25915
                                            store: Ext.create('Ext.data.Store', {
25916
                                                storeId: 'store' + rec.FieldName,
25917
                                                autoLoad: true,
25918
                                                data: storeData
25919

    
25920
                                            }),
25921
                                            listeners: {
25922
                                                change: function (val) {
25923
                                                    var _label = val.name;
25924
                                                    var _form = val.formtarget;
25925
                                                    var _Value = val.getValue();
25926
                                                    var target = rec.TriggerCombo;
25927
                                                    var custumFunc = rec.SelectFunction;
25928
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25929
                                                    if (frm) {
25930
                                                        if (target) {
25931
                                                            var f = frm.getForm().findField(target)
25932
                                                            _store = f.getStore();
25933
                                                            var _tbl = _store.proxy.extraParams.tableName;
25934
                                                            var oldParam = _store.proxy.extraParams.param;
25935
                                                            _store.proxy.extraParams = {
25936
                                                                tableName: _tbl,
25937
                                                                param: _label + '[=]' + _Value
25938
                                                            };
25939
                                                            _store.load();
25940
                                                        }
25941
                                                        if (custumFunc) {
25942
                                                            eval(custumFunc)
25943
                                                        }
25944
                                                    }
25945
                                                }
25946
                                            },
25947
                                            queryMode: 'local',
25948
                                            valueField: 'code',
25949
                                            displayField: 'desc',
25950
                                        });
25951
                                    } else {
25952
                                        formfield = new Ext.form.TextField({
25953
                                            allowBlank: allowblank,
25954
                                            fieldLabel: rec.ScreenCaption,
25955
                                            readOnly: readonly,
25956
                                            //labelCls: 'label-minova',
25957
                                            labelWidth: me.labelWidth,
25958
                                            hidden: ishidden,
25959
                                            name: rec.FieldName,
25960
                                            msgTarget: 'side',
25961
                                            value: rec.DefaultValue,
25962
                                            maxLength: rec.Length,
25963
                                            anchor: '100%',
25964
                                            formname: formname_,
25965
                                            nameTable: nameTable_,
25966
                                            listeners: {
25967
                                                change: function (val) {
25968
                                                    var _label = val.name;
25969
                                                    var _form = val.formname;
25970
                                                    var _Value = val.getValue();
25971
                                                    var target = rec.TriggerCombo;
25972
                                                    var custumFunc = rec.SelectFunction;
25973
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25974
                                                        Ext.Ajax.request({
25975
                                                            async: false,
25976
                                                            method: 'POST',
25977
                                                            url: '/UserControl/GetStore',
25978
                                                            params: {
25979
                                                                tableName: 'PCMFUNC',
25980
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25981
                                                            },
25982
                                                            success: function (response) {
25983
                                                                var results = Ext.decode(response.responseText);
25984
                                                                data_ = results.data[0];
25985
                                                                if (data_ != undefined) {
25986
                                                                    custumFunc = data_.FunctionCode;
25987
                                                                }
25988
                                                            }
25989
                                                        });
25990
                                                    }
25991
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25992
                                                    if (frm) {
25993
                                                        if (custumFunc) {
25994
                                                            eval(custumFunc)
25995
                                                        }
25996
                                                    }
25997
                                                }
25998
                                            }
25999
                                        });
26000
                                    }
26001
                                }
26002
                            } else if (rec.DataType == 1 || rec.DataType == 2) {
26003
                                formfield = new MinovaUtil.MinovaES.MinovaNumberField({
26004
                                    allowBlank: allowblank,
26005
                                    fieldLabel: rec.ScreenCaption,
26006
                                    readOnly: readonly,
26007
                                    //labelCls: 'label-minova',
26008
                                    labelWidth: me.labelWidth,
26009
                                    msgTarget: 'side',
26010
                                    hidden: ishidden,
26011
                                    name: rec.FieldName,
26012
                                    value: rec.DefaultValue,
26013
                                    maxLength: rec.Length,
26014
                                    anchor: '100%',
26015
                                    formname: formname_,
26016
                                    nameTable: nameTable_,
26017
                                    fieldStyle: 'text-align:right;',
26018
                                    listeners: {
26019
                                        change: function (val) {
26020
                                            var _label = val.name;
26021
                                            var _form = val.formname;
26022
                                            var _Value = val.getValue();
26023
                                            var target = rec.TriggerCombo;
26024
                                            var custumFunc = rec.SelectFunction;
26025
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26026
                                                Ext.Ajax.request({
26027
                                                    async: false,
26028
                                                    method: 'POST',
26029
                                                    url: '/UserControl/GetStore',
26030
                                                    params: {
26031
                                                        tableName: 'PCMFUNC',
26032
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26033
                                                    },
26034
                                                    success: function (response) {
26035
                                                        var results = Ext.decode(response.responseText);
26036
                                                        data_ = results.data[0];
26037
                                                        if (data_ != undefined) {
26038
                                                            custumFunc = data_.FunctionCode;
26039
                                                        }
26040
                                                    }
26041
                                                });
26042
                                            }
26043
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26044
                                            if (frm) {
26045
                                                if (target) {
26046
                                                    var f = frm.getForm().findField(target)
26047
                                                    _store = f.getStore();
26048
                                                    var _tbl = _store.proxy.extraParams.tableName;
26049
                                                    var oldParam = _store.proxy.extraParams.param;
26050
                                                    _store.proxy.extraParams = {
26051
                                                        tableName: _tbl,
26052
                                                        param: _label + '[=]' + _Value
26053
                                                    };
26054
                                                    _store.load();
26055
                                                }
26056
                                                if (custumFunc) {
26057
                                                    eval(custumFunc)
26058
                                                }
26059
                                            }
26060
                                        }
26061
                                    }
26062
                                });
26063
                            } else if (rec.DataType == 3) {
26064
                                formfield = new Ext.form.TextField({
26065
                                    allowBlank: allowblank,
26066
                                    fieldLabel: rec.ScreenCaption,
26067
                                    readOnly: readonly,
26068
                                    //labelCls: 'label-minova',
26069
                                    labelWidth: me.labelWidth,
26070
                                    msgTarget: 'side',
26071
                                    hidden: ishidden,
26072
                                    name: rec.FieldName,
26073
                                    value: rec.DefaultValue,
26074
                                    maxLength: rec.Length,
26075
                                    precision: rec.Prec,
26076
                                    anchor: '100%',
26077
                                    formname: formname_,
26078
                                    nameTable: nameTable_,
26079
                                    fieldStyle: 'text-align:right;',
26080
                                    maskRe: '^[0-9]+(\.[0-9]{1,2})?$',
26081
                                    listeners: {
26082
                                        change: function (val) {
26083
                                            var _label = val.name;
26084
                                            var _form = val.formname;
26085
                                            var _Value = val.getValue();
26086
                                            var target = rec.TriggerCombo;
26087
                                            var custumFunc = rec.SelectFunction;
26088
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26089
                                                Ext.Ajax.request({
26090
                                                    async: false,
26091
                                                    method: 'POST',
26092
                                                    url: '/UserControl/GetStore',
26093
                                                    params: {
26094
                                                        tableName: 'PCMFUNC',
26095
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26096
                                                    },
26097
                                                    success: function (response) {
26098
                                                        var results = Ext.decode(response.responseText);
26099
                                                        data_ = results.data[0];
26100
                                                        if (data_ != undefined) {
26101
                                                            custumFunc = data_.FunctionCode;
26102
                                                        }
26103
                                                    }
26104
                                                });
26105
                                            }
26106
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26107
                                            if (frm) {
26108
                                                if (target) {
26109
                                                    var f = frm.getForm().findField(target)
26110
                                                    _store = f.getStore();
26111
                                                    var _tbl = _store.proxy.extraParams.tableName;
26112
                                                    var oldParam = _store.proxy.extraParams.param;
26113
                                                    _store.proxy.extraParams = {
26114
                                                        tableName: _tbl,
26115
                                                        param: _label + '[=]' + _Value
26116
                                                    };
26117
                                                    _store.load();
26118
                                                }
26119
                                                if (custumFunc) {
26120
                                                    eval(custumFunc)
26121
                                                }
26122
                                            }
26123
                                        }
26124
                                    }
26125
                                });
26126
                            }
26127
                    }
26128
                } else if (rec.SearchType != "") {
26129
                    if (rec.SearchType == "0") //combobox
26130
                    {
26131
                        valueField = null;
26132
                        displayValue = null;
26133
                        if (rec.TableRef != "") {
26134
                            Ext.Ajax.request({
26135
                                async: false,
26136
                                method: 'POST',
26137
                                url: '/UserControl/GetStore',
26138
                                params: {
26139
                                    tableName: 'SDATATABLEFIELD',
26140
                                    param: 'TableName[equal]' + rec.TableRef
26141
                                },
26142
                                success: function (response) {
26143
                                    var results = Ext.decode(response.responseText);
26144
                                    data_ = results.data;
26145
                                    if (data_ != undefined) {
26146
                                        valueField_ = $.grep(data_, function (r) {
26147
                                            return r.ValueField == '1'
26148
                                        });
26149
                                        if (valueField_.length > 0) {
26150
                                            valueField = valueField_[0].FieldName
26151
                                        }
26152
                                        displayValue_ = $.grep(data_, function (r) {
26153
                                            return r.DisplayValue == '1'
26154
                                        });
26155
                                        if (displayValue_.length > 0) {
26156
                                            displayValue = displayValue_[0].FieldName
26157
                                        }
26158
                                    }
26159
                                }
26160
                            });
26161
                        }
26162
                        formfield = new Ext.form.ComboBox({
26163
                            allowBlank: allowblank,
26164
                            fieldLabel: rec.ScreenCaption,
26165
                            forceSelection: true,
26166
                            anyMatch: true,
26167
                            readOnly: readonly,
26168
                            //labelCls: 'label-minova',
26169
                            labelWidth: me.labelWidth,
26170
                            hidden: ishidden,
26171
                            msgTarget: 'side',
26172
                            name: rec.FieldName,
26173
                            formname: formname_,
26174
                            nameTable: nameTable_,
26175
                            value: rec.DefaultValue,
26176
                            anchor: '100%', //width: '95%',
26177
                            //store: Ext.StoreMgr.lookup('store' + rec.FieldName) ? Ext.StoreMgr.lookup('store' + rec.FieldName):
26178
                            store: Ext.create('Ext.data.Store', {
26179
                                storeId: 'store' + rec.FieldName,
26180
                                autoLoad: false,
26181
                                proxy: {
26182
                                    method: 'POST',
26183
                                    type: 'ajax',
26184
                                    url: '/UserControl/GetStore',
26185
                                    extraParams: {
26186
                                        tableName: rec.TableRef,
26187
                                        param: rec.ParamCombo
26188
                                    },
26189
                                    reader: {
26190
                                        type: 'json',
26191
                                        root: 'data',
26192
                                        totalProperty: 'data[0].TotalCount'
26193
                                    }
26194
                                }
26195
                            }),
26196
                            formtarget: formname_,
26197
                            listeners: {
26198
                                afterrender: function (f) {
26199
                                    var store_ = f.getStore();
26200
                                    store_.load();
26201
                                },
26202
                                change: function (val) {
26203
                                    var _label = val.name;
26204
                                    var _form = val.formtarget;
26205
                                    var _Value = val.getValue();
26206
                                    var target = rec.TriggerCombo;
26207
                                    var custumFunc = rec.SelectFunction;
26208
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26209
                                    if (frm) {
26210

    
26211
                                        if (target) {
26212
                                            var f = frm.getForm().findField(target)
26213
                                            _store = f.getStore();
26214
                                            var _tbl = _store.proxy.extraParams.tableName;
26215
                                            var oldParam = _store.proxy.extraParams.param;
26216
                                            _store.proxy.extraParams = {
26217
                                                tableName: _tbl,
26218
                                                param: _label + '[=]' + _Value
26219
                                            };
26220
                                            _store.load();
26221
                                        }
26222
                                        if (custumFunc) {
26223
                                            eval(custumFunc)
26224
                                        }
26225
                                    }
26226
                                }
26227
                            },
26228
                            queryMode: 'local',
26229
                            displayField: displayValue,
26230
                            valueField: valueField,
26231
                        });
26232
                    } else if (rec.SearchType == '2') //Lookup
26233
                    {
26234
                        formfield = new MinovaUtil.MinovaES.MinovaLookupGrid({
26235
                            allowBlank: allowblank,
26236
                            fieldLabel: rec.ScreenCaption,
26237
                            readOnly: readonly,
26238
                            IsPrimaryKey: rec.IsPrimaryKey,
26239
                            msgTarget: 'side',
26240
                            //labelCls: 'label-minova',
26241
                            labelWidth: me.labelWidth,
26242
                            hidden: ishidden,
26243
                            name: rec.FieldName,
26244
                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
26245
                            triggerCls: 'x-form-search-trigger',
26246
                            vtype: 'alphanum', // disable space
26247
                            formtarget: me.formname, // nama form  yang akan di set value-nya
26248
                            anchor: '100%',
26249
                            formname: formname_,
26250
                            nameTable: nameTable_,
26251
                            LookupFunction: rec.LookupFunction,
26252
                            SearchFunction: rec.SearchFunction,
26253
                            listeners: {
26254
                                change: function (val) {
26255
                                    var _label = val.name;
26256
                                    var _form = val.formname;
26257
                                    var _Value = val.getValue();
26258
                                    var target = rec.TriggerCombo;
26259
                                    var custumFunc = rec.SelectFunction;
26260
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26261
                                        Ext.Ajax.request({
26262
                                            async: false,
26263
                                            method: 'POST',
26264
                                            url: '/UserControl/GetStore',
26265
                                            params: {
26266
                                                tableName: 'PCMFUNC',
26267
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26268
                                            },
26269
                                            success: function (response) {
26270
                                                var results = Ext.decode(response.responseText);
26271
                                                data_ = results.data[0];
26272
                                                if (data_ != undefined) {
26273
                                                    custumFunc = data_.FunctionCode;
26274
                                                }
26275
                                            }
26276
                                        });
26277
                                    }
26278
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26279
                                    if (frm) {
26280

    
26281
                                        if (target) {
26282
                                            var f = frm.getForm().findField(target)
26283
                                            _store = f.getStore();
26284
                                            var _tbl = _store.proxy.extraParams.tableName;
26285
                                            var oldParam = _store.proxy.extraParams.param;
26286
                                            _store.proxy.extraParams = {
26287
                                                tableName: _tbl,
26288
                                                param: _label + '[=]' + _Value
26289
                                            };
26290
                                            _store.load();
26291
                                        }
26292

    
26293
                                        if (custumFunc) {
26294
                                            eval(custumFunc)
26295
                                        }
26296

    
26297
                                    }
26298

    
26299
                                },
26300

    
26301
                            },
26302
                        });
26303
                    } else if (rec.SearchType == '3') //lookup tree
26304
                    {
26305
                        formfield = new MinovaUtil.MinovaES.MinovaLookupTree({
26306
                            allowBlank: allowblank,
26307
                            fieldLabel: rec.ScreenCaption,
26308
                            readOnly: readonly,
26309
                            IsPrimaryKey: rec.IsPrimaryKey,
26310
                            //labelCls: 'label-minova',
26311
                            labelWidth: me.labelWidth,
26312
                            hidden: ishidden,
26313
                            name: rec.FieldName,
26314
                            msgTarget: 'side',
26315
                            triggerCls: 'x-form-search-trigger',
26316
                            treeSructure: rec.SearchFunction, //'O-O-P',
26317
                            objClassValue: rec.ParamCombo, //'O',
26318
                            formname: formname_,
26319
                            targetField: rec.FieldName,
26320
                            nameTable: nameTable_,
26321
                            editable: false,
26322
                            anchor: '100%',
26323
                            listeners: {
26324
                                change3: function (val) {
26325
                                    var _label = val.name;
26326
                                    var _form = val.formname;
26327
                                    var _Value = val.getValue();
26328
                                    var target = rec.TriggerCombo;
26329
                                    var custumFunc = rec.SelectFunction;
26330
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26331
                                        Ext.Ajax.request({
26332
                                            async: false,
26333
                                            method: 'POST',
26334
                                            url: '/UserControl/GetStore',
26335
                                            params: {
26336
                                                tableName: 'PCMFUNC',
26337
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26338
                                            },
26339
                                            success: function (response) {
26340
                                                var results = Ext.decode(response.responseText);
26341
                                                data_ = results.data[0];
26342
                                                if (data_ != undefined) {
26343
                                                    custumFunc = data_.FunctionCode;
26344
                                                }
26345
                                            }
26346
                                        });
26347
                                    }
26348
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26349
                                    if (frm) {
26350

    
26351
                                        if (target) {
26352
                                            var f = frm.getForm().findField(target)
26353
                                            _store = f.getStore();
26354
                                            var _tbl = _store.proxy.extraParams.tableName;
26355
                                            var oldParam = _store.proxy.extraParams.param;
26356
                                            _store.proxy.extraParams = {
26357
                                                tableName: _tbl,
26358
                                                param: _label + '[=]' + _Value
26359
                                            };
26360
                                            _store.load();
26361
                                        }
26362
                                        if (custumFunc) {
26363
                                            eval(custumFunc)
26364
                                        }
26365
                                    }
26366
                                },
26367
                                blur: function (val) {
26368
                                    //if(val.value.split('-').length != 2){
26369
                                    var _label = val.name;
26370
                                    var _form = val.formname;
26371
                                    var _Value = val.getValue();
26372
                                    var target = rec.TriggerCombo;
26373
                                    var custumFunc = rec.SelectFunction;
26374
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26375
                                        Ext.Ajax.request({
26376
                                            async: false,
26377
                                            method: 'POST',
26378
                                            url: '/UserControl/GetStore',
26379
                                            params: {
26380
                                                tableName: 'PCMFUNC',
26381
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26382
                                            },
26383
                                            success: function (response) {
26384
                                                var results = Ext.decode(response.responseText);
26385
                                                data_ = results.data[0];
26386
                                                if (data_ != undefined) {
26387
                                                    custumFunc = data_.FunctionCode;
26388
                                                }
26389
                                            }
26390
                                        });
26391
                                    }
26392
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26393
                                    if (frm) {
26394

    
26395
                                        if (target) {
26396
                                            var f = frm.getForm().findField(target)
26397
                                            _store = f.getStore();
26398
                                            var _tbl = _store.proxy.extraParams.tableName;
26399
                                            var oldParam = _store.proxy.extraParams.param;
26400
                                            _store.proxy.extraParams = {
26401
                                                tableName: _tbl,
26402
                                                param: _label + '[=]' + _Value
26403
                                            };
26404
                                            _store.load();
26405
                                        }
26406
                                        if (custumFunc) {
26407
                                            eval(custumFunc)
26408
                                        }
26409
                                    }
26410
                                    //}
26411
                                }
26412

    
26413
                            }
26414
                        });
26415
                    }
26416
                }
26417
                if (isDesk) {
26418
                    if (rec.ColumnNo == 1) {
26419
                        col1.push(formfield);
26420
                    } else {
26421
                        col2.push(formfield);
26422
                    }
26423
                } else {
26424
                    col1.push(formfield);
26425
                }
26426

    
26427
            });
26428
        }
26429
        Ext.applyIf(me, {
26430
            items:
26431
                [
26432
                    {
26433
                        //width: 450,
26434
                        //style: 'width: 50%',
26435
                        defaults: {
26436
                            layout: 'anchor',
26437
                            xtype: 'container',
26438
                            flex: 1,
26439
                            margin: '10px',
26440
                            //defaultType: 'textfield',
26441
                            //anchor: '100%',
26442
                            ////style: 'width: 50%',
26443
                        },
26444
                        items: col1,
26445
                        flex: 1,
26446
                    },
26447
                    {
26448
                        //width: 450,
26449
                        //style: 'width: 50%',
26450
                        defaults: {
26451
                            layout: 'anchor',
26452
                            xtype: 'container',
26453
                            flex: 1,
26454
                            margin: '10px',
26455
                            //defaultType: 'textfield',
26456
                            //anchor: '100%',
26457
                            ////style: 'width: 50%',
26458
                        },
26459
                        items: col2,
26460
                        flex: 1,
26461
                    }
26462
                ]
26463
        });
26464
        this.callParent();
26465
    },
26466
    listeners: {
26467
        boxready: function (dataview) {
26468
            //this.reset(); //YN 20211217 - Solusi Layout sebelah kanan terlalu geser
26469
        }
26470
    },
26471
    buttons: [{
26472
        text: 'Update',
26473
        handler: 'onSaveClick'
26474
    }, {
26475
        text: 'Cancel',
26476
        handler: 'onCancelClick'
26477
    }]
26478
});
26479

    
26480
/*Form ESS GeneratorT YN 20211216*/
26481
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowFormGridT', {
26482
    extend: 'Ext.form.Panel',
26483
    alias: ['widget.MinovaWorkflowFormGridT', 'widget.minovaworkflowformgridT', 'widget.workflowformgridT'],
26484
    controller: 'workflowformgrid',
26485
    formname: this.name,
26486
    bizprocid: undefined,
26487
    bizflowid: undefined,
26488
    taskid: undefined,
26489
    tableName: undefined,
26490
    tableNameT: undefined,
26491
    parentKey: undefined,
26492
    titleform: undefined,
26493
    //resizable: true,
26494
    border: true,
26495
    autoScroll: true,
26496
    minHeight: 20,
26497
    layout: {
26498
        type: 'hbox'
26499
    },
26500
    listeners: {
26501
        render: function () {
26502
            if (this.titleform != undefined) {
26503
                this.setTitle(this.titleform);
26504
            }
26505
        },
26506
    },
26507
    buttonAlign: 'left',
26508
    defaults: {
26509
        layout: 'anchor',
26510
        xtype: 'container',
26511
        flex: 1,
26512
        margin: '10px',
26513
        //defaultType: 'textfield',
26514
        //anchor: '100%',
26515
        ////style: 'width: 50%',
26516
    },
26517
    initComponent: function () {
26518
        var col1 = [];
26519
        var col2 = [];
26520
        var me = this;
26521
        var LangID = localStorage.LangId;
26522
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
26523
        var formname_ = me.name;
26524
        var nameTable_ = me.tableName;
26525
        var labelWidth = 150;
26526
        Ext.Ajax.request({
26527
            async: false,
26528
            method: 'POST',
26529
            url: '/UserControl/GetStore',
26530
            params: {
26531
                tableName: 'PDSWFSTRUCTUREFIELD',
26532
                param: parameter
26533
            },
26534
            success: function (response) {
26535
                var results = Ext.decode(response.responseText);
26536
                hasil = results.data;
26537
            }
26538
        });
26539
        if (hasil.length > 0) {
26540
            Ext.each(hasil, function (rec) {
26541
                var formfield = undefined;
26542
                var readonly = false;
26543
                var ishidden = false;
26544
                var allowblank = true;
26545
                var startDt = null;
26546
                var endDt = null;
26547
                if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
26548
                    startDt = 'StartDate';
26549
                    endDt = 'EndDate';
26550
                }
26551
                if (rec.IsReadOnly == '1') {
26552
                    readonly = true;
26553
                }
26554
                if (rec.IsRequired == '1') {
26555
                    allowblank = false;
26556
                }
26557
                if (rec.IsVisible == '0') {
26558
                    ishidden = true;
26559
                }
26560
                if (rec.SearchType == "") //textfield
26561
                {
26562
                    switch (rec.FormatRef) {
26563
                        case "date":
26564
                            if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
26565
                                formfield = new Ext.form.DateField({
26566
                                    allowBlank: allowblank,
26567
                                    fieldLabel: rec.ScreenCaption,
26568
                                    readOnly: readonly,
26569
                                    msgTarget: 'side',
26570
                                    //labelCls: 'label-minova',
26571
                                    labelWidth: labelWidth,
26572
                                    hidden: ishidden,
26573
                                    name: rec.FieldName,
26574
                                    submitFormat: 'Ymd',
26575
                                    value: rec.DefaultValue,
26576
                                    anchor: '100%',
26577
                                    vtype: 'daterange',
26578
                                    start: startDt,
26579
                                    end: endDt,
26580
                                    formname: formname_,
26581
                                    nameTable: nameTable_,
26582
                                    hideMode: 'visibility',
26583
                                    listeners: {
26584
                                        change: function (val) {
26585
                                            var _label = val.name;
26586
                                            var _form = val.formname;
26587
                                            var _Value = val.getValue();
26588
                                            var target = rec.TriggerCombo;
26589
                                            var custumFunc = rec.SelectFunction;
26590
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26591
                                                Ext.Ajax.request({
26592
                                                    async: false,
26593
                                                    method: 'POST',
26594
                                                    url: '/UserControl/GetStore',
26595
                                                    params: {
26596
                                                        tableName: 'PCMFUNC',
26597
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26598
                                                    },
26599
                                                    success: function (response) {
26600
                                                        var results = Ext.decode(response.responseText);
26601
                                                        data_ = results.data[0];
26602
                                                        if (data_ != undefined) {
26603
                                                            custumFunc = data_.FunctionCode;
26604
                                                        }
26605
                                                    }
26606
                                                });
26607
                                            }
26608
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26609
                                            if (frm) {
26610
                                                if (custumFunc) {
26611
                                                    eval(custumFunc)
26612
                                                }
26613
                                            }
26614
                                        }
26615
                                    }
26616
                                });
26617
                            } else {
26618
                                formfield = new Ext.form.DateField({
26619
                                    allowBlank: allowblank,
26620
                                    fieldLabel: rec.ScreenCaption,
26621
                                    readOnly: readonly,
26622
                                    msgTarget: 'side',
26623
                                    //labelCls: 'label-minova',
26624
                                    labelWidth: labelWidth,
26625
                                    hidden: ishidden,
26626
                                    name: rec.FieldName,
26627
                                    submitFormat: 'Ymd',
26628
                                    value: rec.DefaultValue,
26629
                                    anchor: '100%',
26630
                                    formname: formname_,
26631
                                    nameTable: nameTable_,
26632
                                    hideMode: 'visibility',
26633
                                    listeners: {
26634
                                        change: function (val) {
26635
                                            var _label = val.name;
26636
                                            var _form = val.formname;
26637
                                            var _Value = val.getValue();
26638
                                            var target = rec.TriggerCombo;
26639
                                            var custumFunc = rec.SelectFunction;
26640
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26641
                                                Ext.Ajax.request({
26642
                                                    async: false,
26643
                                                    method: 'POST',
26644
                                                    url: '/UserControl/GetStore',
26645
                                                    params: {
26646
                                                        tableName: 'PCMFUNC',
26647
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26648
                                                    },
26649
                                                    success: function (response) {
26650
                                                        var results = Ext.decode(response.responseText);
26651
                                                        data_ = results.data[0];
26652
                                                        if (data_ != undefined) {
26653
                                                            custumFunc = data_.FunctionCode;
26654
                                                        }
26655
                                                    }
26656
                                                });
26657
                                            }
26658
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26659
                                            if (frm) {
26660
                                                if (custumFunc) {
26661
                                                    eval(custumFunc)
26662
                                                }
26663
                                            }
26664
                                        }
26665
                                    }
26666
                                });
26667
                            }
26668
                            break;
26669
                        case "time":
26670
                            formfield = new Ext.form.TimeField({
26671
                                allowBlank: allowblank,
26672
                                fieldLabel: rec.ScreenCaption,
26673
                                readOnly: readonly,
26674
                                //labelCls: 'label-minova',
26675
                                labelWidth: labelWidth,
26676
                                hidden: ishidden,
26677
                                name: rec.FieldName,
26678
                                msgTarget: 'side',
26679
                                format: 'Hi',
26680
                                submitFormat: 'Hi',
26681
                                increment: 5,
26682
                                value: rec.DefaultValue,
26683
                                anchor: '100%',
26684
                                formname: formname_,
26685
                                nameTable: nameTable_,
26686
                                listeners: {
26687
                                    change: function (val) {
26688
                                        var _label = val.name;
26689
                                        var _form = val.formname;
26690
                                        var _Value = val.getValue();
26691
                                        var target = rec.TriggerCombo;
26692
                                        var custumFunc = rec.SelectFunction;
26693
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26694
                                            Ext.Ajax.request({
26695
                                                async: false,
26696
                                                method: 'POST',
26697
                                                url: '/UserControl/GetStore',
26698
                                                params: {
26699
                                                    tableName: 'PCMFUNC',
26700
                                                    param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
26701
                                                },
26702
                                                success: function (response) {
26703
                                                    var results = Ext.decode(response.responseText);
26704
                                                    data_ = results.data[0];
26705
                                                    if (data_ != undefined) {
26706
                                                        custumFunc = data_.FunctionCode;
26707
                                                    }
26708
                                                }
26709
                                            });
26710
                                        }
26711
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26712
                                        if (frm) {
26713
                                            if (custumFunc) {
26714
                                                eval(custumFunc)
26715
                                            }
26716
                                        }
26717
                                    }
26718
                                }
26719
                            });
26720
                            break;
26721
                        case "amount":
26722
                            formfield = new Ext.form.TextField({
26723
                                allowBlank: allowblank,
26724
                                fieldLabel: rec.ScreenCaption,
26725
                                readOnly: readonly,
26726
                                //labelCls: 'label-minova',
26727
                                labelWidth: labelWidth,
26728
                                hidden: ishidden,
26729
                                name: rec.FieldName,
26730
                                msgTarget: 'side',
26731
                                value: rec.DefaultValue,
26732
                                maxLength: rec.Length,
26733
                                anchor: '100%',
26734
                                formname: formname_,
26735
                                nameTable: nameTable_,
26736
                                fieldStyle: 'text-align:right;',
26737
                                listeners: {
26738
                                    change: function (val) {
26739
                                        var _label = val.name;
26740
                                        var _form = val.formname;
26741
                                        var _Value = val.getValue();
26742
                                        var target = rec.TriggerCombo;
26743
                                        var custumFunc = rec.SelectFunction;
26744
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26745
                                            Ext.Ajax.request({
26746
                                                async: false,
26747
                                                method: 'POST',
26748
                                                url: '/UserControl/GetStore',
26749
                                                params: {
26750
                                                    tableName: 'PCMFUNC',
26751
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26752
                                                },
26753
                                                success: function (response) {
26754
                                                    var results = Ext.decode(response.responseText);
26755
                                                    data_ = results.data[0];
26756
                                                    if (data_ != undefined) {
26757
                                                        custumFunc = data_.FunctionCode;
26758
                                                    }
26759
                                                }
26760
                                            });
26761
                                        }
26762
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26763
                                        if (frm) {
26764
                                            if (custumFunc) {
26765
                                                eval(custumFunc)
26766
                                            }
26767
                                        }
26768
                                    }
26769
                                }
26770
                            });
26771
                            break;
26772
                        case "file":
26773
                            formfield = new MinovaUtil.MinovaES.UploadFile({
26774
                                allowBlank: allowblank,
26775
                                fieldLabel: rec.ScreenCaption,
26776
                                readOnly: readonly,
26777
                                readOnlyCls: 'minova-readonly',
26778
                                hidden: ishidden,
26779
                                //labelCls: 'label-minova',
26780
                                name: rec.FieldName,
26781
                                msgTarget: 'side',
26782
                                fieldname: rec.FieldName,
26783
                                IsPrimaryKey: rec.IsPrimaryKey,
26784
                                tableName: rec.TableRef,
26785
                                triggerCls: 'x-form-search-trigger',
26786
                                formtarget: me.formname,
26787
                                anchor: '100%',
26788
                                formname: formname_,
26789
                                nameTable: nameTable_,
26790
                                listeners: {
26791
                                    change: function (val) {
26792
                                        var _label = val.name;
26793
                                        var _form = val.formname;
26794
                                        var _Value = val.getValue();
26795
                                        var target = rec.TriggerCombo;
26796
                                        var custumFunc = rec.SelectFunction;
26797
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26798
                                            Ext.Ajax.request({
26799
                                                async: false,
26800
                                                method: 'POST',
26801
                                                url: '/UserControl/GetStore',
26802
                                                params: {
26803
                                                    tableName: 'PCMFUNC',
26804
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26805
                                                },
26806
                                                success: function (response) {
26807
                                                    var results = Ext.decode(response.responseText);
26808
                                                    data_ = results.data[0];
26809
                                                    if (data_ != undefined) {
26810
                                                        custumFunc = data_.FunctionCode;
26811
                                                    }
26812
                                                }
26813
                                            });
26814
                                        }
26815
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26816
                                        if (frm) {
26817
                                            if (target) {
26818
                                                var f = frm.getForm().findField(target)
26819
                                                _store = f.getStore();
26820
                                                var _tbl = _store.proxy.extraParams.tableName;
26821
                                                var oldParam = _store.proxy.extraParams.param;
26822
                                                _store.proxy.extraParams = {
26823
                                                    tableName: _tbl,
26824
                                                    param: _label + '[=]' + _Value
26825
                                                };
26826
                                                _store.load();
26827
                                            }
26828
                                            if (custumFunc) {
26829
                                                eval(custumFunc)
26830
                                            }
26831
                                        }
26832
                                    }
26833
                                }
26834
                            });
26835
                            break;
26836
                        default:
26837
                            if (rec.DataType == 0) {
26838
                                if (rec.Length > 250) {
26839
                                    formfield = new Ext.form.TextArea({
26840
                                        allowBlank: allowblank,
26841
                                        fieldLabel: rec.ScreenCaption,
26842
                                        readOnly: readonly,
26843
                                        ////labelCls: 'label-minova',
26844
                                        labelWidth: labelWidth,
26845
                                        hidden: ishidden,
26846
                                        name: rec.FieldName,
26847
                                        msgTarget: 'side',
26848
                                        value: rec.DefaultValue,
26849
                                        maxLength: rec.Length,
26850
                                        anchor: '100%',
26851
                                        grow: true,
26852
                                        formname: formname_,
26853
                                        nameTable: nameTable_,
26854
                                        listeners: {
26855
                                            change: function (val) {
26856
                                                var _label = val.name;
26857
                                                var _form = val.formname;
26858
                                                var _Value = val.getValue();
26859
                                                var target = rec.TriggerCombo;
26860
                                                var custumFunc = rec.SelectFunction;
26861
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26862
                                                    Ext.Ajax.request({
26863
                                                        async: false,
26864
                                                        method: 'POST',
26865
                                                        url: '/UserControl/GetStore',
26866
                                                        params: {
26867
                                                            tableName: 'PCMFUNC',
26868
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26869
                                                        },
26870
                                                        success: function (response) {
26871
                                                            var results = Ext.decode(response.responseText);
26872
                                                            data_ = results.data[0];
26873
                                                            if (data_ != undefined) {
26874
                                                                custumFunc = data_.FunctionCode;
26875
                                                            }
26876
                                                        }
26877
                                                    });
26878
                                                }
26879
                                                var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26880
                                                if (frm) {
26881
                                                    if (custumFunc) {
26882
                                                        eval(custumFunc)
26883
                                                    }
26884
                                                }
26885
                                            }
26886
                                        }
26887
                                    });
26888
                                } else {
26889
                                    if (rec.FixedValue != '') {
26890
                                        var storeData = [];
26891
                                        var str = rec.FixedValue;
26892
                                        var hasil = str.split('||');
26893
                                        hasil.forEach(function (h) {
26894
                                            store_ = h.split('=')
26895
                                            storeData.push({
26896
                                                code: store_[0],
26897
                                                desc: store_[1],
26898
                                            });
26899
                                        });
26900
                                        formfield = new Ext.form.ComboBox({
26901
                                            allowBlank: allowblank,
26902
                                            fieldLabel: rec.ScreenCaption,
26903
                                            forceSelection: true,
26904
                                            readOnly: readonly,
26905
                                            //labelCls: 'label-minova',
26906
                                            labelWidth: labelWidth,
26907
                                            hidden: ishidden,
26908
                                            name: rec.FieldName,
26909
                                            msgTarget: 'side',
26910
                                            value: rec.DefaultValue,
26911
                                            anchor: '100%',
26912
                                            formname: formname_,
26913
                                            nameTable: nameTable_,
26914
                                            formtarget: me.formname,
26915
                                            store: Ext.create('Ext.data.Store', {
26916
                                                storeId: 'store' + rec.FieldName,
26917
                                                autoLoad: true,
26918
                                                data: storeData
26919

    
26920
                                            }),
26921
                                            listeners: {
26922
                                                change: function (val) {
26923
                                                    var _label = val.name;
26924
                                                    var _form = val.formtarget;
26925
                                                    var _Value = val.getValue();
26926
                                                    var target = rec.TriggerCombo;
26927
                                                    var custumFunc = rec.SelectFunction;
26928
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26929
                                                    if (frm) {
26930
                                                        if (target) {
26931
                                                            var f = frm.getForm().findField(target)
26932
                                                            _store = f.getStore();
26933
                                                            var _tbl = _store.proxy.extraParams.tableName;
26934
                                                            var oldParam = _store.proxy.extraParams.param;
26935
                                                            _store.proxy.extraParams = {
26936
                                                                tableName: _tbl,
26937
                                                                param: _label + '[=]' + _Value
26938
                                                            };
26939
                                                            _store.load();
26940
                                                        }
26941
                                                        if (custumFunc) {
26942
                                                            eval(custumFunc)
26943
                                                        }
26944
                                                    }
26945
                                                }
26946
                                            },
26947
                                            queryMode: 'local',
26948
                                            valueField: 'code',
26949
                                            displayField: 'desc',
26950
                                        });
26951
                                    } else {
26952
                                        formfield = new Ext.form.TextField({
26953
                                            allowBlank: allowblank,
26954
                                            fieldLabel: rec.ScreenCaption,
26955
                                            readOnly: readonly,
26956
                                            //labelCls: 'label-minova',
26957
                                            labelWidth: labelWidth,
26958
                                            hidden: ishidden,
26959
                                            name: rec.FieldName,
26960
                                            msgTarget: 'side',
26961
                                            value: rec.DefaultValue,
26962
                                            maxLength: rec.Length,
26963
                                            anchor: '100%',
26964
                                            formname: formname_,
26965
                                            nameTable: nameTable_,
26966
                                            listeners: {
26967
                                                change: function (val) {
26968
                                                    var _label = val.name;
26969
                                                    var _form = val.formname;
26970
                                                    var _Value = val.getValue();
26971
                                                    var target = rec.TriggerCombo;
26972
                                                    var custumFunc = rec.SelectFunction;
26973
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26974
                                                        Ext.Ajax.request({
26975
                                                            async: false,
26976
                                                            method: 'POST',
26977
                                                            url: '/UserControl/GetStore',
26978
                                                            params: {
26979
                                                                tableName: 'PCMFUNC',
26980
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26981
                                                            },
26982
                                                            success: function (response) {
26983
                                                                var results = Ext.decode(response.responseText);
26984
                                                                data_ = results.data[0];
26985
                                                                if (data_ != undefined) {
26986
                                                                    custumFunc = data_.FunctionCode;
26987
                                                                }
26988
                                                            }
26989
                                                        });
26990
                                                    }
26991
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26992
                                                    if (frm) {
26993
                                                        if (custumFunc) {
26994
                                                            eval(custumFunc)
26995
                                                        }
26996
                                                    }
26997
                                                }
26998
                                            }
26999
                                        });
27000
                                    }
27001
                                }
27002
                            } else if (rec.DataType == 1 || rec.DataType == 2) {
27003
                                formfield = new MinovaUtil.MinovaES.MinovaNumberField({
27004
                                    allowBlank: allowblank,
27005
                                    fieldLabel: rec.ScreenCaption,
27006
                                    readOnly: readonly,
27007
                                    //labelCls: 'label-minova',
27008
                                    labelWidth: labelWidth,
27009
                                    msgTarget: 'side',
27010
                                    hidden: ishidden,
27011
                                    name: rec.FieldName,
27012
                                    value: rec.DefaultValue,
27013
                                    maxLength: rec.Length,
27014
                                    anchor: '100%',
27015
                                    formname: formname_,
27016
                                    nameTable: nameTable_,
27017
                                    fieldStyle: 'text-align:right;',
27018
                                    listeners: {
27019
                                        change: function (val) {
27020
                                            var _label = val.name;
27021
                                            var _form = val.formname;
27022
                                            var _Value = val.getValue();
27023
                                            var target = rec.TriggerCombo;
27024
                                            var custumFunc = rec.SelectFunction;
27025
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27026
                                                Ext.Ajax.request({
27027
                                                    async: false,
27028
                                                    method: 'POST',
27029
                                                    url: '/UserControl/GetStore',
27030
                                                    params: {
27031
                                                        tableName: 'PCMFUNC',
27032
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27033
                                                    },
27034
                                                    success: function (response) {
27035
                                                        var results = Ext.decode(response.responseText);
27036
                                                        data_ = results.data[0];
27037
                                                        if (data_ != undefined) {
27038
                                                            custumFunc = data_.FunctionCode;
27039
                                                        }
27040
                                                    }
27041
                                                });
27042
                                            }
27043
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27044
                                            if (frm) {
27045
                                                if (target) {
27046
                                                    var f = frm.getForm().findField(target)
27047
                                                    _store = f.getStore();
27048
                                                    var _tbl = _store.proxy.extraParams.tableName;
27049
                                                    var oldParam = _store.proxy.extraParams.param;
27050
                                                    _store.proxy.extraParams = {
27051
                                                        tableName: _tbl,
27052
                                                        param: _label + '[=]' + _Value
27053
                                                    };
27054
                                                    _store.load();
27055
                                                }
27056
                                                if (custumFunc) {
27057
                                                    eval(custumFunc)
27058
                                                }
27059
                                            }
27060
                                        }
27061
                                    }
27062
                                });
27063
                            } else if (rec.DataType == 3) {
27064
                                formfield = new Ext.form.TextField({
27065
                                    allowBlank: allowblank,
27066
                                    fieldLabel: rec.ScreenCaption,
27067
                                    readOnly: readonly,
27068
                                    //labelCls: 'label-minova',
27069
                                    labelWidth: labelWidth,
27070
                                    msgTarget: 'side',
27071
                                    hidden: ishidden,
27072
                                    name: rec.FieldName,
27073
                                    value: rec.DefaultValue,
27074
                                    maxLength: rec.Length,
27075
                                    precision: rec.Prec,
27076
                                    anchor: '100%',
27077
                                    formname: formname_,
27078
                                    nameTable: nameTable_,
27079
                                    fieldStyle: 'text-align:right;',
27080
                                    maskRe: '^[0-9]+(\.[0-9]{1,2})?$',
27081
                                    listeners: {
27082
                                        change: function (val) {
27083
                                            var _label = val.name;
27084
                                            var _form = val.formname;
27085
                                            var _Value = val.getValue();
27086
                                            var target = rec.TriggerCombo;
27087
                                            var custumFunc = rec.SelectFunction;
27088
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27089
                                                Ext.Ajax.request({
27090
                                                    async: false,
27091
                                                    method: 'POST',
27092
                                                    url: '/UserControl/GetStore',
27093
                                                    params: {
27094
                                                        tableName: 'PCMFUNC',
27095
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27096
                                                    },
27097
                                                    success: function (response) {
27098
                                                        var results = Ext.decode(response.responseText);
27099
                                                        data_ = results.data[0];
27100
                                                        if (data_ != undefined) {
27101
                                                            custumFunc = data_.FunctionCode;
27102
                                                        }
27103
                                                    }
27104
                                                });
27105
                                            }
27106
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27107
                                            if (frm) {
27108
                                                if (target) {
27109
                                                    var f = frm.getForm().findField(target)
27110
                                                    _store = f.getStore();
27111
                                                    var _tbl = _store.proxy.extraParams.tableName;
27112
                                                    var oldParam = _store.proxy.extraParams.param;
27113
                                                    _store.proxy.extraParams = {
27114
                                                        tableName: _tbl,
27115
                                                        param: _label + '[=]' + _Value
27116
                                                    };
27117
                                                    _store.load();
27118
                                                }
27119
                                                if (custumFunc) {
27120
                                                    eval(custumFunc)
27121
                                                }
27122
                                            }
27123
                                        }
27124
                                    }
27125
                                });
27126
                            }
27127
                    }
27128
                } else if (rec.SearchType != "") {
27129
                    if (rec.SearchType == "0") //combobox
27130
                    {
27131
                        valueField = null;
27132
                        displayValue = null;
27133
                        if (rec.TableRef != "") {
27134
                            Ext.Ajax.request({
27135
                                async: false,
27136
                                method: 'POST',
27137
                                url: '/UserControl/GetStore',
27138
                                params: {
27139
                                    tableName: 'SDATATABLEFIELD',
27140
                                    param: 'TableName[equal]' + rec.TableRef
27141
                                },
27142
                                success: function (response) {
27143
                                    var results = Ext.decode(response.responseText);
27144
                                    data_ = results.data;
27145
                                    if (data_ != undefined) {
27146
                                        valueField_ = $.grep(data_, function (r) {
27147
                                            return r.ValueField == '1'
27148
                                        });
27149
                                        if (valueField_.length > 0) {
27150
                                            valueField = valueField_[0].FieldName
27151
                                        }
27152
                                        displayValue_ = $.grep(data_, function (r) {
27153
                                            return r.DisplayValue == '1'
27154
                                        });
27155
                                        if (displayValue_.length > 0) {
27156
                                            displayValue = displayValue_[0].FieldName
27157
                                        }
27158
                                    }
27159
                                }
27160
                            });
27161
                        }
27162
                        formfield = new Ext.form.ComboBox({
27163
                            allowBlank: allowblank,
27164
                            fieldLabel: rec.ScreenCaption,
27165
                            forceSelection: true,
27166
                            anyMatch: true,
27167
                            readOnly: readonly,
27168
                            //labelCls: 'label-minova',
27169
                            labelWidth: labelWidth,
27170
                            hidden: ishidden,
27171
                            msgTarget: 'side',
27172
                            name: rec.FieldName,
27173
                            formname: formname_,
27174
                            nameTable: nameTable_,
27175
                            value: rec.DefaultValue,
27176
                            anchor: '100%', //width: '95%',
27177
                            store: Ext.create('Ext.data.Store', {
27178
                                storeId: 'store' + rec.FieldName,
27179
                                autoLoad: false,
27180
                                proxy: {
27181
                                    method: 'POST',
27182
                                    type: 'ajax',
27183
                                    url: '/UserControl/GetStore',
27184
                                    extraParams: {
27185
                                        tableName: rec.TableRef,
27186
                                        param: rec.ParamCombo
27187
                                    },
27188
                                    reader: {
27189
                                        type: 'json',
27190
                                        root: 'data',
27191
                                        totalProperty: 'data[0].TotalCount'
27192
                                    }
27193
                                }
27194
                            }),
27195
                            formtarget: formname_,
27196
                            listeners: {
27197
                                afterrender: function (f) {
27198
                                    var store_ = f.getStore();
27199
                                    store_.load();
27200
                                },
27201
                                change: function (val) {
27202
                                    var _label = val.name;
27203
                                    var _form = val.formtarget;
27204
                                    var _Value = val.getValue();
27205
                                    var target = rec.TriggerCombo;
27206
                                    var custumFunc = rec.SelectFunction;
27207
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27208
                                    if (frm) {
27209

    
27210
                                        if (target) {
27211
                                            var f = frm.getForm().findField(target)
27212
                                            _store = f.getStore();
27213
                                            var _tbl = _store.proxy.extraParams.tableName;
27214
                                            var oldParam = _store.proxy.extraParams.param;
27215
                                            _store.proxy.extraParams = {
27216
                                                tableName: _tbl,
27217
                                                param: _label + '[=]' + _Value
27218
                                            };
27219
                                            _store.load();
27220
                                        }
27221
                                        if (custumFunc) {
27222
                                            eval(custumFunc)
27223
                                        }
27224
                                    }
27225
                                }
27226
                            },
27227
                            queryMode: 'local',
27228
                            displayField: displayValue,
27229
                            valueField: valueField,
27230
                        });
27231
                    } else if (rec.SearchType == '2') //Lookup
27232
                    {
27233
                        formfield = new MinovaUtil.MinovaES.MinovaLookupGrid({
27234
                            allowBlank: allowblank,
27235
                            fieldLabel: rec.ScreenCaption,
27236
                            readOnly: readonly,
27237
                            IsPrimaryKey: rec.IsPrimaryKey,
27238
                            msgTarget: 'side',
27239
                            //labelCls: 'label-minova',
27240
                            labelWidth: labelWidth,
27241
                            hidden: ishidden,
27242
                            name: rec.FieldName,
27243
                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
27244
                            triggerCls: 'x-form-search-trigger',
27245
                            vtype: 'alphanum', // disable space
27246
                            formtarget: me.formname, // nama form  yang akan di set value-nya
27247
                            anchor: '100%',
27248
                            formname: formname_,
27249
                            nameTable: nameTable_,
27250
                            LookupFunction: rec.LookupFunction,
27251
                            SearchFunction: rec.SearchFunction,
27252
                            listeners: {
27253
                                change: function (val) {
27254
                                    var _label = val.name;
27255
                                    var _form = val.formname;
27256
                                    var _Value = val.getValue();
27257
                                    var target = rec.TriggerCombo;
27258
                                    var custumFunc = rec.SelectFunction;
27259
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27260
                                        Ext.Ajax.request({
27261
                                            async: false,
27262
                                            method: 'POST',
27263
                                            url: '/UserControl/GetStore',
27264
                                            params: {
27265
                                                tableName: 'PCMFUNC',
27266
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27267
                                            },
27268
                                            success: function (response) {
27269
                                                var results = Ext.decode(response.responseText);
27270
                                                data_ = results.data[0];
27271
                                                if (data_ != undefined) {
27272
                                                    custumFunc = data_.FunctionCode;
27273
                                                }
27274
                                            }
27275
                                        });
27276
                                    }
27277
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27278
                                    if (frm) {
27279

    
27280
                                        if (target) {
27281
                                            var f = frm.getForm().findField(target)
27282
                                            _store = f.getStore();
27283
                                            var _tbl = _store.proxy.extraParams.tableName;
27284
                                            var oldParam = _store.proxy.extraParams.param;
27285
                                            _store.proxy.extraParams = {
27286
                                                tableName: _tbl,
27287
                                                param: _label + '[=]' + _Value
27288
                                            };
27289
                                            _store.load();
27290
                                        }
27291

    
27292
                                        if (custumFunc) {
27293
                                            eval(custumFunc)
27294
                                        }
27295

    
27296
                                    }
27297

    
27298
                                },
27299

    
27300
                            },
27301
                        });
27302
                    } else if (rec.SearchType == '3') //lookup tree
27303
                    {
27304
                        formfield = new MinovaUtil.MinovaES.MinovaLookupTree({
27305
                            allowBlank: allowblank,
27306
                            fieldLabel: rec.ScreenCaption,
27307
                            readOnly: readonly,
27308
                            IsPrimaryKey: rec.IsPrimaryKey,
27309
                            //labelCls: 'label-minova',
27310
                            labelWidth: labelWidth,
27311
                            hidden: ishidden,
27312
                            name: rec.FieldName,
27313
                            msgTarget: 'side',
27314
                            triggerCls: 'x-form-search-trigger',
27315
                            treeSructure: rec.SearchFunction, //'O-O-P',
27316
                            objClassValue: rec.ParamCombo, //'O',
27317
                            formname: formname_,
27318
                            targetField: rec.FieldName,
27319
                            nameTable: nameTable_,
27320
                            editable: false,
27321
                            anchor: '100%',
27322
                            listeners: {
27323
                                change3: function (val) {
27324
                                    var _label = val.name;
27325
                                    var _form = val.formname;
27326
                                    var _Value = val.getValue();
27327
                                    var target = rec.TriggerCombo;
27328
                                    var custumFunc = rec.SelectFunction;
27329
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27330
                                        Ext.Ajax.request({
27331
                                            async: false,
27332
                                            method: 'POST',
27333
                                            url: '/UserControl/GetStore',
27334
                                            params: {
27335
                                                tableName: 'PCMFUNC',
27336
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27337
                                            },
27338
                                            success: function (response) {
27339
                                                var results = Ext.decode(response.responseText);
27340
                                                data_ = results.data[0];
27341
                                                if (data_ != undefined) {
27342
                                                    custumFunc = data_.FunctionCode;
27343
                                                }
27344
                                            }
27345
                                        });
27346
                                    }
27347
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27348
                                    if (frm) {
27349

    
27350
                                        if (target) {
27351
                                            var f = frm.getForm().findField(target)
27352
                                            _store = f.getStore();
27353
                                            var _tbl = _store.proxy.extraParams.tableName;
27354
                                            var oldParam = _store.proxy.extraParams.param;
27355
                                            _store.proxy.extraParams = {
27356
                                                tableName: _tbl,
27357
                                                param: _label + '[=]' + _Value
27358
                                            };
27359
                                            _store.load();
27360
                                        }
27361
                                        if (custumFunc) {
27362
                                            eval(custumFunc)
27363
                                        }
27364
                                    }
27365
                                },
27366
                                blur: function (val) {
27367
                                    //if(val.value.split('-').length != 2){
27368
                                    var _label = val.name;
27369
                                    var _form = val.formname;
27370
                                    var _Value = val.getValue();
27371
                                    var target = rec.TriggerCombo;
27372
                                    var custumFunc = rec.SelectFunction;
27373
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27374
                                        Ext.Ajax.request({
27375
                                            async: false,
27376
                                            method: 'POST',
27377
                                            url: '/UserControl/GetStore',
27378
                                            params: {
27379
                                                tableName: 'PCMFUNC',
27380
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27381
                                            },
27382
                                            success: function (response) {
27383
                                                var results = Ext.decode(response.responseText);
27384
                                                data_ = results.data[0];
27385
                                                if (data_ != undefined) {
27386
                                                    custumFunc = data_.FunctionCode;
27387
                                                }
27388
                                            }
27389
                                        });
27390
                                    }
27391
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27392
                                    if (frm) {
27393

    
27394
                                        if (target) {
27395
                                            var f = frm.getForm().findField(target)
27396
                                            _store = f.getStore();
27397
                                            var _tbl = _store.proxy.extraParams.tableName;
27398
                                            var oldParam = _store.proxy.extraParams.param;
27399
                                            _store.proxy.extraParams = {
27400
                                                tableName: _tbl,
27401
                                                param: _label + '[=]' + _Value
27402
                                            };
27403
                                            _store.load();
27404
                                        }
27405
                                        if (custumFunc) {
27406
                                            eval(custumFunc)
27407
                                        }
27408
                                    }
27409
                                    //}
27410
                                }
27411

    
27412
                            }
27413
                        });
27414
                    }
27415
                }
27416
                if (isDesk) {
27417
                    if (rec.ColumnNo == 1) {
27418
                        col1.push(formfield);
27419
                    } else {
27420
                        col2.push(formfield);
27421
                    }
27422
                } else {
27423
                    col1.push(formfield);
27424
                }
27425

    
27426
            });
27427
        }
27428
        Ext.applyIf(me, {
27429
            items:
27430
                [
27431
                    {
27432
                        //width: 450,
27433
                        //style: 'width: 50%',
27434
                        defaults: {
27435
                            layout: 'anchor',
27436
                            xtype: 'container',
27437
                            flex: 1,
27438
                            margin: '10px',
27439
                            //defaultType: 'textfield',
27440
                            //anchor: '100%',
27441
                            ////style: 'width: 50%',
27442
                        },
27443
                        items: col1,
27444
                        flex: 1,
27445
                    },
27446
                    {
27447
                        //width: 450,
27448
                        //style: 'width: 50%',
27449
                        defaults: {
27450
                            layout: 'anchor',
27451
                            xtype: 'container',
27452
                            flex: 1,
27453
                            margin: '10px',
27454
                            //defaultType: 'textfield',
27455
                            //anchor: '100%',
27456
                            ////style: 'width: 50%',
27457
                        },
27458
                        items: col2,
27459
                        flex: 1,
27460
                    }
27461
                ]
27462
        });
27463
        this.callParent();
27464
    },
27465
    listeners: {
27466
        boxready: function (dataview) {
27467
            //this.reset(); //YN 20211217 - Solusi Layout sebelah kanan terlalu geser
27468
        }
27469
    },
27470
    buttons: [{
27471
        text: 'Update',
27472
        handler: 'onSaveClick'
27473
    }, {
27474
        text: 'Cancel',
27475
        handler: 'onCancelClick'
27476
    }]
27477
});
27478

    
27479
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowFormGridController', {
27480
    extend: 'Ext.app.ViewController',
27481
    alias: 'controller.workflowformgrid',
27482
    //afterrender: function () {
27483
    //    this.reset();
27484
    //},
27485

    
27486
    onSaveClick: function () {
27487
        // Save the changes pending in the dialog's child session back to the
27488
        // parent session.
27489
        //this.dialog.getSession().save();
27490
        var frmPanel = this.getView();
27491
        //var panel = this.up('form');
27492
        //var form = panel.getForm();
27493
        if (frmPanel.isValid()) {
27494
            //Ext.Msg.alert('Success');
27495
            var grdPanel = Ext.ComponentQuery.query('[name=grid' + frmPanel.tableName + ']')[0];
27496
            var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
27497
            values = frmPanel.getValues();
27498
            try {               
27499
                dtrec.set(values);
27500
                }
27501
            catch (e) {
27502
                //grdPanel.reconfigure();
27503
                console.log(e);
27504
            }
27505
            frmPanel.hide();
27506
            //this.onCancelClick();
27507
        } else {
27508
            fieldNames = [];
27509
            fields = this.getInvalidFields(frmPanel);
27510
            for (var i = 0; i < fields.length; i++) {
27511
                field = fields[i];
27512
                fieldNames.push(i + 1 + '. ' + field.fieldLabel + ' (' + field.activeErrors[0] + ')');
27513
            }
27514
            console.debug(fieldNames);
27515
            Ext.MessageBox.alert('Invalid Fields', 'The following fields are invalid: </br> ' + fieldNames.join(' </br>'));
27516
        }
27517
    },
27518

    
27519
    onCancelClick: function () {
27520
        //this.getView().remove(this.dialog);
27521
        //this.dialog = null;
27522
        var frmPanel = this.getView();
27523
        //frmPanel.reset();
27524
        frmPanel.hide();
27525
    },
27526

    
27527
    getInvalidFields: function (frmPanel) {
27528
        var invalidFields = [];
27529
        Ext.suspendLayouts();
27530
        frmPanel.getForm().getFields().filterBy(function (field) {
27531
            if (field.validate()) return;
27532
            invalidFields.push(field);
27533
        });
27534
        Ext.resumeLayouts(true);
27535
        return invalidFields;
27536
    },
27537
});
27538

    
27539
/*Form ESS Generator Layout: Auto if just 1 column YN 20211216*/
27540
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowForm1', {
27541
    extend: 'Ext.form.Panel',
27542
    alias: ['widget.MinovaWorkflowForm1', 'widget.minovaworkflowform1', 'widget.workflowform1'],
27543
    formname: this.name,
27544
    bizprocid: undefined,
27545
    bizflowid: undefined,
27546
    taskid: undefined,
27547
    tableName: undefined,
27548
    tableNameT: undefined,
27549
    parentKey: undefined,
27550
    titleform: undefined,
27551
    name: undefined,
27552
    labelAlign: 'left',
27553
    labelWidth: 150,
27554
    labelSeparator: undefined,
27555
    //resizable: true,
27556
    border: true,
27557
    autoScroll: true,
27558
    minHeight: 20,
27559
    marginDefault: 10,
27560
    layout: {
27561
        type: (isDesk == true) ? 'hbox': 'auto'
27562
    },
27563
    listeners: {
27564
        render: function () {
27565
            if (this.titleform != undefined) {
27566
                this.setTitle(this.titleform);
27567
            }
27568
        },
27569
    },
27570
    defaults: {
27571
        layout: 'anchor',
27572
        xtype: 'container',
27573
        flex: 1,
27574
        margin: this.marginDefault,
27575
        //defaultType: 'textfield',
27576
        //anchor: '100%',
27577
        ////style: 'width: 50%',
27578
    },
27579
    initComponent: function () {
27580
        var col1 = [];
27581
        var col2 = [];
27582
        var me = this;
27583
        var LangID = localStorage.LangId;
27584
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
27585
        var formname_ = me.name;
27586
        var nameTable_ = me.tableName;
27587
        var labelWidth = me.labelWidth;
27588
        Ext.Ajax.request({
27589
            async: false,
27590
            method: 'POST',
27591
            url: '/UserControl/GetStore',
27592
            params: {
27593
                tableName: 'PDSWFSTRUCTUREFIELD',
27594
                param: parameter
27595
            },
27596
            success: function (response) {
27597
                var results = Ext.decode(response.responseText);
27598
                hasil = results.data;
27599
            }
27600
        });
27601
        if (hasil.length > 0) {
27602
            Ext.each(hasil, function (rec) {
27603
                var formfield = undefined;
27604
                var readonly = false;
27605
                var ishidden = false;
27606
                var allowblank = true;
27607
                var startDt = null;
27608
                var endDt = null;
27609
                if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
27610
                    startDt = 'StartDate';
27611
                    endDt = 'EndDate';
27612
                }
27613
                if (rec.IsReadOnly == '1') {
27614
                    readonly = true;
27615
                }
27616
                if (rec.IsRequired == '1') {
27617
                    allowblank = false;
27618
                }
27619
                if (rec.IsVisible == '0') {
27620
                    ishidden = true;
27621
                }
27622
                if (rec.SearchType == "") //textfield
27623
                {
27624
                    switch (rec.FormatRef) {
27625
                        case "date":
27626
                            if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
27627
                                formfield = new Ext.form.DateField({
27628
                                    allowBlank: allowblank,
27629
                                    fieldLabel: rec.ScreenCaption,
27630
                                    readOnly: readonly,
27631
									
27632
									//Start for mobile by saswanto
27633
									editable:readonly,
27634
									plugins: 'responsive',
27635
									responsiveConfig: {
27636
										personalizedWide:{}
27637
									},    
27638
									responsiveFormulas: {
27639
										personalizedWide: function (context,layout) {
27640
											if (context.width <= 600){
27641
												this.cmp.setEditable(false);
27642
												return true;
27643
											}
27644
										}
27645
									},							
27646
									//Start for mobile by saswanto									
27647
									
27648
                                    msgTarget: 'side',
27649
                                    //labelCls: 'label-minova',
27650
                                    labelWidth: labelWidth,
27651
                                    hidden: ishidden,
27652
                                    name: rec.FieldName,
27653
                                    submitFormat: 'Ymd',
27654
                                    value: rec.DefaultValue,
27655
                                    anchor: '100%',
27656
                                    vtype: 'daterange',
27657
                                    start: startDt,
27658
                                    end: endDt,
27659
                                    formname: formname_,
27660
                                    nameTable: nameTable_,
27661
                                    hideMode: 'visibility',
27662
                                    listeners: {
27663
                                        change: function (val) {
27664
                                            var _label = val.name;
27665
                                            var _form = val.formname;
27666
                                            var _Value = val.getValue();
27667
                                            var target = rec.TriggerCombo;
27668
                                            var custumFunc = rec.SelectFunction;
27669
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27670
                                                Ext.Ajax.request({
27671
                                                    async: false,
27672
                                                    method: 'POST',
27673
                                                    url: '/UserControl/GetStore',
27674
                                                    params: {
27675
                                                        tableName: 'PCMFUNC',
27676
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27677
                                                    },
27678
                                                    success: function (response) {
27679
                                                        var results = Ext.decode(response.responseText);
27680
                                                        data_ = results.data[0];
27681
                                                        if (data_ != undefined) {
27682
                                                            custumFunc = data_.FunctionCode;
27683
                                                        }
27684
                                                    }
27685
                                                });
27686
                                            }
27687
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27688
                                            if (frm) {
27689
                                                if (custumFunc) {
27690
                                                    eval(custumFunc)
27691
                                                }
27692
                                            }
27693
                                        }
27694
                                    }
27695
                                });
27696
                            } else {
27697
                                formfield = new Ext.form.DateField({
27698
                                    allowBlank: allowblank,
27699
                                    fieldLabel: rec.ScreenCaption,
27700
                                    readOnly: readonly,
27701
									
27702
									//Start for mobile by saswanto
27703
									editable:readonly,
27704
									plugins: 'responsive',
27705
									responsiveConfig: {
27706
										personalizedWide:{}
27707
									},    
27708
									responsiveFormulas: {
27709
										personalizedWide: function (context,layout) {
27710
											if (context.width <= 600){
27711
												this.cmp.setEditable(false);
27712
												return true;
27713
											}
27714
										}
27715
									},							
27716
									//Start for mobile by saswanto									
27717
									
27718
                                    msgTarget: 'side',
27719
                                    //labelCls: 'label-minova',
27720
                                    labelWidth: labelWidth,
27721
                                    hidden: ishidden,
27722
                                    name: rec.FieldName,
27723
                                    submitFormat: 'Ymd',
27724
                                    value: rec.DefaultValue,
27725
                                    anchor: '100%',
27726
                                    formname: formname_,
27727
                                    nameTable: nameTable_,
27728
                                    hideMode: 'visibility',
27729
                                    listeners: {
27730
                                        change: function (val) {
27731
                                            var _label = val.name;
27732
                                            var _form = val.formname;
27733
                                            var _Value = val.getValue();
27734
                                            var target = rec.TriggerCombo;
27735
                                            var custumFunc = rec.SelectFunction;
27736
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27737
                                                Ext.Ajax.request({
27738
                                                    async: false,
27739
                                                    method: 'POST',
27740
                                                    url: '/UserControl/GetStore',
27741
                                                    params: {
27742
                                                        tableName: 'PCMFUNC',
27743
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27744
                                                    },
27745
                                                    success: function (response) {
27746
                                                        var results = Ext.decode(response.responseText);
27747
                                                        data_ = results.data[0];
27748
                                                        if (data_ != undefined) {
27749
                                                            custumFunc = data_.FunctionCode;
27750
                                                        }
27751
                                                    }
27752
                                                });
27753
                                            }
27754
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27755
                                            if (frm) {
27756
                                                if (custumFunc) {
27757
                                                    eval(custumFunc)
27758
                                                }
27759
                                            }
27760
                                        }
27761
                                    }
27762
                                });
27763
                            }
27764
                            break;
27765
                        case "time":
27766
                            formfield = new Ext.form.TimeField({
27767
                                allowBlank: allowblank,
27768
                                fieldLabel: rec.ScreenCaption,
27769
                                readOnly: readonly,
27770
								
27771
								//Start for mobile by saswanto
27772
								editable:readonly,
27773
								plugins: 'responsive',
27774
								responsiveConfig: {
27775
									personalizedWide:{}
27776
								},    
27777
								responsiveFormulas: {
27778
									personalizedWide: function (context,layout) {
27779
										if (context.width <= 600){
27780
											this.cmp.setEditable(false);
27781
											return true;
27782
										}
27783
									}
27784
								},							
27785
								//Start for mobile by saswanto								
27786
								
27787
                                //labelCls: 'label-minova',
27788
                                labelWidth: labelWidth,
27789
                                hidden: ishidden,
27790
                                name: rec.FieldName,
27791
                                msgTarget: 'side',
27792
                                format: 'Hi',
27793
                                submitFormat: 'Hi',
27794
                                increment: 5,
27795
                                value: rec.DefaultValue,
27796
                                anchor: '100%',
27797
                                formname: formname_,
27798
                                nameTable: nameTable_,
27799
                                listeners: {
27800
                                    change: function (val) {
27801
                                        var _label = val.name;
27802
                                        var _form = val.formname;
27803
                                        var _Value = val.getValue();
27804
                                        var target = rec.TriggerCombo;
27805
                                        var custumFunc = rec.SelectFunction;
27806
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27807
                                            Ext.Ajax.request({
27808
                                                async: false,
27809
                                                method: 'POST',
27810
                                                url: '/UserControl/GetStore',
27811
                                                params: {
27812
                                                    tableName: 'PCMFUNC',
27813
                                                    param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
27814
                                                },
27815
                                                success: function (response) {
27816
                                                    var results = Ext.decode(response.responseText);
27817
                                                    data_ = results.data[0];
27818
                                                    if (data_ != undefined) {
27819
                                                        custumFunc = data_.FunctionCode;
27820
                                                    }
27821
                                                }
27822
                                            });
27823
                                        }
27824
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27825
                                        if (frm) {
27826
                                            if (custumFunc) {
27827
                                                eval(custumFunc)
27828
                                            }
27829
                                        }
27830
                                    }
27831
                                }
27832
                            });
27833
                            break;
27834
                        case "amount":
27835
                            formfield = new Ext.form.TextField({
27836
                                allowBlank: allowblank,
27837
                                fieldLabel: rec.ScreenCaption,
27838
                                readOnly: readonly,
27839
                                //labelCls: 'label-minova',
27840
                                labelWidth: labelWidth,
27841
                                hidden: ishidden,
27842
                                name: rec.FieldName,
27843
                                msgTarget: 'side',
27844
                                value: rec.DefaultValue,
27845
                                maxLength: rec.Length,
27846
                                anchor: '100%',
27847
                                formname: formname_,
27848
                                nameTable: nameTable_,
27849
                                fieldStyle: 'text-align:right;',
27850
                                listeners: {
27851
                                    change: function (val) {
27852
                                        var _label = val.name;
27853
                                        var _form = val.formname;
27854
                                        var _Value = val.getValue();
27855
                                        var target = rec.TriggerCombo;
27856
                                        var custumFunc = rec.SelectFunction;
27857
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27858
                                            Ext.Ajax.request({
27859
                                                async: false,
27860
                                                method: 'POST',
27861
                                                url: '/UserControl/GetStore',
27862
                                                params: {
27863
                                                    tableName: 'PCMFUNC',
27864
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27865
                                                },
27866
                                                success: function (response) {
27867
                                                    var results = Ext.decode(response.responseText);
27868
                                                    data_ = results.data[0];
27869
                                                    if (data_ != undefined) {
27870
                                                        custumFunc = data_.FunctionCode;
27871
                                                    }
27872
                                                }
27873
                                            });
27874
                                        }
27875
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27876
                                        if (frm) {
27877
                                            if (custumFunc) {
27878
                                                eval(custumFunc)
27879
                                            }
27880
                                        }
27881
                                    }
27882
                                }
27883
                            });
27884
                            break;
27885
                        case "file":
27886
                            formfield = new MinovaUtil.MinovaES.UploadFile({
27887
                                allowBlank: allowblank,
27888
                                fieldLabel: rec.ScreenCaption,
27889
                                readOnly: readonly,
27890
                                readOnlyCls: 'minova-readonly',
27891
                                hidden: ishidden,
27892
                                //labelCls: 'label-minova',
27893
                                name: rec.FieldName,
27894
                                msgTarget: 'side',
27895
                                fieldname: rec.FieldName,
27896
                                IsPrimaryKey: rec.IsPrimaryKey,
27897
                                tableName: rec.TableRef,
27898
                                triggerCls: 'x-form-search-trigger',
27899
                                formtarget: me.formname,
27900
                                anchor: '100%',
27901
                                formname: formname_,
27902
                                nameTable: nameTable_,
27903
                                listeners: {
27904
                                    change: function (val) {
27905
                                        var _label = val.name;
27906
                                        var _form = val.formname;
27907
                                        var _Value = val.getValue();
27908
                                        var target = rec.TriggerCombo;
27909
                                        var custumFunc = rec.SelectFunction;
27910
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27911
                                            Ext.Ajax.request({
27912
                                                async: false,
27913
                                                method: 'POST',
27914
                                                url: '/UserControl/GetStore',
27915
                                                params: {
27916
                                                    tableName: 'PCMFUNC',
27917
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27918
                                                },
27919
                                                success: function (response) {
27920
                                                    var results = Ext.decode(response.responseText);
27921
                                                    data_ = results.data[0];
27922
                                                    if (data_ != undefined) {
27923
                                                        custumFunc = data_.FunctionCode;
27924
                                                    }
27925
                                                }
27926
                                            });
27927
                                        }
27928
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27929
                                        if (frm) {
27930
                                            if (target) {
27931
                                                var f = frm.getForm().findField(target)
27932
                                                _store = f.getStore();
27933
                                                var _tbl = _store.proxy.extraParams.tableName;
27934
                                                var oldParam = _store.proxy.extraParams.param;
27935
                                                _store.proxy.extraParams = {
27936
                                                    tableName: _tbl,
27937
                                                    param: _label + '[=]' + _Value
27938
                                                };
27939
                                                _store.load();
27940
                                            }
27941
                                            if (custumFunc) {
27942
                                                eval(custumFunc)
27943
                                            }
27944
                                        }
27945
                                    }
27946
                                }
27947
                            });
27948
                            break;
27949
                        default:
27950
                            if (rec.DataType == 0) {
27951
                                if (rec.Length > 250) {
27952
                                    formfield = new Ext.form.TextArea({
27953
                                        allowBlank: allowblank,
27954
                                        fieldLabel: rec.ScreenCaption,
27955
                                        readOnly: readonly,
27956
                                        labelAlign: me.labelAlign,
27957
                                        labelSeparator: me.labelSeparator,
27958
                                        //labelCls: 'label-minova',
27959
                                        labelWidth: labelWidth,
27960
                                        hidden: ishidden,
27961
                                        name: rec.FieldName,
27962
                                        msgTarget: 'side',
27963
                                        value: rec.DefaultValue,
27964
                                        maxLength: rec.Length,
27965
                                        anchor: '100%',
27966
                                        grow: true,
27967
                                        formname: formname_,
27968
                                        nameTable: nameTable_,
27969
                                        listeners: {
27970
                                            change: function (val) {
27971
                                                var _label = val.name;
27972
                                                var _form = val.formname;
27973
                                                var _Value = val.getValue();
27974
                                                var target = rec.TriggerCombo;
27975
                                                var custumFunc = rec.SelectFunction;
27976
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27977
                                                    Ext.Ajax.request({
27978
                                                        async: false,
27979
                                                        method: 'POST',
27980
                                                        url: '/UserControl/GetStore',
27981
                                                        params: {
27982
                                                            tableName: 'PCMFUNC',
27983
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27984
                                                        },
27985
                                                        success: function (response) {
27986
                                                            var results = Ext.decode(response.responseText);
27987
                                                            data_ = results.data[0];
27988
                                                            if (data_ != undefined) {
27989
                                                                custumFunc = data_.FunctionCode;
27990
                                                            }
27991
                                                        }
27992
                                                    });
27993
                                                }
27994
                                                var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27995
                                                if (frm) {
27996
                                                    if (custumFunc) {
27997
                                                        eval(custumFunc)
27998
                                                    }
27999
                                                }
28000
                                            }
28001
                                        }
28002
                                    });
28003
                                } else {
28004
                                    if (rec.FixedValue != '') {
28005
                                        var storeData = [];
28006
                                        var str = rec.FixedValue;
28007
                                        var hasil = str.split('||');
28008
                                        hasil.forEach(function (h) {
28009
                                            store_ = h.split('=')
28010
                                            storeData.push({
28011
                                                code: store_[0],
28012
                                                desc: store_[1],
28013
                                            });
28014
                                        });
28015
                                        formfield = new Ext.form.ComboBox({
28016
                                            allowBlank: allowblank,
28017
                                            fieldLabel: rec.ScreenCaption,
28018
                                            forceSelection: true,
28019
                                            readOnly: readonly,
28020
                                            //labelCls: 'label-minova',
28021
                                            labelWidth: labelWidth,
28022
                                            hidden: ishidden,
28023
                                            name: rec.FieldName,
28024
                                            msgTarget: 'side',
28025
                                            value: rec.DefaultValue,
28026
                                            anchor: '100%',
28027
                                            formname: formname_,
28028
                                            nameTable: nameTable_,
28029
                                            formtarget: me.formname,
28030
                                            store: Ext.create('Ext.data.Store', {
28031
                                                storeId: 'store' + rec.FieldName,
28032
                                                autoLoad: true,
28033
                                                data: storeData
28034

    
28035
                                            }),
28036
                                            listeners: {
28037
                                                change: function (val) {
28038
                                                    var _label = val.name;
28039
                                                    var _form = val.formtarget;
28040
                                                    var _Value = val.getValue();
28041
                                                    var target = rec.TriggerCombo;
28042
                                                    var custumFunc = rec.SelectFunction;
28043
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
28044
                                                    if (frm) {
28045
                                                        if (target) {
28046
                                                            var f = frm.getForm().findField(target)
28047
                                                            _store = f.getStore();
28048
                                                            var _tbl = _store.proxy.extraParams.tableName;
28049
                                                            var oldParam = _store.proxy.extraParams.param;
28050
                                                            _store.proxy.extraParams = {
28051
                                                                tableName: _tbl,
28052
                                                                param: _label + '[=]' + _Value
28053
                                                            };
28054
                                                            _store.load();
28055
                                                        }
28056
                                                        if (custumFunc) {
28057
                                                            eval(custumFunc)
28058
                                                        }
28059
                                                    }
28060
                                                }
28061
                                            },
28062
                                            queryMode: 'local',
28063
                                            valueField: 'code',
28064
                                            displayField: 'desc',
28065
                                        });
28066
                                    } else {
28067
                                        formfield = new Ext.form.TextField({
28068
                                            allowBlank: allowblank,
28069
                                            fieldLabel: rec.ScreenCaption,
28070
                                            readOnly: readonly,
28071
                                            //labelCls: 'label-minova',
28072
                                            labelWidth: labelWidth,
28073
                                            hidden: ishidden,
28074
                                            name: rec.FieldName,
28075
                                            msgTarget: 'side',
28076
                                            value: rec.DefaultValue,
28077
                                            maxLength: rec.Length,
28078
                                            anchor: '100%',
28079
                                            formname: formname_,
28080
                                            nameTable: nameTable_,
28081
                                            listeners: {
28082
                                                change: function (val) {
28083
                                                    var _label = val.name;
28084
                                                    var _form = val.formname;
28085
                                                    var _Value = val.getValue();
28086
                                                    var target = rec.TriggerCombo;
28087
                                                    var custumFunc = rec.SelectFunction;
28088
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28089
                                                        Ext.Ajax.request({
28090
                                                            async: false,
28091
                                                            method: 'POST',
28092
                                                            url: '/UserControl/GetStore',
28093
                                                            params: {
28094
                                                                tableName: 'PCMFUNC',
28095
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28096
                                                            },
28097
                                                            success: function (response) {
28098
                                                                var results = Ext.decode(response.responseText);
28099
                                                                data_ = results.data[0];
28100
                                                                if (data_ != undefined) {
28101
                                                                    custumFunc = data_.FunctionCode;
28102
                                                                }
28103
                                                            }
28104
                                                        });
28105
                                                    }
28106
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
28107
                                                    if (frm) {
28108
                                                        if (custumFunc) {
28109
                                                            eval(custumFunc)
28110
                                                        }
28111
                                                    }
28112
                                                }
28113
                                            }
28114
                                        });
28115
                                    }
28116
                                }
28117
                            } else if (rec.DataType == 1 || rec.DataType == 2) {
28118
                                formfield = new MinovaUtil.MinovaES.MinovaNumberField({
28119
                                    allowBlank: allowblank,
28120
                                    fieldLabel: rec.ScreenCaption,
28121
                                    readOnly: readonly,
28122
                                    //labelCls: 'label-minova',
28123
                                    labelWidth: labelWidth,
28124
                                    msgTarget: 'side',
28125
                                    hidden: ishidden,
28126
                                    name: rec.FieldName,
28127
                                    value: rec.DefaultValue,
28128
                                    maxLength: rec.Length,
28129
                                    anchor: '100%',
28130
                                    formname: formname_,
28131
                                    nameTable: nameTable_,
28132
                                    fieldStyle: 'text-align:right;',
28133
                                    listeners: {
28134
                                        change: function (val) {
28135
                                            var _label = val.name;
28136
                                            var _form = val.formname;
28137
                                            var _Value = val.getValue();
28138
                                            var target = rec.TriggerCombo;
28139
                                            var custumFunc = rec.SelectFunction;
28140
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28141
                                                Ext.Ajax.request({
28142
                                                    async: false,
28143
                                                    method: 'POST',
28144
                                                    url: '/UserControl/GetStore',
28145
                                                    params: {
28146
                                                        tableName: 'PCMFUNC',
28147
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28148
                                                    },
28149
                                                    success: function (response) {
28150
                                                        var results = Ext.decode(response.responseText);
28151
                                                        data_ = results.data[0];
28152
                                                        if (data_ != undefined) {
28153
                                                            custumFunc = data_.FunctionCode;
28154
                                                        }
28155
                                                    }
28156
                                                });
28157
                                            }
28158
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
28159
                                            if (frm) {
28160
                                                if (target) {
28161
                                                    var f = frm.getForm().findField(target)
28162
                                                    _store = f.getStore();
28163
                                                    var _tbl = _store.proxy.extraParams.tableName;
28164
                                                    var oldParam = _store.proxy.extraParams.param;
28165
                                                    _store.proxy.extraParams = {
28166
                                                        tableName: _tbl,
28167
                                                        param: _label + '[=]' + _Value
28168
                                                    };
28169
                                                    _store.load();
28170
                                                }
28171
                                                if (custumFunc) {
28172
                                                    eval(custumFunc)
28173
                                                }
28174
                                            }
28175
                                        }
28176
                                    }
28177
                                });
28178
                            } else if (rec.DataType == 3) {
28179
                                formfield = new Ext.form.TextField({
28180
                                    allowBlank: allowblank,
28181
                                    fieldLabel: rec.ScreenCaption,
28182
                                    readOnly: readonly,
28183
                                    //labelCls: 'label-minova',
28184
                                    labelWidth: labelWidth,
28185
                                    msgTarget: 'side',
28186
                                    hidden: ishidden,
28187
                                    name: rec.FieldName,
28188
                                    value: rec.DefaultValue,
28189
                                    maxLength: rec.Length,
28190
                                    precision: rec.Prec,
28191
                                    anchor: '100%',
28192
                                    formname: formname_,
28193
                                    nameTable: nameTable_,
28194
                                    fieldStyle: 'text-align:right;',
28195
                                    maskRe: '^[0-9]+(\.[0-9]{1,2})?$',
28196
                                    listeners: {
28197
                                        change: function (val) {
28198
                                            var _label = val.name;
28199
                                            var _form = val.formname;
28200
                                            var _Value = val.getValue();
28201
                                            var target = rec.TriggerCombo;
28202
                                            var custumFunc = rec.SelectFunction;
28203
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28204
                                                Ext.Ajax.request({
28205
                                                    async: false,
28206
                                                    method: 'POST',
28207
                                                    url: '/UserControl/GetStore',
28208
                                                    params: {
28209
                                                        tableName: 'PCMFUNC',
28210
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28211
                                                    },
28212
                                                    success: function (response) {
28213
                                                        var results = Ext.decode(response.responseText);
28214
                                                        data_ = results.data[0];
28215
                                                        if (data_ != undefined) {
28216
                                                            custumFunc = data_.FunctionCode;
28217
                                                        }
28218
                                                    }
28219
                                                });
28220
                                            }
28221
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
28222
                                            if (frm) {
28223
                                                if (target) {
28224
                                                    var f = frm.getForm().findField(target)
28225
                                                    _store = f.getStore();
28226
                                                    var _tbl = _store.proxy.extraParams.tableName;
28227
                                                    var oldParam = _store.proxy.extraParams.param;
28228
                                                    _store.proxy.extraParams = {
28229
                                                        tableName: _tbl,
28230
                                                        param: _label + '[=]' + _Value
28231
                                                    };
28232
                                                    _store.load();
28233
                                                }
28234
                                                if (custumFunc) {
28235
                                                    eval(custumFunc)
28236
                                                }
28237
                                            }
28238
                                        }
28239
                                    }
28240
                                });
28241
                            }
28242
                    }
28243
                } else if (rec.SearchType != "") {
28244
                    if (rec.SearchType == "0") //combobox
28245
                    {
28246
                        valueField = null;
28247
                        displayValue = null;
28248
                        if (rec.TableRef != "") {
28249
                            Ext.Ajax.request({
28250
                                async: false,
28251
                                method: 'POST',
28252
                                url: '/UserControl/GetStore',
28253
                                params: {
28254
                                    tableName: 'SDATATABLEFIELD',
28255
                                    param: 'TableName[equal]' + rec.TableRef
28256
                                },
28257
                                success: function (response) {
28258
                                    var results = Ext.decode(response.responseText);
28259
                                    data_ = results.data;
28260
                                    if (data_ != undefined) {
28261
                                        valueField_ = $.grep(data_, function (r) {
28262
                                            return r.ValueField == '1'
28263
                                        });
28264
                                        if (valueField_.length > 0) {
28265
                                            valueField = valueField_[0].FieldName
28266
                                        }
28267
                                        displayValue_ = $.grep(data_, function (r) {
28268
                                            return r.DisplayValue == '1'
28269
                                        });
28270
                                        if (displayValue_.length > 0) {
28271
                                            displayValue = displayValue_[0].FieldName
28272
                                        }
28273
                                    }
28274
                                }
28275
                            });
28276
                        }
28277
                        formfield = new Ext.form.ComboBox({
28278
                            allowBlank: allowblank,
28279
                            fieldLabel: rec.ScreenCaption,
28280
                            forceSelection: true,
28281
                            anyMatch: true,
28282
                            readOnly: readonly,
28283
							
28284
							//Start for mobile by saswanto
28285
							editable:readonly,
28286
							plugins: 'responsive',
28287
							responsiveConfig: {
28288
								personalizedWide:{}
28289
							},    
28290
							responsiveFormulas: {
28291
								personalizedWide: function (context,layout) {
28292
									if (context.width <= 600){
28293
										this.cmp.setEditable(false);
28294
										return true;
28295
									}
28296
								}
28297
							},							
28298
							//Start for mobile by saswanto
28299
							
28300
							
28301
                            //labelCls: 'label-minova',
28302
                            labelWidth: labelWidth,
28303
                            hidden: ishidden,
28304
                            msgTarget: 'side',
28305
                            name: rec.FieldName,
28306
                            formname: formname_,
28307
                            nameTable: nameTable_,
28308
                            value: rec.DefaultValue,
28309
                            anchor: '100%',
28310
                            store: Ext.create('Ext.data.Store', {
28311
                                storeId: 'store' + rec.FieldName,
28312
                                autoLoad: false,
28313
                                proxy: {
28314
                                    method: 'POST',
28315
                                    type: 'ajax',
28316
                                    url: '/UserControl/GetStore',
28317
                                    extraParams: {
28318
                                        tableName: rec.TableRef,
28319
                                        param: rec.ParamCombo
28320
                                    },
28321
                                    reader: {
28322
                                        type: 'json',
28323
                                        root: 'data',
28324
                                        totalProperty: 'data[0].TotalCount'
28325
                                    }
28326
                                }
28327
                            }),                            
28328
                            formtarget: formname_,
28329
                            listeners: {
28330
                                afterrender: function (f) {
28331
                                    var store_ = f.getStore();
28332
                                    store_.load();
28333
                                },
28334
                                change: function (val) {
28335
                                    var _label = val.name;
28336
                                    var _form = val.formtarget;
28337
                                    var _Value = val.getValue();
28338
                                    var target = rec.TriggerCombo;
28339
                                    var custumFunc = rec.SelectFunction;
28340
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
28341
                                    if (frm) {
28342

    
28343
                                        if (target) {
28344
                                            var f = frm.getForm().findField(target)
28345
                                            _store = f.getStore();
28346
                                            var _tbl = _store.proxy.extraParams.tableName;
28347
                                            var oldParam = _store.proxy.extraParams.param;
28348
                                            _store.proxy.extraParams = {
28349
                                                tableName: _tbl,
28350
                                                param: _label + '[=]' + _Value
28351
                                            };
28352
                                            _store.load();
28353
                                        }
28354
                                        if (custumFunc) {
28355
                                            eval(custumFunc)
28356
                                        }
28357
                                    }
28358
                                }
28359
                            },
28360
                            queryMode: 'local',
28361
                            displayField: displayValue,
28362
                            valueField: valueField,
28363
                        });
28364
                    } 
28365
					
28366
					else if (rec.SearchType == "6") {
28367
    var valueField = null;
28368
    var displayValue = null;
28369
    var TableRef = undefined;
28370

    
28371
    if (rec.TableRef != '') {
28372
        TableRef = rec.TableRef;
28373
        Ext.Ajax.request({
28374
            async: false,
28375
            method: 'POST',
28376
            url: '/UserControl/GetStore',
28377
            params: {
28378
                tableName: 'SDATATABLEFIELD',
28379
                param: 'TableName[equal]' + rec.TableRef
28380
            },
28381
            success: function (response) {
28382
                var results = Ext.decode(response.responseText);
28383
                var data_ = results.data;
28384
                if (data_ != undefined) {
28385
                    var valueField_ = $.grep(data_, function (r) {
28386
                        return r.ValueField == '1';
28387
                    });
28388
                    if (valueField_.length > 0) {
28389
                        valueField = valueField_[0].FieldName;
28390
                    }
28391

    
28392
                    var displayValue_ = $.grep(data_, function (r) {
28393
                        return r.DisplayValue == '1';
28394
                    });
28395
                    if (displayValue_.length > 0) {
28396
                        displayValue = displayValue_[0].FieldName;
28397
                    }
28398
                }
28399
            }
28400
        });
28401
    }
28402

    
28403
    var store = Ext.create('Ext.data.Store', {
28404
        storeId: 'store_' + me.tableName + rec.FieldName,
28405
        autoLoad: true,
28406
        proxy: {
28407
            method: 'POST',
28408
            type: 'ajax',
28409
            url: '/UserControl/GetStoreAuth',
28410
            extraParams: {
28411
                tableName: TableRef,
28412
                param: rec.ParamCombo,
28413
                menuId: MinovaUtil.GetMenuID()
28414
            },
28415
            reader: {
28416
                type: 'json',
28417
                root: 'data',
28418
                totalProperty: 'data[0].TotalCount'
28419
            }
28420
        }
28421
    });
28422

    
28423
    var formfield = Ext.create('Ext.form.ComboBox', {
28424
        allowBlank: allowblank,
28425
        fieldLabel: rec.ScreenCaption,
28426
        forceSelection: true,
28427
        readOnly: readonly,
28428
        editable: true,
28429
        plugins: 'responsive',
28430
        responsiveConfig: {
28431
            personalizedWide: {}
28432
        },
28433
        responsiveFormulas: {
28434
            personalizedWide: function (context, layout) {
28435
                if (context.width <= 600) {
28436
                    this.cmp.setEditable(false);
28437
                    return true;
28438
                }
28439
            }
28440
        },
28441
        labelWidth: labelWidth,
28442
        hidden: ishidden,
28443
        msgTarget: 'side',
28444
        name: rec.FieldName,
28445
        formname: formname_,
28446
        nameTable: nameTable_,
28447
        value: rec.DefaultValue,
28448
        anchor: '100%',
28449
        store: store,
28450
        formtarget: formname_,
28451
        queryMode: 'remote',
28452
        displayField: displayValue,
28453
        valueField: valueField,
28454
        minChars: 1,
28455
        typeAhead: true,
28456
        typeAheadDelay: 300,
28457
        listConfig: {
28458
            itemTpl: '{' + displayValue + '}'
28459
        },
28460
        doQuery: function(queryString, forceAll) {
28461
            this.expand();
28462
            this.store.clearFilter();
28463
            if (!forceAll) {
28464
                var matcher = new RegExp(Ext.String.escapeRegex(queryString), 'i');
28465
                this.store.filterBy(function(record) {
28466
                    return matcher.test(record.get(displayValue));
28467
                });
28468
            }
28469
        },
28470
        listeners: {
28471
            change: function(val) {
28472
                var fvalue = val.getValue();
28473
                var custumFunc = rec.SelectFunction;
28474
                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28475
                    Ext.Ajax.request({
28476
                        async: false,
28477
                        method: 'POST',
28478
                        url: '/UserControl/GetStore',
28479
                        params: {
28480
                            tableName: 'PCMFUNC',
28481
                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
28482
                        },
28483
                        success: function (response) {
28484
                            var results = Ext.decode(response.responseText);
28485
                            var dt = results.data[0];
28486
                            if (dt != undefined) {
28487
                                custumFunc = dt.FunctionCode;
28488
                            }
28489
                        }
28490
                    });
28491
                }
28492
                if (custumFunc) {
28493
                    eval(custumFunc);
28494
                }
28495
            }
28496
        }
28497
    });
28498

    
28499
    // Assuming you are adding this to a form or panel
28500
    var form = Ext.ComponentQuery.query('form[name=' + formname_ + ']')[0];
28501
    if (form) {
28502
        form.add(formfield);
28503
    }
28504
}
28505

    
28506

    
28507

    
28508
					else if (rec.SearchType == '2') //Lookup
28509
                    {
28510
                        formfield = new MinovaUtil.MinovaES.MinovaLookupGrid({
28511
                            allowBlank: allowblank,
28512
                            fieldLabel: rec.ScreenCaption,
28513
                            readOnly: readonly,
28514
                            IsPrimaryKey: rec.IsPrimaryKey,
28515
                            msgTarget: 'side',
28516
                            //labelCls: 'label-minova',
28517
                            labelWidth: labelWidth,
28518
                            hidden: ishidden,
28519
                            name: rec.FieldName,
28520
                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
28521
                            triggerCls: 'x-form-search-trigger',
28522
                            vtype: 'alphanum', // disable space
28523
                            formtarget: me.formname, // nama form  yang akan di set value-nya
28524
                            anchor: '100%',
28525
                            formname: formname_,
28526
                            nameTable: nameTable_,
28527
                            LookupFunction: rec.LookupFunction,
28528
                            SearchFunction: rec.SearchFunction,
28529
                            listeners: {
28530
                                change: function (val) {
28531
                                    var _label = val.name;
28532
                                    var _form = val.formname;
28533
                                    var _Value = val.getValue();
28534
                                    var target = rec.TriggerCombo;
28535
                                    var custumFunc = rec.SelectFunction;
28536
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28537
                                        Ext.Ajax.request({
28538
                                            async: false,
28539
                                            method: 'POST',
28540
                                            url: '/UserControl/GetStore',
28541
                                            params: {
28542
                                                tableName: 'PCMFUNC',
28543
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28544
                                            },
28545
                                            success: function (response) {
28546
                                                var results = Ext.decode(response.responseText);
28547
                                                data_ = results.data[0];
28548
                                                if (data_ != undefined) {
28549
                                                    custumFunc = data_.FunctionCode;
28550
                                                }
28551
                                            }
28552
                                        });
28553
                                    }
28554
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
28555
                                    if (frm) {
28556

    
28557
                                        if (target) {
28558
                                            var f = frm.getForm().findField(target)
28559
                                            _store = f.getStore();
28560
                                            var _tbl = _store.proxy.extraParams.tableName;
28561
                                            var oldParam = _store.proxy.extraParams.param;
28562
                                            _store.proxy.extraParams = {
28563
                                                tableName: _tbl,
28564
                                                param: _label + '[=]' + _Value
28565
                                            };
28566
                                            _store.load();
28567
                                        }
28568

    
28569
                                        if (custumFunc) {
28570
                                            eval(custumFunc)
28571
                                        }
28572

    
28573
                                    }
28574

    
28575
                                },
28576

    
28577
                            },
28578
                        });
28579
                    } else if (rec.SearchType == '3') //lookup tree
28580
                    {
28581
                        formfield = new MinovaUtil.MinovaES.MinovaLookupTree({
28582
                            allowBlank: allowblank,
28583
                            fieldLabel: rec.ScreenCaption,
28584
                            readOnly: readonly,
28585
                            IsPrimaryKey: rec.IsPrimaryKey,
28586
                            //labelCls: 'label-minova',
28587
                            labelWidth: labelWidth,
28588
                            hidden: ishidden,
28589
                            name: rec.FieldName,
28590
                            msgTarget: 'side',
28591
                            triggerCls: 'x-form-search-trigger',
28592
                            treeSructure: rec.SearchFunction, //'O-O-P',
28593
                            objClassValue: rec.ParamCombo, //'O',
28594
                            formname: formname_,
28595
                            targetField: rec.FieldName,
28596
                            nameTable: nameTable_,
28597
                            editable: false,
28598
                            anchor: '100%',
28599
                            listeners: {
28600
                                change3: function (val) {
28601
                                    var _label = val.name;
28602
                                    var _form = val.formname;
28603
                                    var _Value = val.getValue();
28604
                                    var target = rec.TriggerCombo;
28605
                                    var custumFunc = rec.SelectFunction;
28606
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28607
                                        Ext.Ajax.request({
28608
                                            async: false,
28609
                                            method: 'POST',
28610
                                            url: '/UserControl/GetStore',
28611
                                            params: {
28612
                                                tableName: 'PCMFUNC',
28613
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28614
                                            },
28615
                                            success: function (response) {
28616
                                                var results = Ext.decode(response.responseText);
28617
                                                data_ = results.data[0];
28618
                                                if (data_ != undefined) {
28619
                                                    custumFunc = data_.FunctionCode;
28620
                                                }
28621
                                            }
28622
                                        });
28623
                                    }
28624
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
28625
                                    if (frm) {
28626

    
28627
                                        if (target) {
28628
                                            var f = frm.getForm().findField(target)
28629
                                            _store = f.getStore();
28630
                                            var _tbl = _store.proxy.extraParams.tableName;
28631
                                            var oldParam = _store.proxy.extraParams.param;
28632
                                            _store.proxy.extraParams = {
28633
                                                tableName: _tbl,
28634
                                                param: _label + '[=]' + _Value
28635
                                            };
28636
                                            _store.load();
28637
                                        }
28638
                                        if (custumFunc) {
28639
                                            eval(custumFunc)
28640
                                        }
28641
                                    }
28642
                                },
28643
                                blur: function (val) {
28644
                                    //if(val.value.split('-').length != 2){
28645
                                    var _label = val.name;
28646
                                    var _form = val.formname;
28647
                                    var _Value = val.getValue();
28648
                                    var target = rec.TriggerCombo;
28649
                                    var custumFunc = rec.SelectFunction;
28650
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28651
                                        Ext.Ajax.request({
28652
                                            async: false,
28653
                                            method: 'POST',
28654
                                            url: '/UserControl/GetStore',
28655
                                            params: {
28656
                                                tableName: 'PCMFUNC',
28657
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28658
                                            },
28659
                                            success: function (response) {
28660
                                                var results = Ext.decode(response.responseText);
28661
                                                data_ = results.data[0];
28662
                                                if (data_ != undefined) {
28663
                                                    custumFunc = data_.FunctionCode;
28664
                                                }
28665
                                            }
28666
                                        });
28667
                                    }
28668
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
28669
                                    if (frm) {
28670

    
28671
                                        if (target) {
28672
                                            var f = frm.getForm().findField(target)
28673
                                            _store = f.getStore();
28674
                                            var _tbl = _store.proxy.extraParams.tableName;
28675
                                            var oldParam = _store.proxy.extraParams.param;
28676
                                            _store.proxy.extraParams = {
28677
                                                tableName: _tbl,
28678
                                                param: _label + '[=]' + _Value
28679
                                            };
28680
                                            _store.load();
28681
                                        }
28682
                                        if (custumFunc) {
28683
                                            eval(custumFunc)
28684
                                        }
28685
                                    }
28686
                                    //}
28687
                                }
28688

    
28689
                            }
28690
                        });
28691
                    } else if (rec.SearchType == '10') //Checkboxgroup
28692
                    {
28693
                        if (rec.TableRef != "") {
28694
                            Ext.Ajax.request({
28695
                                async: false,
28696
                                method: 'POST',
28697
                                url: '/UserControl/GetStore',
28698
                                params: {
28699
                                    tableName: 'SDATATABLEFIELD',
28700
                                    param: 'TableName[equal]' + rec.TableRef
28701
                                },
28702
                                success: function (response) {
28703
                                    var results = Ext.decode(response.responseText);
28704
                                    data_ = results.data;
28705
                                    if (data_ != undefined) {
28706
                                        valueField_ = $.grep(data_, function (r) {
28707
                                            return r.ValueField == '1'
28708
                                        });
28709
                                        if (valueField_.length > 0) {
28710
                                            valueField = valueField_[0].FieldName
28711
                                        }
28712
                                        displayValue_ = $.grep(data_, function (r) {
28713
                                            return r.DisplayValue == '1'
28714
                                        });
28715
                                        if (displayValue_.length > 0) {
28716
                                            displayValue = displayValue_[0].FieldName
28717
                                        }
28718
                                    }
28719
                                }
28720
                            });
28721
                        }
28722
                        formfield = new MinovaUtil.MinovaES.StoreCheckboxGroup({
28723
                            //xtype: 'storecheckboxgroup',
28724
                            //allowBlank: allowblank,
28725
                            name: 'cbg' + rec.FieldName,
28726
                            nametxt: rec.FieldName,
28727
                            formname: formname_,
28728
                            nameTable: nameTable_,
28729
                            value: rec.DefaultValue,
28730
                            fieldLabel: rec.ScreenCaption,
28731
                            labelAlign: me.labelAlign,
28732
                            labelSeparator: me.labelSeparator,
28733
                            readOnly: readonly,
28734
                            //forceSelection: true,
28735
                            //anyMatch: true,
28736
                            //readOnly: readonly,
28737
                            ////labelCls: 'label-minova',
28738
                            labelWidth: labelWidth,
28739
                            //hidden: ishidden,
28740
                            //msgTarget: 'side',
28741
                            //name: rec.FieldName,
28742
                            //formname: formname_,
28743
                            //nameTable: nameTable_,
28744
                            //value: rec.DefaultValue,
28745
                            //width: '95%',
28746
                            store: Ext.create('Ext.data.Store', {
28747
                                storeId: 'store' + rec.FieldName,
28748
                                autoLoad: true,
28749
                                proxy: {
28750
                                    method: 'POST',
28751
                                    type: 'ajax',
28752
                                    url: '/UserControl/GetStore',
28753
                                    extraParams: {
28754
                                        tableName: rec.TableRef,
28755
                                        param: rec.ParamCombo
28756
                                    },
28757
                                    reader: {
28758
                                        type: 'json',
28759
                                        root: 'data',
28760
                                        totalProperty: 'data[0].TotalCount'
28761
                                    }
28762
                                }
28763
                            }),
28764
                            //formtarget: formname_,
28765
                            columns: 2,
28766
                            vertical: true,
28767
                            mapFn: function (storeItem) {
28768
                                var txfield = Ext.ComponentQuery.query('[name=' + rec.FieldName + '_TX_' + storeItem.data.ProblemCode + ']')[0];
28769
                                var txvalue = '';
28770
                                if (txfield) txvalue = txfield.value;
28771
                                var cbfield = Ext.ComponentQuery.query('[name=' + rec.FieldName + '_CB_' + storeItem.data.ProblemCode + ']')[0];
28772
                                var cbchecked = false;
28773
                                if (cbfield) cbchecked = (cbfield.value === 'true');
28774
                                return {
28775
                                    // Here, we define which store fields map 
28776
                                    // to which checkbox configuration property.
28777
                                    // The field "label" should map to boxLabel
28778
                                    // The field "value" should map to inputValue
28779
                                    // xtype and name are hardcoded for all checkboxes in this group.
28780
                                    xtype: 'container',
28781
                                    items: [
28782
                                        {
28783
                                            xtype: 'checkbox',
28784
                                            boxLabel: storeItem.data.ProblemDesc,
28785
                                            name: 'cb_' + rec.FieldName + '_CB_' + storeItem.data.ProblemCode,
28786
                                            nametxt: rec.FieldName + '_CB_' + storeItem.data.ProblemCode,
28787
                                            formname: formname_,
28788
                                            nameTable: nameTable_,
28789
                                            readOnly: readonly,
28790
                                            isshowtext: storeItem.data.IsShowText,
28791
                                            inputValue: storeItem.data.ProblemCode,
28792
                                            checked: cbchecked,
28793
                                            listeners: {
28794
                                                click: {
28795
                                                    element: 'el', //bind to the underlying el property on the panel
28796
                                                    fn: function (id) {
28797
                                                        var MyComp = Ext.getCmp(this.id);
28798
                                                        var frmForm = Ext.ComponentQuery.query('[name=tx_' + this.el.component.nametxt.replace("_CB_", "_TX_") + ']')[0];
28799
                                                        if (this.el.component.isshowtext == '1') {
28800
                                                            frmForm.setHidden(!MyComp.checked);
28801
                                                            frmForm.setValue('');
28802
                                                        }
28803
                                                        var cb_ = Ext.ComponentQuery.query('[name=' + this.el.component.nametxt + ']')[0];
28804
                                                        cb_.setValue(MyComp.checked);
28805
                                                    }
28806
                                                },
28807
                                                //change: function (val) {
28808
                                                //    alert('ok');
28809
                                                //},
28810
                                            }
28811
                                        }, {
28812
                                            xtype: 'textareafield',
28813
                                            name: 'tx_' + rec.FieldName + '_TX_' + storeItem.data.ProblemCode,
28814
                                            nametxt: rec.FieldName + '_TX_' + storeItem.data.ProblemCode,
28815
                                            formname: formname_,
28816
                                            nameTable: nameTable_,
28817
                                            readOnly: readonly,
28818
                                            width: '100%',
28819
                                            value: txvalue,
28820
                                            hidden: !((storeItem.data.IsShowText === '1') && (cbchecked)),
28821
                                            listeners: {
28822
                                                change: function (id, newValue, oldValue, eOpts) {
28823
                                                    var frmForm = Ext.ComponentQuery.query('[name=' + id.nametxt + ']')[0];
28824
                                                    frmForm.setValue(newValue);
28825
                                                },
28826
                                            }
28827
                                        }]
28828
                                };
28829
                            }
28830
                        });
28831
                    } else if (rec.SearchType == '11') //Checkbox
28832
                    {
28833
                        formfield = new Ext.Container({
28834
                            items: [
28835
                                {
28836
                                    xtype: 'checkbox',
28837
                                    boxLabel: rec.ScreenCaption,
28838
                                    name: 'cb_' + rec.FieldName,
28839
                                    nametxt: rec.FieldName,
28840
                                    hidden: ishidden,
28841
                                    readOnly: readonly,
28842
                                    tableName: rec.TableRef, //name tabel yang jadi ref-nya
28843
                                    checked: (rec.DefaultValue.toUpperCase() === 'TRUE'),
28844
                                    listeners: {
28845
                                        click: {
28846
                                            element: 'el', //bind to the underlying el property on the panel
28847
                                            fn: function (id) {
28848
                                                var MyComp = Ext.getCmp(this.id);
28849
                                                var frmForm = Ext.ComponentQuery.query('[name=' + this.el.component.nametxt + ']')[0];
28850
                                                frmForm.setValue(MyComp.checked);
28851
                                            }
28852
                                        }
28853
                                    }
28854
                                },
28855
                                {
28856
                                    xtype: 'textfield',
28857
                                    name: rec.FieldName,
28858
                                    namecb: 'cb_' + rec.FieldName,
28859
                                    formname: formname_,
28860
                                    nameTable: nameTable_,
28861
                                    readOnly: readonly,
28862
                                    value: rec.DefaultValue,
28863
                                    hidden: true,
28864
                                    listeners: {
28865
                                        change: function (id, newValue, oldValue, eOpts) {
28866
                                            var cbfield = Ext.ComponentQuery.query('[name=' + id.namecb + ']')[0];
28867
                                            var cbchecked = false;
28868
                                            if (cbfield) cbchecked = (newValue === 'true');
28869
                                            cbfield.setValue(cbchecked);
28870
                                        },
28871
                                    }
28872
                                }]
28873
                            
28874
                        })
28875
                        //formfield = new Ext.form.field.Checkbox({
28876
                        //    boxLabel: rec.ScreenCaption,
28877
                        //    name: rec.FieldName,
28878
                        //    name: 'cb_' + rec.FieldName,
28879
                        //    nametxt: rec.FieldName,
28880
                        //    hidden: ishidden,
28881
                        //    readOnly: readonly,
28882
                        //    name: rec.FieldName,
28883
                        //    tableName: rec.TableRef, //name tabel yang jadi ref-nya
28884
                        //    checked: (rec.DefaultValue.toUpperCase() === 'TRUE'),
28885
                        //    listeners: {
28886
                        //        click: {
28887
                        //            element: 'el', //bind to the underlying el property on the panel
28888
                        //            fn: function (id) {
28889
                        //                var MyComp = Ext.getCmp(this.id);
28890
                        //                var cb_ = Ext.ComponentQuery.query('[name=' + this.el.component.nametxt + ']')[0];
28891
                        //                cb_.setValue(MyComp.checked);
28892
                        //            }
28893
                        //        }
28894
                        //    }
28895
                        //    //value: rec.DefaultValue,
28896
                        //})
28897
                    }
28898
                }
28899
                if (isDesk) {
28900
                    if (rec.ColumnNo == 1) {
28901
                        col1.push(formfield);
28902
                    } else {
28903
                        col2.push(formfield);
28904
                    }
28905
                } else {
28906
                    col1.push(formfield);
28907
                }
28908

    
28909
            });
28910
        }
28911
        Ext.applyIf(me, {
28912
            items:
28913
                [
28914
                    {
28915
                        //width: 450,
28916
                        //style: 'width: 50%',
28917
                        defaults: {
28918
                            layout: 'anchor',
28919
                            xtype: 'container',
28920
                            flex: 1,
28921
                            margin: me.marginDefault,
28922
                            //defaultType: 'textfield',
28923
                            //anchor: '100%',
28924
                            ////style: 'width: 50%',
28925
                        },
28926
                        items: col1,
28927
                        flex: 1,
28928
                    },
28929
                    {
28930
                        //width: 450,
28931
                        //style: 'width: 50%',
28932
                        defaults: {
28933
                            layout: 'anchor',
28934
                            xtype: 'container',
28935
                            flex: 1,
28936
                            margin: me.marginDefault,
28937
                            //defaultType: 'textfield',
28938
                            //anchor: '100%',
28939
                            ////style: 'width: 50%',
28940
                        },
28941
                        items: col2,
28942
                        flex: 1,
28943
                    }
28944
                ]
28945
        });
28946
        this.callParent();
28947
    }
28948
});
28949

    
28950
/*EditableGrid ESS Generator YN 20211216 */
28951
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowEditableGrid2', {
28952
    extend: 'Ext.form.Panel',
28953
    alias: ['widget.minovaworkfloweditablegrid2', 'widget.workfloweditablegrid2'],
28954
    requires: [
28955
        'Ext.grid.plugin.CellEditing',
28956
        'Ext.grid.RowNumberer',
28957
        'Ext.grid.Panel',
28958
    ],
28959
    cls: 'grid-ess',
28960
    anchor: '100%',
28961
    tableName: undefined,
28962
    hideButton: undefined,
28963
    multiSelect: undefined,
28964
    formname: this.name,
28965
    bizprocid: undefined,
28966
    bizflowid: undefined,
28967
    taskid: undefined,
28968
    features: undefined,
28969
    minHeight: undefined,
28970
    maxHeight: undefined,
28971
    headerLayout: undefined,
28972
    summaryType: undefined,
28973
    initComponent: function () {
28974
        var me = this;
28975
        var isLookup = me.isLookup;
28976
        var hide_ = false;
28977
        var widthLock = 250;
28978
        var checkSelection = '';
28979
        if (me.hideButton == true) {
28980
            hide_ = true;
28981
        }
28982
        if (me.multiSelect) {
28983
            locking = false;
28984
            checkSelection = 'checkboxmodel';
28985
            widthLock = 40;
28986
        }
28987
        var tableName = me.tableName;
28988
        var features = me.features;
28989
        var cols = [];
28990
        var fieldStore = [];
28991
        var _url = 'GetAllField';
28992
        var hasil = null;
28993
        var height = me.height;
28994
        var storeID = 'store' + me.tableName;
28995
        var gridName = 'grid' + me.name;
28996
        if (me.storeName) {
28997
            storeID = me.storeName;
28998
        }
28999
        var LangID = MinovaUtil.GetLangID();
29000
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
29001
        Ext.Ajax.request({
29002
            async: false,
29003
            method: 'POST',
29004
            url: '/UserControl/GetStore',
29005
            params: {
29006
                tableName: 'PDSWFSTRUCTUREFIELD',
29007
                param: parameter
29008
            },
29009
            success: function (response) {
29010
                var results = Ext.decode(response.responseText);
29011
                hasil = results.data;
29012
            }
29013
        });
29014
        cols.push({
29015
            xtype: 'rownumberer'
29016
        });
29017
        var addData = 'var data={';
29018
        if (hasil.length > 0) {
29019
            Ext.each(hasil, function (rec) {
29020
                fieldStore.push(rec.FieldName);
29021
                if (rec.FieldName != 'Sequence') {
29022
                    addData = addData + rec.FieldName + ":" + "'',";
29023
                }
29024
                var null_ = null;
29025
                var ReadOnly_ = false;
29026
                if (rec.IsRequired == '1') {
29027
                    null_ = false;
29028
                } else {
29029
                    null_ = true;
29030
                }
29031
                var Hidden_ = false;
29032
                if (rec.IsReadOnly == '1') {
29033
                    ReadOnly_ = true;
29034
                }
29035
                if (rec.IsVisible == '1') {
29036
                    switch (rec.FormatRef) {
29037
                        case "date":
29038
                            cols.push({
29039
                                xtype: 'minovadatecolumn',
29040
                                hidden: Hidden_,
29041
                                text: rec.HeaderTitle,
29042
                                dataIndex: rec.FieldName,
29043
                                filter: {
29044
                                    itemDefaults: {
29045
                                        emptyText: 'Search for...',
29046
                                    }
29047
                                },
29048
                                editor: {
29049
                                    allowBlank: null_,
29050
                                    xtype: 'datefield',
29051
                                    hideMode: 'visibility',
29052
                                    readOnly: ReadOnly_,
29053
                                    id: tableName + rec.FieldName,
29054
                                    fieldGrid: rec.FieldName,
29055
                                    nameTable: rec.TableName,
29056
                                    value: rec.DefaultValue
29057
                                }
29058
                            });
29059
                            break
29060
                        case "amount":
29061
                            cols.push({
29062
                                xtype: 'minovacurrancycolumn',
29063
                                align: 'right',
29064
                                text: rec.HeaderTitle,
29065
                                dataIndex: rec.FieldName,
29066
                                hidden: Hidden_,
29067
                                filter: {
29068
                                    itemDefaults: {
29069
                                        emptyText: 'Search for...'
29070
                                    }
29071
                                },
29072
                                editor: {
29073
                                    allowBlank: null_,
29074
                                    xtype: 'minovacurrencyfield',
29075
                                    readOnly: ReadOnly_,
29076
                                    id: tableName + rec.FieldName,
29077
                                    nameTable: rec.TableName,
29078
                                    fieldGrid: rec.FieldName,
29079
                                    fieldStyle: 'text-align:right;',
29080
                                    value: '0',
29081
                                    maxLength: rec.Length,
29082
                                }
29083
                            });
29084
                            break
29085
                        default:
29086
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
29087
                                cols.push({
29088
                                    text: rec.HeaderTitle,
29089
                                    dataIndex: rec.FieldName,
29090
                                    width: 100,
29091
                                    filter: {
29092
                                        type: 'string',
29093
                                        itemDefaults: {
29094
                                            emptyText: 'Search for...'
29095
                                        }
29096
                                    }
29097
                                });
29098
                            } else if (rec.SearchType == '0') { 
29099
                                var valueField = null;
29100
                                var displayValue = null;
29101
                                var TableRef = undefined;
29102
                                if (rec.TableRef != '') {
29103
                                    TableRef = rec.TableRef;
29104
                                    Ext.Ajax.request({
29105
                                        async: false,
29106
                                        method: 'POST',
29107
                                        url: '/UserControl/GetStore',
29108
                                        params: {
29109
                                            tableName: 'SDATATABLEFIELD',
29110
                                            param: 'TableName[equal]' + rec.TableRef
29111
                                        },
29112
                                        success: function (response) {
29113
                                            var results = Ext.decode(response.responseText);
29114
                                            data_ = results.data;
29115
                                            if (data_ != undefined) {
29116
                                                valueField_ = $.grep(data_, function (r) {
29117
                                                    return r.ValueField == '1'
29118
                                                });
29119
                                                valueField = valueField_[0].FieldName
29120
                                                displayValue_ = $.grep(data_, function (r) {
29121
                                                    return r.DisplayValue == '1'
29122
                                                });
29123
                                                displayValue = displayValue_[0].FieldName
29124
                                            }
29125
                                        }
29126
                                    });
29127
                                }
29128
                                Ext.create('Ext.data.Store', {
29129
                                    storeId: 'store_' + me.tableName + rec.FieldName,
29130
                                    autoLoad: true,
29131
                                    proxy: {
29132
                                        method: 'POST',
29133
                                        type: 'ajax',
29134
                                        url: '/UserControl/GetStoreAuth',
29135
                                        extraParams: {
29136
                                            tableName: TableRef,
29137
                                            param: rec.ParamCombo,
29138
                                            menuId: MinovaUtil.GetMenuID()
29139
                                        },
29140
                                        reader: {
29141
                                            type: 'json',
29142
                                            root: 'data',
29143
                                            totalProperty: 'data[0].TotalCount'
29144
                                        }
29145
                                    }
29146
                                });
29147
                                cols.push({
29148
                                    //xtype : 'minovacombocolumn',
29149
                                    hidden: Hidden_,
29150
                                    text: rec.HeaderTitle,
29151
                                    dataIndex: rec.FieldName,
29152
                                    width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
29153
                                    summaryType: function (records) {
29154
                                        var suma = 0;
29155
                                        if (me.summaryType == 'average') {
29156
                                            // Sumar en la columna solo las lineas que estan marcadas para ser sumadas a los totales
29157
                                            Ext.each(records, function (record, index) {
29158
                                                if (record.get(rec.FieldName)) {
29159
                                                    suma = suma + parseFloat(record.get(rec.FieldName).replace(",", "."));
29160
                                                }
29161
                                            });
29162
                                            (records.length == 0) ? suma = 0 : suma = suma / records.length;
29163
                                        }
29164
                                        else if (me.summaryType == 'sum') {
29165
                                            // Sumar en la columna solo las lineas que estan marcadas para ser sumadas a los totales
29166
                                            Ext.each(records, function (record, index) {
29167
                                                if (record.get(rec.FieldName)) {
29168
                                                    suma = suma + parseFloat(record.get(rec.FieldName).replace(",", "."));
29169
                                                }
29170
                                            });
29171
                                        }
29172
                                        return suma;
29173
                                    },
29174
                                    //valueField : valueField,
29175
                                    //displayField : displayValue,
29176
                                    //store : 'store_' + me.tableName + rec.FieldName,
29177
                                    editor: {
29178
                                        allowBlank: null_,
29179
                                        xtype: 'minovacombobox',
29180
                                        readOnly: ReadOnly_,
29181
                                        id: rec.TableName + rec.FieldName,
29182
                                        nameTable: rec.TableName,
29183
                                        fieldGrid: rec.FieldName,
29184
                                        valueField: valueField,
29185
                                        displayField: displayValue,
29186
                                        store: 'store_' + me.tableName + rec.FieldName,
29187
                                        value: rec.DefaultValue,
29188
										formtarget: me.name,
29189
										listeners: {
29190
											blur: function (val) {
29191
												var _label = val.valueField; //YN 220616
29192
												var _form = val.formtarget;
29193
												var _Value = val.getValue();
29194
												var target = rec.TriggerCombo;
29195
												var custumFunc = rec.SelectFunction;
29196
												var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
29197
												if (frm) {
29198

    
29199
													if (target) {
29200
														//var f = frm.getForm().findField(target)
29201
														//_store = f.getStore();
29202
														var _store = Ext.data.StoreManager.lookup('store_' + me.tableName + target);
29203
														var _tbl = _store.proxy.extraParams.tableName;
29204
														var oldParam = _store.proxy.extraParams.param;
29205
														_store.proxy.extraParams = {
29206
															tableName: _tbl,
29207
															param: _label + '[=]' + _Value
29208
														};
29209
														_store.load();
29210
													}
29211
													if (custumFunc) {
29212
														eval(custumFunc)
29213
													}
29214
												}
29215
											}
29216
										}
29217
                                    },
29218
                                    renderer: function (value) {
29219
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
29220
                                        var index = store.find(valueField, value);
29221
                                        var val = "";
29222
                                        if (index != -1) {
29223
                                            var rc = store.getAt(index);
29224
                                            val = rc.get(displayValue);
29225
                                        } else {
29226
                                            val = value;
29227
                                        }
29228
                                        return val;
29229
                                    },
29230
                                    filter: {
29231
                                        type: 'list',
29232
                                        itemDefaults: {
29233
                                            emptyText: 'Search for...'
29234
                                        }
29235
                                    }
29236
                                });
29237
                            } else if (rec.SearchType == '5') {
29238
                                var valueField = null;
29239
                                var displayValue = null;
29240
                                var AdditionaldisplayValue = null;
29241
                                var TableRef = undefined;
29242
                                if (rec.TableRef != '') {
29243
                                    TableRef = rec.TableRef;
29244
                                    Ext.Ajax.request({
29245
                                        async: false,
29246
                                        method: 'POST',
29247
                                        url: '/UserControl/GetStore',
29248
                                        params: {
29249
                                            tableName: 'SDATATABLEFIELD',
29250
                                            param: 'TableName[equal]' + rec.TableRef
29251
                                        },
29252
                                        success: function (response) {
29253
                                            var results = Ext.decode(response.responseText);
29254
                                            data_ = results.data;
29255
                                            if (data_ != undefined) {
29256
                                                valueField_ = $.grep(data_, function (r) {
29257
                                                    return r.ValueField == '1'
29258
                                                });
29259
                                                if (valueField_.length > 0) {
29260
                                                    valueField = valueField_[0].FieldName
29261
                                                }
29262

    
29263
                                                displayValue_ = $.grep(data_, function (r) {
29264
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
29265
                                                });
29266
                                                if (displayValue_.length > 0) {
29267
                                                    displayValue = displayValue_[0].FieldName;
29268
                                                }
29269
                                                if (displayValue_.length >= 2) {
29270
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
29271
                                                }
29272
                                            }
29273
                                        }
29274
                                    });
29275
                                }
29276
                                Ext.create('Ext.data.Store', {
29277
                                    storeId: 'store_' + me.tableName + rec.FieldName,
29278
                                    autoLoad: true,
29279
                                    proxy: {
29280
                                        method: 'POST',
29281
                                        type: 'ajax',
29282
                                        url: '/UserControl/GetStoreAuth',
29283
                                        extraParams: {
29284
                                            tableName: TableRef,
29285
                                            param: rec.ParamCombo,
29286
                                            menuId: MinovaUtil.GetMenuID()
29287
                                        },
29288
                                        reader: {
29289
                                            type: 'json',
29290
                                            root: 'data',
29291
                                            totalProperty: 'data[0].TotalCount'
29292
                                        }
29293
                                    }
29294
                                });
29295
                                cols.push({
29296
                                    //xtype : 'minovacombocolumn',
29297
                                    hidden: Hidden_,
29298
                                    text: rec.HeaderTitle,
29299
                                    dataIndex: rec.FieldName,
29300
                                    //valueField : valueField,
29301
                                    //displayField : displayValue,
29302
                                    //store : 'store_' + me.tableName + rec.FieldName,
29303
                                    tpl: Ext.create('Ext.XTemplate',
29304
                                        '<ul class="x-list-plain"><tpl for=".">',
29305
                                        '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
29306
                                        '</tpl></ul>'),
29307
                                    displayTpl: Ext.create('Ext.XTemplate',
29308
                                        '<tpl for=".">',
29309
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
29310
                                        '</tpl>'),
29311
                                    editor: {
29312
                                        allowBlank: null_,
29313
                                        xtype: 'combobox',
29314
                                        readOnly: ReadOnly_,
29315
                                        id: rec.TableName + rec.FieldName,
29316
                                        nameTable: rec.TableName,
29317
                                        fieldGrid: rec.FieldName,
29318
                                        valueField: valueField,
29319
                                        displayField: displayValue,
29320
                                        store: 'store_' + me.tableName + rec.FieldName,
29321
                                        value: rec.DefaultValue,
29322
                                        tpl: Ext.create('Ext.XTemplate',
29323
                                            '<ul class="x-list-plain"><tpl for=".">',
29324
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
29325
                                            '</tpl></ul>'),
29326
                                        displayTpl: Ext.create('Ext.XTemplate',
29327
                                            '<tpl for=".">',
29328
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
29329
                                            '</tpl>')
29330
                                    },
29331
                                    renderer: function (value) {
29332
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
29333
                                        var index = store.find(valueField, value);
29334
                                        var val = "";
29335
                                        if (index != -1) {
29336
                                            var rc = store.getAt(index);
29337
                                            //val = rc.get(displayValue);
29338
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
29339
                                        } else {
29340
                                            val = value;
29341
                                        }
29342
                                        return val;
29343
                                    },
29344
                                    filter: {
29345
                                        type: 'list',
29346
                                        itemDefaults: {
29347
                                            emptyText: 'Search for...'
29348
                                        }
29349
                                    }
29350
                                });
29351
                            }
29352
							else if (rec.SearchType == '2') {
29353
                                var triger = (rec.TriggerCombo).split('$');
29354
                                var targetField_ = triger[0];
29355
                                var fieldValue_ = triger[1];
29356
                                cols.push({
29357
                                    text: rec.HeaderTitle,
29358
                                    hidden: Hidden_,
29359
                                    dataIndex: rec.FieldName,
29360
                                    filter: {
29361
                                        itemDefaults: {
29362
                                            emptyText: 'Search for...'
29363
                                        }
29364
                                    },
29365
                                    editor: {
29366
                                        allowBlank: null_,
29367
                                        xtype: 'minovalookupgrid',
29368
                                        readOnly: ReadOnly_,
29369
                                        isGrid: true,
29370
                                        fieldTarget: targetField_,
29371
                                        fieldValue: fieldValue_,
29372
                                        isGrid: true,
29373
                                        id: tableName + rec.FieldName,
29374
                                        tableName: rec.TableRef,
29375
                                        triggerCls: 'x-form-search-trigger',
29376
                                        vtype: 'alphanum',
29377
                                        nameTable: rec.TableName,
29378
                                        fieldGrid: rec.FieldName,
29379
                                        listeners: {
29380
                                            change: function (val) {
29381
                                                var custumFunc = rec.SelectFunction;
29382
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
29383
                                                    Ext.Ajax.request({
29384
                                                        async: false,
29385
                                                        method: 'POST',
29386
                                                        url: '/UserControl/GetStore',
29387
                                                        params: {
29388
                                                            tableName: 'PCMFUNC',
29389
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
29390
                                                        },
29391
                                                        success: function (response) {
29392
                                                            var results = Ext.decode(response.responseText);
29393
                                                            data_ = results.data[0];
29394
                                                            if (data_ != undefined) {
29395
                                                                custumFunc = data_.FunctionCode;
29396
                                                            }
29397
                                                        }
29398
                                                    });
29399
                                                }
29400
                                                if (custumFunc) {
29401
                                                    eval(custumFunc)
29402
                                                }
29403
                                            }
29404
                                        }
29405
                                    }
29406
                                });
29407
                            } else if (rec.SearchType == '3') {
29408
                                cols.push({
29409
                                    text: rec.HeaderTitle,
29410
                                    hidden: Hidden_,
29411
                                    dataIndex: rec.FieldName,
29412
                                    filter: {
29413
                                        itemDefaults: {
29414
                                            emptyText: 'Search for...'
29415
                                        }
29416
                                    },
29417
                                    editor: {
29418
                                        allowBlank: null_,
29419
                                        xtype: 'MinovaLookupTree',
29420
                                        readOnly: ReadOnly_,
29421
                                        id: tableName + rec.FieldName,
29422
                                        tableName: rec.TableRef,
29423
                                        triggerCls: 'x-form-search-trigger',
29424
                                        vtype: 'alphanum',
29425
                                        treeSructure: rec.SearchFunction,
29426
                                        objClassValue: rec.ParamCombo,
29427
                                        nameTable: rec.TableName,
29428
                                        fieldGrid: rec.FieldName,
29429
                                        formname: me.name,
29430
                                        listeners: {
29431
                                            change: function (val) {
29432
                                                var custumFunc = rec.SelectFunction;
29433
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
29434
                                                    Ext.Ajax.request({
29435
                                                        async: false,
29436
                                                        method: 'POST',
29437
                                                        url: '/UserControl/GetStore',
29438
                                                        params: {
29439
                                                            tableName: 'PCMFUNC',
29440
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
29441
                                                        },
29442
                                                        success: function (response) {
29443
                                                            var results = Ext.decode(response.responseText);
29444
                                                            data_ = results.data[0];
29445
                                                            if (data_ != undefined) {
29446
                                                                custumFunc = data_.FunctionCode;
29447
                                                            }
29448
                                                        }
29449
                                                    });
29450
                                                }
29451
                                                if (custumFunc) {
29452
                                                    eval(custumFunc)
29453
                                                }
29454
                                            }
29455
                                        }
29456
                                    }
29457
                                });
29458
                            } 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) {
29459
                                var triger = (rec.TriggerCombo).split('&');
29460
                                var targetField_ = triger[0];
29461
                                var fieldValue_ = triger[0];
29462
                                cols.push({
29463
                                    text: rec.HeaderTitle,
29464
                                    hidden: Hidden_,
29465
                                    dataIndex: rec.FieldName,
29466
                                    filter: {
29467
                                        itemDefaults: {
29468
                                            emptyText: 'Search for...'
29469
                                        }
29470
                                    },
29471
                                    editor: {
29472
                                        allowBlank: null_,
29473
                                        xtype: 'lookupemployee',
29474
                                        readOnly: ReadOnly_,
29475
                                        isGrid: true,
29476
                                        fieldTarget: targetField_,
29477
                                        fieldValue: fieldValue_,
29478
                                        isGrid: true,
29479
                                        id: tableName + rec.FieldName,
29480
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
29481
                                        triggerCls: 'x-form-search-trigger',
29482
                                        vtype: 'alphanum', // disable space
29483
                                        nameTable: rec.TableName,
29484
                                        fieldGrid: rec.FieldName,
29485
                                        listeners: {
29486
                                            change: function (val) {
29487
                                                var custumFunc = rec.SelectFunction;
29488
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
29489
                                                    Ext.Ajax.request({
29490
                                                        async: false,
29491
                                                        method: 'POST',
29492
                                                        url: '/UserControl/GetStore',
29493
                                                        params: {
29494
                                                            tableName: 'PCMFUNC',
29495
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
29496
                                                        },
29497
                                                        success: function (response) {
29498
                                                            var results = Ext.decode(response.responseText);
29499
                                                            data_ = results.data[0];
29500
                                                            if (data_ != undefined) {
29501
                                                                custumFunc = data_.FunctionCode;
29502
                                                            }
29503
                                                        }
29504
                                                    });
29505
                                                }
29506
                                                if (custumFunc) {
29507
                                                    eval(custumFunc)
29508
                                                }
29509
                                            }
29510
                                        }
29511
                                    }
29512
                                });
29513
                            } else if (rec.SearchType == '4' && isLookup != true) {
29514
                                cols.push({
29515
                                    text: rec.HeaderTitle,
29516
                                    hidden: Hidden_,
29517
                                    dataIndex: rec.FieldName,
29518
                                    filter: {
29519
                                        itemDefaults: {
29520
                                            emptyText: 'Search for...'
29521
                                        }
29522
                                    },
29523
                                    editor: {
29524
                                        allowBlank: null_,
29525
                                        xtype: 'lookupemployee',
29526
                                        readOnly: ReadOnly_,
29527
                                        isGrid: true,
29528
                                        fieldTarget: targetField_,
29529
                                        fieldValue: fieldValue_,
29530
                                        isGrid: true,
29531
                                        id: tableName + rec.FieldName,
29532
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
29533
                                        triggerCls: 'x-form-search-trigger',
29534
                                        vtype: 'alphanum', // disable space
29535
                                        nameTable: rec.TableName,
29536
                                        fieldGrid: rec.FieldName,
29537
                                        listeners: {
29538
                                            change: function (val) {
29539
                                                var custumFunc = rec.SelectFunction;
29540
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
29541
                                                    Ext.Ajax.request({
29542
                                                        async: false,
29543
                                                        method: 'POST',
29544
                                                        url: '/UserControl/GetStore',
29545
                                                        params: {
29546
                                                            tableName: 'PCMFUNC',
29547
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
29548
                                                        },
29549
                                                        success: function (response) {
29550
                                                            var results = Ext.decode(response.responseText);
29551
                                                            data_ = results.data[0];
29552
                                                            if (data_ != undefined) {
29553
                                                                custumFunc = data_.FunctionCode;
29554
                                                            }
29555
                                                        }
29556
                                                    });
29557
                                                }
29558
                                                if (custumFunc) {
29559
                                                    eval(custumFunc)
29560
                                                }
29561
                                            }
29562
                                        }
29563
                                    }
29564
                                });
29565
                            } else if (rec.FixedValue != '') { // add by taufan
29566
                                cols.push({
29567
                                    text: rec.HeaderTitle,
29568
                                    hidden: Hidden_,
29569
                                    dataIndex: rec.FieldName,
29570
                                    filter: {
29571
                                        itemDefaults: {
29572
                                            emptyText: 'Search for...'
29573
                                        }
29574
                                    },
29575
                                    editor: {
29576
                                        allowBlank: null_,
29577
                                        xtype: 'minovafixvalue',
29578
                                        readOnly: ReadOnly_,
29579
                                        id: rec.TableName + rec.FieldName,
29580
                                        name: rec.TableName + rec.FieldName,
29581
                                        nameTable: rec.TableName,
29582
                                        fieldGrid: rec.FieldName,
29583
                                        fixedValue: rec.FixedValue,
29584
                                        valueField: 'code',
29585
                                        displayField: 'desc',
29586
                                        value: rec.DefaultValue
29587
                                    },
29588
                                    renderer: function (value) {
29589
                                        var val = "";
29590
                                        var storeData = [];
29591
                                        var str = rec.FixedValue;
29592
                                        var hasil = str.split('||');
29593
                                        hasil.forEach(function (h) {
29594
                                            store_ = h.split('=')
29595
                                            storeData.push({
29596
                                                code: store_[0],
29597
                                                desc: store_[1]
29598
                                            });
29599
                                        });
29600
                                        var item = storeData.find(x => x.code == value);
29601
                                        if (item != undefined) {
29602
                                            val = item.desc;
29603
                                        }
29604
                                        return val;
29605
                                    }
29606
                                });
29607
                            } else {
29608
                                var _custumFunc = null;
29609
                                Ext.Ajax.request({
29610
                                    async: false,
29611
                                    method: 'POST',
29612
                                    url: '/UserControl/GetStore',
29613
                                    params: {
29614
                                        tableName: 'SDATATABLEFIELD',
29615
                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
29616
                                    },
29617
                                    success: function (response) {
29618
                                        var results = Ext.decode(response.responseText);
29619
                                        data_ = results.data[0];
29620
                                        if (data_ != undefined) {
29621
                                            _custumFunc = data_.SelectFunction;
29622
                                        }
29623
                                    }
29624
                                });
29625
                                _xtype = 'textfield';
29626
                                if (rec.Length > 250) {
29627
                                    _xtype = 'textareafield';
29628
                                    cols.push({
29629
                                        text: rec.HeaderTitle,
29630
                                        xtype: 'gridcolumn',
29631
                                        hidden: Hidden_,
29632
                                        dataIndex: rec.FieldName,
29633
                                        filter: {
29634
                                            itemDefaults: {
29635
                                                emptyText: 'Search for...'
29636
                                            }
29637
                                        },
29638
                                        cellWrap: true,
29639
                                        width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
29640
                                        editor: {
29641
                                            allowBlank: null_,
29642
                                            xtype: _xtype,
29643
                                            readOnly: ReadOnly_,
29644
                                            id: tableName + rec.FieldName,
29645
                                            nameTable: rec.TableName,
29646
                                            fieldGrid: rec.FieldName,
29647
                                            value: rec.DefaultValue,
29648
                                            maxLength: rec.Length,
29649
                                            grow: true,
29650
                                            listeners: {
29651
                                                //initialize: function (editor) {
29652
                                                //    editor.ownerCt.alignTo(editor.ownerCt.boundEl, 'tl-tl');
29653
                                                //    editor.ownerCt.alignment = 'tl-tl';
29654
                                                //},
29655
                                                afterrender: function () {
29656
                                                    var me = this;
29657
                                                    //me.el.swallowEvent(['keypress', 'keydown']);
29658
                                                }
29659
                                            }
29660
                                        },
29661
                                        renderer: function (v) {
29662
                                            if (v != undefined) {
29663
												result = v.replace(/\r\n\r\n/g, "</p><p>").replace(/\n\n/g, "</p><p>");
29664
												result = result.replace(/\r\n/g, "<br />").replace(/\n/g, "<br />");
29665
												result = result.replace(/\r\t/g, "&emsp;").replace(/\t/g, "&emsp;");
29666
												return result;
29667
											}
29668
											else {
29669
												return v;
29670
											}
29671
                                        }
29672
                                    });
29673
                                }
29674
                                else {
29675
                                    cols.push({
29676
                                        text: rec.HeaderTitle,
29677
                                        xtype: 'gridcolumn',
29678
                                        hidden: Hidden_,
29679
                                        dataIndex: rec.FieldName,
29680
                                        filter: {
29681
                                            itemDefaults: {
29682
                                                emptyText: 'Search for...'
29683
                                            }
29684
                                        },
29685
                                        cellWrap: true,
29686
                                        width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
29687
                                        editor: {
29688
                                            allowBlank: null_,
29689
                                            xtype: _xtype,
29690
                                            readOnly: ReadOnly_,
29691
                                            id: tableName + rec.FieldName,
29692
                                            nameTable: rec.TableName,
29693
                                            fieldGrid: rec.FieldName,
29694
                                            value: rec.DefaultValue,
29695
                                            maxLength: rec.Length,
29696
                                            grow: true,
29697
                                            listeners: {
29698
                                                change: function (val) {
29699
                                                    if (_custumFunc) {
29700
                                                        eval(_custumFunc)
29701
                                                    }
29702
                                                }
29703
                                                /*change: function (val) {
29704
                                                    var custumFunc = null;
29705
                                                    Ext.Ajax.request({
29706
                                                        async: false,
29707
                                                        method: 'POST',
29708
                                                        url: '/UserControl/GetStore',
29709
                                                        params: {
29710
                                                            tableName: 'SDATATABLEFIELD',
29711
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
29712
                                                        },
29713
                                                        success: function (response) {
29714
                                                            var results = Ext.decode(response.responseText);
29715
                                                            data_ = results.data[0];
29716
                                                            if (data_ != undefined) {
29717
                                                                custumFunc = data_.SelectFunction;
29718
                                                                //console.log(data_)
29719
                                                            }
29720
                                                        }
29721
                                                    });
29722
    
29723
                                                    if (custumFunc) {
29724
                                                        eval(custumFunc)
29725
                                                    }
29726
                                                } */
29727
                                            }
29728
                                        }
29729
                                    });
29730
                                }
29731
                            }
29732
                            break
29733
                    }
29734
                } else {
29735
                    cols.push({
29736
                        text: rec.HeaderTitle,
29737
                        hidden: Hidden_,
29738
                        dataIndex: rec.FieldName,
29739
                        hidden: true,
29740
                        editor: {
29741
                            allowBlank: true,
29742
                            xtype: 'textfield',
29743
                            readOnly: ReadOnly_,
29744
                            id: tableName + rec.FieldName,
29745
                            nameTable: rec.TableName,
29746
                            fieldGrid: rec.FieldName,
29747
                            value: rec.DefaultValue
29748
                        },
29749
                        filter: {
29750
                            itemDefaults: {
29751
                                emptyText: 'Search for...'
29752
                            }
29753
                        }
29754
                    });
29755
                }
29756
            });
29757

    
29758
        };        
29759
        //cols.push({
29760
        //    xtype: 'actioncolumn',
29761
        //    text: 'Edit',
29762
        //    maxWidth: 150,
29763
        //    minWidth: 50,
29764
        //    border: false,
29765
        //    itemId: 'startEditActionColumn',
29766
        //    align: 'center',
29767
        //    items: [
29768
        //        {
29769
        //            iconCls: 'x-fa fa-pencil-square-o',
29770
        //            handler: function (grid, rowIndex, colIndex) {
29771
        //                grid.editingPlugin.startEdit(rowIndex, 0);
29772
        //            }
29773
        //        }
29774
        //    ]
29775
        //});
29776
        addData = addData + "}";
29777
        Ext.applyIf(me, {
29778
            items: [{
29779
                xtype: 'grid',
29780
                id: gridName,
29781
                name: gridName,
29782
                height: height,
29783
                minHeight: me.minHeight,
29784
                maxHeight: me.maxHeight,
29785
                addFlag: true,
29786
                deleteFlag: true,
29787
                store: Ext.create('Ext.data.Store', {
29788
                    storeId: storeID,
29789
                    fields: fieldStore,
29790
                    //groupField: 'QuestionGroup',
29791
                    grouper: {
29792
                        sortProperty: 'SeqQuest',
29793
                        groupFn: function (record) {
29794
                            return record.get('QuestionGroup');
29795
                        }
29796
                    },
29797
                    proxy: {
29798
                        method: 'POST',
29799
                        type: 'ajax',
29800
                        url: '',
29801
                        reader: {
29802
                            type: 'json',
29803
                            root: 'data'
29804
                        }
29805
                    }
29806
                }),
29807
                dockedItems: [{
29808
                    xtype: 'toolbar',
29809
                    items: [{
29810
                        text: 'Add',
29811
                        hidden: hide_,
29812
                        name: tableName + 'Add',
29813
                        iconCls: 'fa-plus-circle',
29814
                        style: 'font-family: FontAwesome',
29815
                        handler: function () {
29816
                            var grid = Ext.getCmp(gridName);
29817
                            if (grid.addFlag === true) {
29818
                                var store = Ext.StoreMgr.lookup(storeID)
29819
                                idx = store.getCount();
29820
                                var action = getParam('action');
29821
                                var data = '';
29822
                                var Sequence = 0;
29823
                                if (idx == 0) {
29824
                                    Sequence = 1;
29825
                                } else {
29826
                                    Sequence = 1 + idx;
29827
                                }
29828
                                var seq = 'Sequence';
29829
                                var SequenceValue = Sequence;
29830
                                eval(addData);
29831
                                data[seq] = SequenceValue;
29832
                                store.insert(idx, data);
29833
                            }
29834
                        }
29835
                    }, {
29836
                        text: 'Delete',
29837
                        hidden: hide_,
29838
                        name: tableName + 'DeleteText',
29839
                        iconCls: 'fa-trash-o',
29840
                        style: 'font-family: FontAwesome',
29841
                        handler: function () {
29842
                            var grid = Ext.getCmp(gridName);
29843
                            if (grid.deleteFlag === true) {
29844
                                var me = this,
29845
                                    store = Ext.StoreMgr.lookup(storeID)
29846
                                var grid = Ext.getCmp(gridName);
29847
                                Ext.MessageBox.show({
29848
                                    title: 'Remove tab',
29849
                                    msg: "This will remove. Do you want to continue?",
29850
                                    buttons: Ext.MessageBox.YESNO,
29851
                                    fn: function (choice) {
29852
                                        console.log(choice);
29853
                                        if (choice === 'yes') {
29854
                                            var selection = grid.getView().getSelectionModel().getSelection()[0];
29855
                                            if (selection) {
29856
                                                store.remove(selection);
29857
                                            }
29858
                                        }
29859
                                    }
29860
                                });
29861
                            }
29862
                        }
29863
                        },
29864
                        {
29865
                            xtype: 'label',
29866
                            name: tableName + 'Label',
29867
							id: tableName + 'Label', //YN 220316
29868
							hidden: true, //YN 220316
29869
                            html: '<i>*Please double click on the cell/row to edit content.</i>'
29870
                        }]
29871
                }
29872
                ],
29873
                columns: {
29874
                    defaults: {
29875
                        menuDisabled: true
29876
                    },
29877
                    items: cols
29878
                },
29879
                //selModel: 'rowmodel',
29880
                selType: 'rowmodel', //checkSelection,
29881
                plugins: [
29882
                    Ext.create('Ext.grid.plugin.CellEditing', {
29883
                        clicksToEdit: 2
29884
                    })
29885
                ],
29886
                //plugins: {
29887
                //    //ptype: 'actionColumnRowEditing', //rowediting
29888
                //    //pluginId: 'rowEditing',
29889
                //    ptype: 'cellediting',
29890
                //    //hiddenColumnsOnEdit: ['startEditActionColumn'],
29891
                //    clicksToEdit: 2,
29892
                //    //saveButtonIconCls: 'x-fa fa-floppy-o',
29893
                //    listeners: {}
29894
                //},
29895
                //listeners: {
29896
                //    'beforeedit': function (editor) {
29897
                //        editor.getEditor().floatingButtons.items.items[0].hide();
29898
                //        editor.getEditor().floatingButtons.items.items[1].hide();
29899
                //    }
29900
                //},
29901
                features: features,
29902
                viewConfig: {
29903
                    listeners: {
29904
                        refresh: function (dataview) {
29905
                            Ext.each(dataview.panel.columns, function (column) {
29906
                                column.autoSize();
29907
                                column.setWidth(column.width + 20); //YN 220316
29908
                            })
29909
                        }
29910
                    }
29911
                }
29912
            }
29913
            ]
29914
        });
29915
        me.callParent(arguments);
29916
    }
29917
});
29918

    
29919
/*Grid Display ESS Generator YN 20211216 */
29920
Ext.define('MinovaUtil.MinovaES.MinovaGridDisplay', {
29921
    extend: 'Ext.grid.Panel',
29922
    requires: ['Ext.grid.RowNumberer'],
29923
    alias: 'widget.minovagriddisplay',
29924
    //alternateClassName : 'Ext.grid.MinovaGrid',
29925
    tableName: undefined,
29926
    isLookup: undefined,
29927
    param: undefined,
29928
    pagesize: undefined,
29929
    storeName: undefined,
29930
    layoutType: undefined,
29931
    enableLocking: true,
29932
    initComponent: function () {
29933
        var me = this;
29934
        var cols_ = [];
29935
        var fieldeditor = {};
29936
        var hasil = null;
29937
        var autoLoad = true;
29938
        var LangID = MinovaUtil.GetLangID();
29939
        parameter = null;
29940
        if (me.isLookup == true || isLookup == 1 || isLookup == 'Y') {
29941
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'"
29942
        } else {
29943
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
29944
        }
29945
        Ext.Ajax.request({
29946
            async: false,
29947
            method: 'POST',
29948
            url: '/UserControl/GetStore',
29949
            params: {
29950
                tableName: 'PDSBS0007',
29951
                param: parameter
29952
            },
29953
            success: function (response) {
29954
                var results = Ext.decode(response.responseText);
29955
                hasil = results.data;
29956
            }
29957
        });
29958
        if (hasil.length > 0) {
29959
            Ext.each(hasil, function (rec) {
29960
                var null_ = null;
29961
                if (rec.IsPrimaryKey == true) {
29962
                    null_ = false;
29963
                }
29964
                if (rec.IsRequired == true) {
29965
                    null_ = false;
29966
                } else {
29967
                    null_ = true;
29968
                }
29969
                if (rec.GridView == 1) {
29970
                    switch (rec.FormatRef) {
29971
                        case "date":
29972
                            cols_.push({
29973
                                xtype: 'minovadatecolumn',
29974
                                text: rec.HeaderTitle,
29975
                                dataIndex: rec.FieldName,
29976
                                width: 100,
29977
                                filter: {
29978
                                    type: 'date',
29979
                                    itemDefaults: {
29980
                                        emptyText: 'Search for...'
29981
                                    }
29982
                                }
29983
                            });
29984
                            break
29985
                        case "amountencrypt":
29986
                            cols_.push({
29987
                                xtype: 'minovaamountcolumn',
29988
                                text: rec.HeaderTitle,
29989
                                dataIndex: rec.FieldName,
29990
                                align: 'right',
29991
                                width: 100,
29992
                                filter: {
29993
                                    type: 'string',
29994
                                    itemDefaults: {
29995
                                        emptyText: 'Search for...'
29996
                                    }
29997
                                }
29998
                            });
29999
                            break
30000
                        case "amount":
30001
                            cols_.push({
30002
                                xtype: 'minovacurrancycolumn',
30003
                                text: rec.HeaderTitle,
30004
                                dataIndex: rec.FieldName,
30005
                                align: 'right',
30006
                                width: 100,
30007
                                filter: {
30008
                                    type: 'number',
30009
                                    itemDefaults: {
30010
                                        emptyText: 'Search for...'
30011
                                    }
30012
                                }
30013
                            });
30014
                            break
30015
                        case "datetime":
30016
                            cols_.push({
30017
                                xtype: 'minovadatetimecolumn',
30018
                                text: rec.HeaderTitle,
30019
                                dataIndex: rec.FieldName,
30020
                                width: 140,
30021
                                filter: {
30022
                                    type: 'string',
30023
                                    itemDefaults: {
30024
                                        emptyText: 'Search for...'
30025
                                    }
30026
                                }
30027
                            });
30028
                            break
30029
                        default:
30030
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
30031
                                cols_.push({
30032
                                    text: rec.HeaderTitle,
30033
                                    dataIndex: rec.FieldName,
30034
                                    width: 100,
30035
                                    filter: {
30036
                                        type: 'string',
30037
                                        itemDefaults: {
30038
                                            emptyText: 'Search for...'
30039
                                        }
30040
                                    }
30041
                                });
30042
                            } else if (rec.SearchType == '2') {
30043
                                cols_.push({
30044
                                    xtype: 'minovalookupcolumn',
30045
                                    text: rec.HeaderTitle,
30046
                                    tableName: rec.TableRef,
30047
                                    dataIndex: rec.FieldName,
30048
                                    filter: {
30049
                                        itemDefaults: {
30050
                                            emptyText: 'Search for...'
30051
                                        }
30052
                                    }
30053
                                });
30054
                            } else if (rec.TableRef != "") {
30055
                                if (rec.TableRef != null) {
30056
                                    var valueField = null;
30057
                                    Ext.Ajax.request({
30058
                                        async: false,
30059
                                        method: 'POST',
30060
                                        url: '/UserControl/GetStore',
30061
                                        params: {
30062
                                            tableName: 'SDATATABLEFIELD',
30063
                                            param: 'ValueField[equal]1,TableName[equal]' + rec.TableRef
30064
                                        },
30065
                                        success: function (response) {
30066
                                            var results = Ext.decode(response.responseText);
30067
                                            data_ = results.data[0];
30068
                                            if (data_ != undefined) {
30069
                                                valueField = data_.FieldName;
30070
                                            }
30071
                                        }
30072
                                    });
30073

    
30074
                                    displayValue = null;
30075
                                    Ext.Ajax.request({
30076
                                        async: false,
30077
                                        method: 'POST',
30078
                                        url: '/UserControl/GetStore',
30079
                                        params: {
30080
                                            tableName: 'SDATATABLEFIELD',
30081
                                            param: 'DisplayValue[equal]1,TableName[equal]' + rec.TableRef
30082
                                        },
30083
                                        success: function (response) {
30084
                                            var results = Ext.decode(response.responseText);
30085
                                            data_ = results.data[0];
30086
                                            if (data_ != undefined) {
30087
                                                displayValue = data_.FieldName;
30088
                                                //console.log(data_)
30089
                                            }
30090
                                        }
30091
                                    });
30092
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
30093
                                    var count_ = 0;
30094
                                    if (store_) {
30095
                                        count_ = store_.count();
30096
                                    }
30097
                                    if (count_ == 0) {
30098
                                        Ext.create('Ext.data.Store', {
30099
                                            storeId: 'store_' + rec.FieldName,
30100
                                            autoLoad: true,
30101
                                            proxy: {
30102
                                                method: 'POST',
30103
                                                type: 'ajax',
30104
                                                url: '/UserControl/GetStore',
30105
                                                extraParams: {
30106
                                                    tableName: rec.TableRef,
30107
                                                    param: rec.ParamCombo
30108
                                                },
30109
                                                reader: {
30110
                                                    type: 'json',
30111
                                                    root: 'data',
30112
                                                    totalProperty: 'data[0].TotalCount'
30113
                                                }
30114
                                            }
30115
                                        })
30116
                                    }
30117
                                    cols_.push({
30118
                                        xtype: 'minovacombocolumn',
30119
                                        text: rec.HeaderTitle,
30120
                                        dataIndex: rec.FieldName,
30121
                                        valueField: valueField,
30122
                                        displayField: displayValue,
30123
                                        store: 'store_' + rec.FieldName,
30124
                                        filter: {
30125
                                            type: 'list',
30126
                                            itemDefaults: {
30127
                                                emptyText: 'Search for...'
30128
                                            }
30129
                                        }
30130
                                    });
30131
                                }
30132

    
30133
                            } else {
30134
                                cols_.push({
30135
                                    text: rec.HeaderTitle,
30136
                                    dataIndex: rec.FieldName,
30137
                                    width: rec.Length * 6.5 + 20, //(rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
30138
                                    flex: ((rec.Length * 6.5 + 20) >= 800)?1:0,
30139
                                    //autoSizeColumn: true,
30140
                                    cellWrap: true,
30141
                                    hidden: (rec.IsHidden=='1')? true:false,
30142
                                    filter: {
30143
                                        itemDefaults: {
30144
                                            emptyText: 'Search for...'
30145
                                        }
30146
                                    }
30147
                                });
30148
                            }
30149
                            break
30150
                    }
30151
                }
30152
                else {
30153
                    cols_.push({
30154
                        text: rec.HeaderTitle,
30155
                        dataIndex: rec.FieldName,
30156
                        hidden: true,
30157
                        filter: {
30158
                            itemDefaults: {
30159
                                emptyText: 'Search for...'
30160
                            }
30161
                        }
30162
                    });
30163
                }
30164
            });
30165
        };
30166
        var param_ = me.param;
30167
        if (param_ == undefined) {
30168
            param_ = ''
30169
        }
30170

    
30171
        var jsStoreGrid = new Ext.create('Ext.data.Store', {
30172
            storeId: me.storeName,
30173
            autoLoad: false,
30174
            proxy: {
30175
                method: 'POST',
30176
                type: 'ajax',
30177
                url: '/UserControl/GetStore',
30178
                extraParams: {
30179
                    tableName: me.tableName,
30180
                    param: param_
30181
                },
30182
                reader: {
30183
                    type: 'json',
30184
                    root: 'data',
30185
                    totalProperty: 'data[0].TotalCount'
30186
                }
30187
            }
30188
        });
30189

    
30190
        Ext.applyIf(me, {
30191
            defaults: {
30192
                autoSizeColumn: true,
30193
            },
30194
            columns: cols_,
30195
            store: jsStoreGrid,
30196
            viewConfig: {
30197
                listeners: {
30198
                    refresh: function (dataview) {
30199
                        Ext.each(dataview.panel.columns, function (column) {
30200
                            if (column.autoSizeColumn === true)
30201
                                column.autoSize();
30202
                        })
30203
                    }
30204
                }
30205
            },
30206
        });
30207
        me.callParent(arguments);
30208
    }
30209

    
30210
});
30211

    
30212
/*https://fiddle.sencha.com/#fiddle/1544&view/editor */
30213
Ext.define('MinovaUtil.MinovaES.StoreCheckboxGroup', {
30214
    extend: 'Ext.form.CheckboxGroup',
30215
    xtype: 'storecheckboxgroup', // <- this "xtype" is a unique name of the component.
30216
    name: undefined,
30217
    nametxt: undefined,
30218
    formname: undefined,
30219
    nameTable: undefined,
30220
    initComponent: function () {
30221
        var me = this;
30222
        if (!me.store) throw "No store defined for StoreCheckboxGroup";
30223
        if (!me.mapFn) throw "No mapFn defined for StoreCheckboxGroup";
30224
        if (me.items) throw "Items may not be defined for StoreCheckboxGroup; we get them from the store!";
30225
        var checklistStore = me.store, // <-- using the required "store" property
30226
            renderCheckboxes = function () {
30227
                me.removeAll();
30228
                //me.add(formfield = new Ext.form.TextField({
30229
                //    name: me.nametxt,
30230
                //    formname: me.formname,
30231
                //    nameTable: me.nameTable,
30232
                //}));
30233
                me.add(
30234
                    checklistStore.getRange().map(me.mapFn)); // <-- using the required "mapFn" property
30235
            };
30236
        me.callParent(arguments);
30237
        renderCheckboxes(); // <-- using the function I defined above
30238
        checklistStore.on({
30239
            load: renderCheckboxes, // <-------- binding the
30240
            update: renderCheckboxes, // <------ function to
30241
            datachanged: renderCheckboxes, // <- the store
30242
            filterchange: renderCheckboxes // <- events
30243
        });
30244
    }
30245
});
30246
/* END YN 20211216 */
30247

    
30248

    
30249

    
30250

    
30251

    
(2-2/2)