cronapp-framework-js 2.8.21 → 2.8.25

package/js/directives.js

@@ -386,7 +386,7 @@
           }
         }
       })
-    .directive('dynamicFile', function($compile, $translate) {
+      .directive('dynamicFile', function($compile, $translate) {
         var template = '';
         return {
           restrict: 'A',
@@ -395,18 +395,18 @@
           link: function(scope, element, attr) {
             var s = scope;
             var required = (attr.ngRequired && attr.ngRequired == "true"?"required":"");
-          
+
             var splitedNgModel = attr.ngModel.split('.');
             var datasource = splitedNgModel[0];
             var field = splitedNgModel[splitedNgModel.length-1];
             var number = Math.floor((Math.random() * 1000) + 20);
             var content = element.html();
-          
+
             var maxFileSize = "";
             if (attr.maxFileSize)
               maxFileSize = attr.maxFileSize;
             let fileInfo = attr.fileInfo ? `'${attr.fileInfo}'`: 'undefined';
-          
+
             var templateDyn    = '\
                                 <div ng-show="!$ngModel$" ngf-drop="" ngf-drag-over-class="dragover">\
                                   <input id="$id$" aria-label="$userHtml$" ng-if="!$ngModel$" autocomplete="off" tabindex="-1" class="uiSelectRequired ui-select-offscreen" style="top: inherit !important;margin-left: 85px !important;margin-top: 50px !important; display: none;" type=text ng-model="$ngModel$" $required$>\
@@ -443,7 +443,7 @@
                 .split('$lblDownload$').join($translate.instant('download'))
                 .split('$fileInfo$').join(fileInfo)
             );
-          
+
             element.html(templateDyn);
             $compile(templateDyn)(element.scope());
           }
@@ -762,12 +762,12 @@
           link: function (scope, element, attrs, ngModelCtrl) {
 
             let waitAngularReady = () => {
-                if (scope.$$phase !== '$apply' && scope.$$phase !== '$digest') {
-                    element.find('i').remove();
-                }
-                else {
-                    setTimeout( () => waitAngularReady(), 200);
-                }
+              if (scope.$$phase !== '$apply' && scope.$$phase !== '$digest') {
+                element.find('i').remove();
+              }
+              else {
+                setTimeout( () => waitAngularReady(), 200);
+              }
             };
             waitAngularReady();
 
@@ -1414,1938 +1414,1939 @@
         };
       })
 
-    .directive('cronScheduler', ['$compile', '$translate', function($compile, $translate) {
-      return {
-        estrict: 'E',
-        replace: true,
-        initCulture: function() {
-          var culture = $translate.use();
-          culture = culture.replace(/_/gm, '-');
-          var parts = culture.split('-');
-          parts[parts.length - 1] = parts[parts.length - 1].toUpperCase();
-          culture = parts.join('-');
-          kendo.culture(culture);
-        },
-        getSchedulerModel: function(datasourceFields) {
-          let model = {
-            id: "id", // The "id" of the event is the "taskId" field
-            fields: {}
-          };
-          for(let key in datasourceFields) {
-            model.fields[key] = {from: datasourceFields[key].name, validation: { required: !datasourceFields[key].nullable } };
-          }
+      .directive('cronScheduler', ['$compile', '$translate', function($compile, $translate) {
+        return {
+          estrict: 'E',
+          replace: true,
+          initCulture: function() {
+            var culture = $translate.use();
+            culture = culture.replace(/_/gm, '-');
+            var parts = culture.split('-');
+            parts[parts.length - 1] = parts[parts.length - 1].toUpperCase();
+            culture = parts.join('-');
+            kendo.culture(culture);
+          },
+          getSchedulerModel: function(datasourceFields) {
+            let model = {
+              id: "id", // The "id" of the event is the "taskId" field
+              fields: {}
+            };
+            for(let key in datasourceFields) {
+              model.fields[key] = {from: datasourceFields[key].name, validation: { required: !datasourceFields[key].nullable } };
+            }
 
-          return model
-        },
-        mergeSchedulerEventWithDatasourceActive: (datasource, item) => {
-          //In order to merge the new event info with the active item from datasorce.
-          return Object.assign(datasource.active, item);
-        },
-        setDatasourceActiveItem: function (datasource, item, keyField) {
-          if (item) {
-            for (let key in datasource.data) {
-              let dsItem = datasource.data[key][keyField];
-              if (dsItem !== null && dsItem === item[keyField]) {
-                datasource.active = datasource.copy(datasource.data[key], {});
-                return datasource.active;
-              }
-            }
-            // If item is not present clean active
-            datasource.startEditing({});
-            return datasource.active;
-          }
-        },
-        getSchedulerProperties: function(options, datasource, scope) {
-          let schedulerStartDate = (options.initialDateStrategy === 'Expression' ? scope.$eval(generateBlocklyCall(options.initialDateBlocklyInfo)) : options.initialDate);
-          let lastSearchedPeriod = {start: null, end: null};
-          let needsToFetchData = function(searchablePeriod) {
-            return !angular.equals(lastSearchedPeriod, searchablePeriod);
-          };
-          let visibleViews = [];
-          if(options.views) {
-            for(let viewIndex in options.views) {
-              let view = options.views[viewIndex];
-              if(view.visible) {
-                visibleViews.push(view);
+            return model
+          },
+          mergeSchedulerEventWithDatasourceActive: (datasource, item) => {
+            //In order to merge the new event info with the active item from datasorce.
+            return Object.assign(datasource.active, item);
+          },
+          setDatasourceActiveItem: function (datasource, item, keyField) {
+            if (item) {
+              for (let key in datasource.data) {
+                let dsItem = datasource.data[key][keyField];
+                if (dsItem !== null && dsItem === item[keyField]) {
+                  datasource.active = datasource.copy(datasource.data[key], {});
+                  return datasource.active;
+                }
               }
+              // If item is not present clean active
+              datasource.startEditing({});
+              return datasource.active;
             }
-          } else {
-            if(options.showDayTab) {
-              visibleViews.push('day');
-            }
-            if(options.showAgendaTab) {
-              visibleViews.push('agenda');
-            }
-            if(options.showMonthTab) {
-              visibleViews.push('month');
-            }
-            if(options.showTimelineTab) {
-              visibleViews.push('timeline');
-            }
-            if(options.showWeekTab) {
-              visibleViews.push('week');
-            }
-            if(options.showWorkWeekTab) {
-              visibleViews.push('workWeek');
+          },
+          getSchedulerProperties: function(options, datasource, scope) {
+            let schedulerStartDate = (options.initialDateStrategy === 'Expression' ? scope.$eval(generateBlocklyCall(options.initialDateBlocklyInfo)) : options.initialDate);
+            let lastSearchedPeriod = {start: null, end: null};
+            let needsToFetchData = function(searchablePeriod) {
+              return !angular.equals(lastSearchedPeriod, searchablePeriod);
+            };
+            let visibleViews = [];
+            if(options.views) {
+              for(let viewIndex in options.views) {
+                let view = options.views[viewIndex];
+                if(view.visible) {
+                  visibleViews.push(view);
+                }
+              }
+            } else {
+              if(options.showDayTab) {
+                visibleViews.push('day');
+              }
+              if(options.showAgendaTab) {
+                visibleViews.push('agenda');
+              }
+              if(options.showMonthTab) {
+                visibleViews.push('month');
+              }
+              if(options.showTimelineTab) {
+                visibleViews.push('timeline');
+              }
+              if(options.showWeekTab) {
+                visibleViews.push('week');
+              }
+              if(options.showWorkWeekTab) {
+                visibleViews.push('workWeek');
+              }
             }
-          }
 
 
-          let cronSchedulerProperties = {
-            dateHeaderTemplate: kendo.template(`#=kendo.toString(date, ${kendo.culture().name.toLowerCase().includes('pt')?'\'ddd dd/M\'':'\'ddd M/dd\''})#`),
-            showWorkHours: options.showWorkHours,
-            selectable: true,
-            date: schedulerStartDate,
-            mobile: true,
-            allDaySlot: options.allDaySlot,
-            messages: {
-              editor: {
-                timezone: $translate.instant('TimezoneEvent')
-              }
-            },
-            currentTimeMarker: (options.currentTimeMarker ? {
-              updateInterval: 10000,
-              useLocalTimezone: false
-            } : options.currentTimeMarker),
-            views: visibleViews,
-            navigate: function(e) {
-              //Navigated from
-              let view = e.sender.view();
-
-              // The view has:
-              // A startDate method which returns the start date of the view.
-              // An endDate method which returns the end date of the view.
-
-              //kendo.format("view:: start: {0:d}; end: {1:d};", view.startDate(), view.endDate())
-            },
-            dataBound: function(e) {
-              //Navigated to
-              let view = e.sender.view();
+            let cronSchedulerProperties = {
+              dateHeaderTemplate: kendo.template(`#=kendo.toString(date, ${kendo.culture().name.toLowerCase().includes('pt')?'\'ddd dd/M\'':'\'ddd M/dd\''})#`),
+              showWorkHours: options.showWorkHours,
+              selectable: true,
+              date: schedulerStartDate,
+              mobile: true,
+              allDaySlot: options.allDaySlot,
+              messages: {
+                editor: {
+                  timezone: $translate.instant('TimezoneEvent')
+                }
+              },
+              currentTimeMarker: (options.currentTimeMarker ? {
+                updateInterval: 10000,
+                useLocalTimezone: false
+              } : options.currentTimeMarker),
+              views: visibleViews,
+              navigate: function(e) {
+                //Navigated from
+                let view = e.sender.view();
+
+                // The view has:
+                // A startDate method which returns the start date of the view.
+                // An endDate method which returns the end date of the view.
+
+                //kendo.format("view:: start: {0:d}; end: {1:d};", view.startDate(), view.endDate())
+              },
+              dataBound: function(e) {
+                //Navigated to
+                let view = e.sender.view();
 
-              // The view has:
-              // A startDate method which returns the start date of the view.
-              // An endDate method which returns the end date of the view.
+                // The view has:
+                // A startDate method which returns the start date of the view.
+                // An endDate method which returns the end date of the view.
 
-              //kendo.format("view:: start: {0:d}; end: {1:d};", view.startDate(), view.endDate())
-            },
-            change: (e) => {
-              if (e && e.events && e.events.length) {
-                this.setDatasourceActiveItem(datasource, e.events[0], 'id');
-              } else {
-                datasource.startInserting({});
-              }
-              console.log('Active: ', datasource.active);
-            },
-            edit: function (e) {
-              if (options && options.allowCustomAction) {
-                let container = e.container;
-
-                let btnLabel = options.customActionLabel ? options.customActionLabel : $translate.instant(Details);
-                /* ACTION: ADD custom button */
-                let detailButton = $('<a class="k-button">' + btnLabel + '</a>');
-
-                //wire its click event
-                detailButton.click(function (e) {
-                  scope.safeApply(() => {
-                    scope.$eval(generateBlocklyCall(options.customActionBlockly));
+                //kendo.format("view:: start: {0:d}; end: {1:d};", view.startDate(), view.endDate())
+              },
+              change: (e) => {
+                if (e && e.events && e.events.length) {
+                  this.setDatasourceActiveItem(datasource, e.events[0], 'id');
+                } else {
+                  datasource.startInserting({});
+                }
+                console.log('Active: ', datasource.active);
+              },
+              edit: function (e) {
+                if (options && options.allowCustomAction) {
+                  let container = e.container;
+
+                  let btnLabel = options.customActionLabel ? options.customActionLabel : $translate.instant(Details);
+                  /* ACTION: ADD custom button */
+                  let detailButton = $('<a class="k-button">' + btnLabel + '</a>');
+
+                  //wire its click event
+                  detailButton.click(function (e) {
+                    scope.safeApply(() => {
+                      scope.$eval(generateBlocklyCall(options.customActionBlockly));
+                    });
                   });
-                });
 
-                //add the button to the container
-                let buttonsContainer = container.find(".k-edit-buttons");
-                buttonsContainer.append(detailButton);
+                  //add the button to the container
+                  let buttonsContainer = container.find(".k-edit-buttons");
+                  buttonsContainer.append(detailButton);
 
-              }
+                }
 
-            },
-            dataSource: {
-              batch: false, // Enable batch updates
-              transport: {
-                read: function(read) {
-                  read.data = read.data || {};
-                  // verify if lastSearchedPeriod is the same searched now. If so ignore search.
-                  if(needsToFetchData(read.data)) {
-                    lastSearchedPeriod = read.data;
-
-                    if(jQuery.isEmptyObject(read.data)) {
-                      read.data[options.schedulerDataModel.start.name] = schedulerStartDate;
-                    }
-                    let paramsOData = kendo.data.transports.odata.parameterMap(read.data, 'read');
-                    let orderBy = '';
-                    let fetchData = {};
-                    fetchData.params = paramsOData;
-                    datasource.fetch(fetchData, {
-                      success: function(data) {
-                        read.success(angular.copy(data));
-                      },
-                      canceled: function(data) {
-                        // notify the data source that the request failed
-                        read.error(angular.copy(data));
+              },
+              dataSource: {
+                batch: false, // Enable batch updates
+                transport: {
+                  read: function(read) {
+                    read.data = read.data || {};
+                    // verify if lastSearchedPeriod is the same searched now. If so ignore search.
+                    if(needsToFetchData(read.data)) {
+                      lastSearchedPeriod = read.data;
+
+                      if(jQuery.isEmptyObject(read.data)) {
+                        read.data[options.schedulerDataModel.start.name] = schedulerStartDate;
                       }
-                    }, false);
-                  } else {
-                    read.error();
-                  }
-                }.bind(this),
-                update: (update) => {
-                  let item = this.parseToDatasourceSchema(datasource, update.data, options);
-                  datasource.startEditing(datasource.active);
-                  this.mergeSchedulerEventWithDatasourceActive(datasource, item);
-                  datasource.update(
-                    datasource.active,
-                    (data) => {
-                      let updatedItem = angular.copy(data);
-                      update.success(updatedItem);
-                      datasource.fetch({}, {
-                        success: (allData) => {
-                          this.setDatasourceActiveItem(datasource, updatedItem, 'id');
+                      let paramsOData = kendo.data.transports.odata.parameterMap(read.data, 'read');
+                      let orderBy = '';
+                      let fetchData = {};
+                      fetchData.params = paramsOData;
+                      datasource.fetch(fetchData, {
+                        success: function(data) {
+                          read.success(angular.copy(data));
                         },
-                        canceled: (data) => {
+                        canceled: function(data) {
                           // notify the data source that the request failed
+                          read.error(angular.copy(data));
                         }
                       }, false);
-                    },
-                    (data) => {
-                      update.error(angular.copy(data));
+                    } else {
+                      read.error();
                     }
-                  );
-                },
-                create: (create) => {
-                  let item = this.parseToDatasourceSchema(datasource, create.data, options);
-                  this.mergeSchedulerEventWithDatasourceActive(datasource, item);
-                  datasource.insert(
-                    datasource.active,
-                    (data) => {
-                      let newItem = angular.copy(data);
-                      create.success(newItem);
-                      datasource.fetch({}, {
-                        success: (allData) => {
-                          this.setDatasourceActiveItem(datasource, newItem, 'id');
+                  }.bind(this),
+                  update: (update) => {
+                    let item = this.parseToDatasourceSchema(datasource, update.data, options);
+                    datasource.startEditing(datasource.active);
+                    this.mergeSchedulerEventWithDatasourceActive(datasource, item);
+                    datasource.update(
+                        datasource.active,
+                        (data) => {
+                          let updatedItem = angular.copy(data);
+                          update.success(updatedItem);
+                          datasource.fetch({}, {
+                            success: (allData) => {
+                              this.setDatasourceActiveItem(datasource, updatedItem, 'id');
+                            },
+                            canceled: (data) => {
+                              // notify the data source that the request failed
+                            }
+                          }, false);
                         },
-                        canceled: function(data) {
-                          // notify the data source that the request failed
+                        (data) => {
+                          update.error(angular.copy(data));
                         }
-                      }, false);
-                    },
-                    (data) => {
-                      create.error(angular.copy(data));
-                    }
-                  );
+                    );
+                  },
+                  create: (create) => {
+                    let item = this.parseToDatasourceSchema(datasource, create.data, options);
+                    this.mergeSchedulerEventWithDatasourceActive(datasource, item);
+                    datasource.insert(
+                        datasource.active,
+                        (data) => {
+                          let newItem = angular.copy(data);
+                          create.success(newItem);
+                          datasource.fetch({}, {
+                            success: (allData) => {
+                              this.setDatasourceActiveItem(datasource, newItem, 'id');
+                            },
+                            canceled: function(data) {
+                              // notify the data source that the request failed
+                            }
+                          }, false);
+                        },
+                        (data) => {
+                          create.error(angular.copy(data));
+                        }
+                    );
+                  },
+                  destroy: function(destroy) {
+                    datasource.removeSilent(
+                        this.parseToDatasourceSchema(datasource, destroy.data, options),
+                        function(data) {
+                          destroy.success(angular.copy(data));
+                        },
+                        function(data) {
+                          destroy.error(angular.copy(data));
+                        }
+                    );
+                  }.bind(this)
                 },
-                destroy: function(destroy) {
-                  datasource.removeSilent(
-                    this.parseToDatasourceSchema(datasource, destroy.data, options),
-                    function(data) {
-                      destroy.success(angular.copy(data));
-                    },
-                    function(data) {
-                      destroy.error(angular.copy(data));
-                    }
-                  );
-                }.bind(this)
-              },
-              schema: {
-                model: this.getSchedulerModel(options.schedulerDataModel)
+                schema: {
+                  model: this.getSchedulerModel(options.schedulerDataModel)
+                }
               }
+            };
+            if(!options.views) {
+              cronSchedulerProperties.editable = options.editable;
+            }
+            if(window.fixedTimeZone && window.timeZone) {
+              cronSchedulerProperties.timezone = window.timeZone;
+            }
+            return cronSchedulerProperties;
+          },
+          showError: function(scope, title, message) {
+            let info = {
+              message: message,
+              title: title,
+              delay: null
+            };
+            scope.Notification.error(info);
+          },
+          parseToDatasourceSchema: function(datasource, object, options) {
+            let parsedObj = {};
+            //Antigo parse setava nulo no campo title (se viesse vazio e quebrava o kendo na visualização do tipo mensal)
+            for(let key in datasource.schema) {
+              let name = datasource.schema[key].name;
+              parsedObj[name] = object[name];
+            }
+
+            parsedObj[options.schedulerDataModel.isAllDay.name] = parsedObj[options.schedulerDataModel.isAllDay.name] === true;
+            if (!parsedObj[options.schedulerDataModel.id.name])
+              delete parsedObj[options.schedulerDataModel.id.name];
+            return parsedObj;
+          },
+          link: function(scope, element, attrs, ngModelCtrl) {
+            let schedulerElement = $('<div></div>');
+            let options = JSON.parse(attrs.options || "{}");
+            let datasource;
+            if(options.dataSourceScreen && options.dataSourceScreen.entityDataSource) {
+              datasource = eval(options.dataSourceScreen.entityDataSource.name);
+            }
+            //Validate Component Configuration
+            if(!datasource) {
+              // There is no Datasource
+              let errorObject = {};
+              $translate('DatasourceNotFoundMessage').then((datasourceNotFoundMessage) => {
+                errorObject.message = datasourceNotFoundMessage;
+                return $translate('Scheduler');
+              }).then((scheduler) => {
+                errorObject.component = scheduler;
+                return $translate('DatasourceNotFoundTitle');
+              }).then((datasourceNotFoundTitle) => {
+                errorObject.title = datasourceNotFoundTitle;
+                this.showError(scope, errorObject.title, errorObject.message.replace('{0}', errorObject.component));
+              });
+              return;
+            }else if(jQuery.isEmptyObject(options.schedulerDataModel)){
+              //TODO ADD Message to not relation fields added
+              return;
             }
-          };
-          if(!options.views) {
-            cronSchedulerProperties.editable = options.editable;
-          }
-          if(window.fixedTimeZone && window.timeZone) {
-            cronSchedulerProperties.timezone = window.timeZone;
-          }
-          return cronSchedulerProperties;
-        },
-        showError: function(scope, title, message) {
-          let info = {
-            message: message,
-            title: title,
-            delay: null
-          };
-          scope.Notification.error(info);
-        },
-        parseToDatasourceSchema: function(datasource, object, options) {
-          let parsedObj = {};
-          //Antigo parse setava nulo no campo title (se viesse vazio e quebrava o kendo na visualização do tipo mensal)
-          for(let key in datasource.schema) {
-            let name = datasource.schema[key].name;
-            parsedObj[name] = object[name];
-          }
-
-          parsedObj[options.schedulerDataModel.isAllDay.name] = parsedObj[options.schedulerDataModel.isAllDay.name] === true;
-          if (!parsedObj[options.schedulerDataModel.id.name])
-            delete parsedObj[options.schedulerDataModel.id.name];
-          return parsedObj;
-        },
-        link: function(scope, element, attrs, ngModelCtrl) {
-          let schedulerElement = $('<div></div>');
-          let options = JSON.parse(attrs.options || "{}");
-          let datasource;
-          if(options.dataSourceScreen && options.dataSourceScreen.entityDataSource) {
-            datasource = eval(options.dataSourceScreen.entityDataSource.name);
-          }
-          //Validate Component Configuration
-          if(!datasource) {
-            // There is no Datasource
-            let errorObject = {};
-            $translate('DatasourceNotFoundMessage').then((datasourceNotFoundMessage) => {
-              errorObject.message = datasourceNotFoundMessage;
-              return $translate('Scheduler');
-            }).then((scheduler) => {
-              errorObject.component = scheduler;
-              return $translate('DatasourceNotFoundTitle');
-            }).then((datasourceNotFoundTitle) => {
-              errorObject.title = datasourceNotFoundTitle;
-              this.showError(scope, errorObject.title, errorObject.message.replace('{0}', errorObject.component));
-            });
-            return;
-          }else if(jQuery.isEmptyObject(options.schedulerDataModel)){
-            //TODO ADD Message to not relation fields added
-            return;
-          }
 
-          let baseUrl = 'node_modules/cronapp-lib-js/dist/js/kendo-ui/js/messages/kendo.messages.';
-          if($translate.use() === 'pt_br') {
-            baseUrl += "pt-BR.min.js";
-          } else {
-            baseUrl += "en-US.min.js";
-          }
+            let baseUrl = 'node_modules/cronapp-lib-js/dist/js/kendo-ui/js/messages/kendo.messages.';
+            if($translate.use() === 'pt_br') {
+              baseUrl += "pt-BR.min.js";
+            } else {
+              baseUrl += "en-US.min.js";
+            }
 
-          this.initCulture();
+            this.initCulture();
 
-          $.getScript(baseUrl, function() {
+            $.getScript(baseUrl, function() {
 
-            let kendoDatasource = app.kendoHelper.getDataSource(options.dataSourceScreen.entityDataSource, scope, true, options.dataSourceScreen.rowsPerPage);
+              let kendoDatasource = app.kendoHelper.getDataSource(options.dataSourceScreen.entityDataSource, scope, true, options.dataSourceScreen.rowsPerPage);
 
-            let schedulerProperties = this.getSchedulerProperties(options, datasource, scope);
+              let schedulerProperties = this.getSchedulerProperties(options, datasource, scope);
 
-            schedulerElement.kendoScheduler(schedulerProperties);
+              schedulerElement.kendoScheduler(schedulerProperties);
 
-            // Get reference to the kendo.ui.Scheduler instance
-            let scheduler = schedulerElement.data("kendoScheduler");
-            let lastView;
+              // Get reference to the kendo.ui.Scheduler instance
+              let scheduler = schedulerElement.data("kendoScheduler");
+              let lastView;
 
-            scheduler.bind('navigate', function(e) {
-              scheduler._previousView = e.sender.view();
-            });
-            scheduler.bind('dataBound', function(e) {
-              scheduler._currentView = e.sender.view();
-              if(scheduler._previousView) {
-                let sameView = compare(scheduler._previousView._dates, scheduler._currentView._dates);
-                if(!sameView) {
-                  let params = {};
-                  params[options.schedulerDataModel.start.name] = scheduler._currentView._startDate;
-                  params[options.schedulerDataModel.end.name] = scheduler._currentView._endDate;
-                  scheduler.dataSource.read(params);
-                  scheduler._previousView = scheduler._currentView;
+              scheduler.bind('navigate', function(e) {
+                scheduler._previousView = e.sender.view();
+              });
+              scheduler.bind('dataBound', function(e) {
+                scheduler._currentView = e.sender.view();
+                if(scheduler._previousView) {
+                  let sameView = compare(scheduler._previousView._dates, scheduler._currentView._dates);
+                  if(!sameView) {
+                    let params = {};
+                    params[options.schedulerDataModel.start.name] = scheduler._currentView._startDate;
+                    params[options.schedulerDataModel.end.name] = scheduler._currentView._endDate;
+                    scheduler.dataSource.read(params);
+                    scheduler._previousView = scheduler._currentView;
+                  }
                 }
-              }
 
-            });
+              });
 
-            function compare(arr1, arr2) {
-              if(!arr1 || !arr2) return
-              let result;
-              arr1.forEach((e1, i) => arr2.forEach(e2 => {
-                if(e1.getTime() !== e2.getTime()) {
-                  result = false
-                } else {
-                  result = true
-                }
-              }));
-              return result
-            }
-          }.bind(this));
+              function compare(arr1, arr2) {
+                if(!arr1 || !arr2) return
+                let result;
+                arr1.forEach((e1, i) => arr2.forEach(e2 => {
+                  if(e1.getTime() !== e2.getTime()) {
+                    result = false
+                  } else {
+                    result = true
+                  }
+                }));
+                return result
+              }
+            }.bind(this));
 
-          element.html(schedulerElement);
-          $compile(schedulerElement)(element.scope());
-        }
-      }
-    }])
-
-
-    .directive('cronGrid', ['$compile', '$translate', function($compile, $translate) {
-      return {
-        restrict: 'E',
-        replace: true,
-        require: 'ngModel',
-        initCulture: function() {
-          var culture = $translate.use();
-          culture = culture.replace(/_/gm,'-');
-          var parts = culture.split('-');
-          parts[parts.length - 1] = parts[parts.length - 1].toUpperCase();
-          culture = parts.join('-');
-          kendo.culture(culture);
-        },
-        changeObjectField: function(dataSource, obj){
-          obj = dataSource.getKeyValues(obj);
-          var keys = Object.keys(obj);
-          if(keys.length === 1){
-            obj = obj[keys];
+            element.html(schedulerElement);
+            $compile(schedulerElement)(element.scope());
           }
-          return obj;
-        },
-        generateToolbarButtonCall: function(toolbarButton, scope, options) {
-          var buttonCall;
-          var generateObjTemplate = function(functionToCall, title, iconClass) {
-            var obj = {
-              template: function() {
-                var buttonId = app.common.generateId();
-                return createTemplateButton(buttonId, functionToCall, title, iconClass);
-              }.bind(this)
-            };
-            return obj;
-          }.bind(this);
-
-          var createTemplateButton = function(buttonId, functionToCall, title, iconClass) {
-            var template = '';
+        }
+      }])
 
-            let security = toolbarButton.security ? `cronapp-security="${toolbarButton.security}"` : "";
 
-            if (toolbarButton.type == "SaveOrCancelChanges") {
-              if (toolbarButton.saveButton)
-                template = '<a #SECURITY# role="button" class="saveorcancelchanges k-button k-button-icontext k-grid-save-changes" id="#BUTTONID#" href="javascript:void(0)"><span class="k-icon k-i-check"></span>#TITLE#</a>';
-              else
-                template = '<a #SECURITY# role="button" class="saveorcancelchanges k-button k-button-icontext k-grid-cancel-changes" id="#BUTTONID#" href="javascript:void(0)"><span class="k-icon k-i-cancel" ></span>#TITLE#</a>';
-            }
-            else if (toolbarButton.type == "Blockly" || toolbarButton.type == "Customized") {
-              template = '<a #SECURITY# class="k-button k-grid-custom" id="#BUTTONID#" href="javascript:void(0)"><span class="#ICONCLASS#" ></span>#TITLE#</a>';
-            }
-            else if (toolbarButton.type == "Native" && toolbarButton.title == 'create') {
-              template = '<a #SECURITY# role="button" id="#BUTTONID#" class="k-button k-button-icontext k-grid-add" href="javascript:void(0)"><span class="k-icon k-i-plus"></span>{{"Add" | translate}}</a>';
-            }
-            else if (toolbarButton.type == "Native" && toolbarButton.title == 'excel') {
-              template = '<a #SECURITY# role="button" id="#BUTTONID#" class="k-button k-button-icontext k-grid-excel" href="javascript:void(0)"><span class="k-icon k-i-file-excel"></span>{{"exportExcel" | translate}}</a>';
-            }
-            else if (toolbarButton.type == "Native" && toolbarButton.title == 'pdf') {
-              template = '<a #SECURITY# role="button" id="#BUTTONID#" class="k-button k-button-icontext k-grid-pdf" href="javascript:void(0)"><span class="k-icon k-i-file-pdf"></span>{{"exportPDF" | translate}}</a>';
+      .directive('cronGrid', ['$compile', '$translate', function($compile, $translate) {
+        return {
+          restrict: 'E',
+          replace: true,
+          require: 'ngModel',
+          initCulture: function() {
+            var culture = $translate.use();
+            culture = culture.replace(/_/gm,'-');
+            var parts = culture.split('-');
+            parts[parts.length - 1] = parts[parts.length - 1].toUpperCase();
+            culture = parts.join('-');
+            kendo.culture(culture);
+          },
+          changeObjectField: function(dataSource, obj){
+            obj = dataSource.getKeyValues(obj);
+            var keys = Object.keys(obj);
+            if(keys.length === 1){
+              obj = obj[keys];
             }
+            return obj;
+          },
+          generateToolbarButtonCall: function(toolbarButton, scope, options) {
+            var buttonCall;
+            var generateObjTemplate = function(functionToCall, title, iconClass) {
+              var obj = {
+                template: function() {
+                  var buttonId = app.common.generateId();
+                  return createTemplateButton(buttonId, functionToCall, title, iconClass);
+                }.bind(this)
+              };
+              return obj;
+            }.bind(this);
 
-            template = template
-              .split('#BUTTONID#').join(buttonId)
-              .split('#FUNCTIONCALL#').join(this.encodeHTML(functionToCall))
-              .split('#TITLE#').join(title)
-              .split('#ICONCLASS#').join(iconClass)
-              .split('#SECURITY#').join(security);
+            var createTemplateButton = function(buttonId, functionToCall, title, iconClass) {
+              var template = '';
 
-            var cronappDatasource = eval(options.dataSourceScreen.entityDataSource.name);
+              let security = toolbarButton.security ? `cronapp-security="${toolbarButton.security}"` : "";
 
-            var waitRender = setInterval(function() {
-              if ($('#' + buttonId).length > 0) {
-                scope.safeApply(function() {
-                  var x = angular.element($('#' + buttonId ));
-                  $compile(x)(scope);
-                });
+              if (toolbarButton.type == "SaveOrCancelChanges") {
+                if (toolbarButton.saveButton)
+                  template = '<a #SECURITY# role="button" class="saveorcancelchanges k-button k-button-icontext k-grid-save-changes" id="#BUTTONID#" href="javascript:void(0)"><span class="k-icon k-i-check"></span>#TITLE#</a>';
+                else
+                  template = '<a #SECURITY# role="button" class="saveorcancelchanges k-button k-button-icontext k-grid-cancel-changes" id="#BUTTONID#" href="javascript:void(0)"><span class="k-icon k-i-cancel" ></span>#TITLE#</a>';
+              }
+              else if (toolbarButton.type == "Blockly" || toolbarButton.type == "Customized") {
+                template = '<a #SECURITY# class="k-button k-grid-custom" id="#BUTTONID#" href="javascript:void(0)"><span class="#ICONCLASS#" ></span>#TITLE#</a>';
+              }
+              else if (toolbarButton.type == "Native" && toolbarButton.title == 'create') {
+                template = '<a #SECURITY# role="button" id="#BUTTONID#" class="k-button k-button-icontext k-grid-add" href="javascript:void(0)"><span class="k-icon k-i-plus"></span>{{"Add" | translate}}</a>';
+              }
+              else if (toolbarButton.type == "Native" && toolbarButton.title == 'excel') {
+                template = '<a #SECURITY# role="button" id="#BUTTONID#" class="k-button k-button-icontext k-grid-excel" href="javascript:void(0)"><span class="k-icon k-i-file-excel"></span>{{"exportExcel" | translate}}</a>';
+              }
+              else if (toolbarButton.type == "Native" && toolbarButton.title == 'pdf') {
+                template = '<a #SECURITY# role="button" id="#BUTTONID#" class="k-button k-button-icontext k-grid-pdf" href="javascript:void(0)"><span class="k-icon k-i-file-pdf"></span>{{"exportPDF" | translate}}</a>';
+              }
 
-                $('#' + buttonId).click(function() {
+              template = template
+                  .split('#BUTTONID#').join(buttonId)
+                  .split('#FUNCTIONCALL#').join(this.encodeHTML(functionToCall))
+                  .split('#TITLE#').join(title)
+                  .split('#ICONCLASS#').join(iconClass)
+                  .split('#SECURITY#').join(security);
 
-                  var currentGrid = options.refComponent;
-                  var selectedRows = [];
-                  currentGrid.select().each(function() {
-                    var gridRow = currentGrid.dataItem(this);
-                    cronappDatasource.data.forEach(function(dsRow) {
-                      if (dsRow.__$id == gridRow.__$id)
-                        selectedRows.push(dsRow);
-                    });
+              var cronappDatasource = eval(options.dataSourceScreen.entityDataSource.name);
+
+              var waitRender = setInterval(function() {
+                if ($('#' + buttonId).length > 0) {
+                  scope.safeApply(function() {
+                    var x = angular.element($('#' + buttonId ));
+                    $compile(x)(scope);
                   });
 
-                  var consolidated = {
-                    item: selectedRows.length ? cronappDatasource.active : null,
-                    index: selectedRows.length ? cronappDatasource.cursor : null
-                  }
+                  $('#' + buttonId).click(function() {
 
-                  let selectedRowsKeyOrObj = [];
-                  if(options.fieldType && options.fieldType === 'key') {
-                    selectedRows.forEach(item => {
-                      selectedRowsKeyOrObj.push(this.changeObjectField(cronappDatasource, cronappDatasource.findObjInDs(item)));
+                    var currentGrid = options.refComponent;
+                    var selectedRows = [];
+                    currentGrid.select().each(function() {
+                      var gridRow = currentGrid.dataItem(this);
+                      cronappDatasource.data.forEach(function(dsRow) {
+                        if (dsRow.__$id == gridRow.__$id)
+                          selectedRows.push(dsRow);
+                      });
                     });
-                  }
-                  else {
-                    selectedRowsKeyOrObj = selectedRows;
-                  }
-
-                  var contextVars = {
-                    'currentData': cronappDatasource.data,
-                    'datasource': cronappDatasource.copyWithoutAngularObj(),
-                    'selectedIndex': selectedRows.length ? cronappDatasource.cursor : null,
-                    'index': selectedRows.length ? cronappDatasource.cursor : null,
-                    'selectedRow': selectedRows.length ? cronappDatasource.active : null,
-                    'consolidated': consolidated,
-                    'item': selectedRows.length ? cronappDatasource.active : null,
-                    'selectedKeys': selectedRows.length ? cronappDatasource.getKeyValues(cronappDatasource.findObjInDs(selectedRows[0]), true) : null,
-                    'selectedRows': selectedRowsKeyOrObj
-                  };
 
-                  scope.$eval(functionToCall, contextVars) ;
-                }.bind(this));
+                    var consolidated = {
+                      item: selectedRows.length ? cronappDatasource.active : null,
+                      index: selectedRows.length ? cronappDatasource.cursor : null
+                    }
 
-                clearInterval(waitRender);
-              }
-            }.bind(this),200);
+                    let selectedRowsKeyOrObj = [];
+                    if(options.fieldType && options.fieldType === 'key') {
+                      selectedRows.forEach(item => {
+                        selectedRowsKeyOrObj.push(this.changeObjectField(cronappDatasource, cronappDatasource.findObjInDs(item)));
+                      });
+                    }
+                    else {
+                      selectedRowsKeyOrObj = selectedRows;
+                    }
 
-            return template;
-          }.bind(this);
-
-          var call = '';
-          if (toolbarButton.type == 'Customized')
-            call = toolbarButton.execute;
-          else if (toolbarButton.methodCall)
-            call = toolbarButton.methodCall;
-          else
-            call = generateBlocklyCall(toolbarButton.blocklyInfo);
-
-          var title = toolbarButton.title == undefined ? '': toolbarButton.title;
-          buttonCall = generateObjTemplate(call, title, toolbarButton.iconClass);
-          return buttonCall;
-        },
-        generateModalSaveOrCancelButtonCall: function(buttonType, functionToCall, datasourceName, modalId, scope) {
+                    var contextVars = {
+                      'currentData': cronappDatasource.data,
+                      'datasource': cronappDatasource.copyWithoutAngularObj(),
+                      'selectedIndex': selectedRows.length ? cronappDatasource.cursor : null,
+                      'index': selectedRows.length ? cronappDatasource.cursor : null,
+                      'selectedRow': selectedRows.length ? cronappDatasource.active : null,
+                      'consolidated': consolidated,
+                      'item': selectedRows.length ? cronappDatasource.active : null,
+                      'selectedKeys': selectedRows.length ? cronappDatasource.getKeyValues(cronappDatasource.findObjInDs(selectedRows[0]), true) : null,
+                      'selectedRows': selectedRowsKeyOrObj
+                    };
+
+                    scope.$eval(functionToCall, contextVars) ;
+                  }.bind(this));
 
-          var buttonId = app.common.generateId();
-          var compileTemplateAngular = function(buttonType, functionToCall, datasourceName, modalId) {
-            var template;
-            if (buttonType == 'save')
-              template = '<button id="#BUTTONID#" aria-label="#ARIALABELSAVE#" class="btn btn-primary btn-fab ng-binding grid-save-button-modal k-button" data-component="crn-button" ng-click="#FUNCTIONCALL#" onclick="(!#DATASOURCENAME#.missingRequiredField(true)?$(\'##MODALID#\').modal(\'hide\'):void(0))"><span class="k-icon k-i-check"></span></button>';
-            else
-              template = '<button id="#BUTTONID#" aria-label="#ARIALABELCANCEL#" type="button" class="btn btn-default btn-fab ng-binding k-button" data-component="crn-button" data-dismiss="modal"><span class="k-icon k-i-cancel"></span></button>'
-            template = template
-              .split('#BUTTONID#').join(buttonId)
-              .split('#FUNCTIONCALL#').join(functionToCall)
-              .split('#DATASOURCENAME#').join(datasourceName)
-              .split('#ARIALABELSAVE#').join($translate.instant('SaveChanges'))
-              .split('#ARIALABELCANCEL#').join($translate.instant('CancelChanges'))
-              .split('#MODALID#').join(modalId);
-
-            var waitRender = setInterval(function() {
-              if ($('#' + buttonId).length > 0) {
-                scope.safeApply(function() {
-                  var x = angular.element($('#' + buttonId ));
-                  $compile(x)(scope);
                   clearInterval(waitRender);
-                });
-              }
-            },200);
+                }
+              }.bind(this),200);
 
-            return template;
-          };
-          buttonCall = compileTemplateAngular(buttonType, functionToCall, datasourceName, modalId);
-          return buttonCall;
-        },
-        addButtonsInModal: function(modal, datasourceName, scope) {
-          var $footerModal = $('#' + modal).find('.modal-footer');
-          if (!$footerModal.find('.grid-save-button-modal').length) {
-            var functionToCall = datasourceName + '.post();'
-            var buttonSave = this.generateModalSaveOrCancelButtonCall('save', functionToCall, datasourceName, modal, scope);
-            $footerModal.append(buttonSave);
-            var buttonCancel = this.generateModalSaveOrCancelButtonCall('cancel', null, null, null, scope);
-            $footerModal.append(buttonCancel);
-          }
-        },
-        getObjectId: function(obj) {
-          if (!obj)
-            obj = "";
-          else if (obj instanceof Date) {
-            var momentDate = moment.utc(obj);
-            obj = new Date(momentDate.format('YYYY-MM-DDTHH:mm:ss'));
-          }
-          else if (typeof obj === 'object') {
-            //Verifica se tem id, senão pega o primeiro campo
-            if (obj["id"])
-              obj = obj["id"];
-            else {
-              for (var key in obj) {
-                obj = obj[key];
-                break;
-              }
-            }
-          }
-          return obj;
-        },
-        encodeHTML: function(value){
-          return value.replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;')
-            .replace(/'/g, '&apos;');
-        },
-        decodeHTML: function(value){
-          return value.replace(/&apos;/g, "'")
-            .replace(/&quot;/g, '"')
-            .replace(/&gt;/g, '>')
-            .replace(/&lt;/g, '<')
-            .replace(/&amp;/g, '&');
-        },
-        getColumnByField: function(options, fieldName) {
-          var selected = null;
-          options.columns.forEach(function(column)  {
-            if (column.field == fieldName)
-              selected = column;
-          });
-          return selected;
-        },
+              return template;
+            }.bind(this);
 
-        resizeGridUsingWidthForDevice: function(grid){
-          for (let idx = 0; idx < grid.columns.length; idx++) {
-            let widthDevice = this.getWidthForDevice(grid.columns[idx]);
-            grid.columns[idx].width = widthDevice.width;
-            if (!widthDevice.visible)
-              grid.hideColumn(idx);
+            var call = '';
+            if (toolbarButton.type == 'Customized')
+              call = toolbarButton.execute;
+            else if (toolbarButton.methodCall)
+              call = toolbarButton.methodCall;
             else
-              grid.showColumn(idx);
-          }
-          if (grid.options.hasSecurity) {
-            let $lastCol = $(grid.element.find('col')).last();
-            $lastCol.css('width','0px');
-          }
-        },
+              call = generateBlocklyCall(toolbarButton.blocklyInfo);
 
-        getWidthForDevice: function(column) {
-          let widthDeviceBig = 1210;
-          let widthDeviceDesktop = 1002;
-          let widthDeviceMedium = 778;
-          let widthDeviceSmall = 424;
+            var title = toolbarButton.title == undefined ? '': toolbarButton.title;
+            buttonCall = generateObjTemplate(call, title, toolbarButton.iconClass);
+            return buttonCall;
+          },
+          generateModalSaveOrCancelButtonCall: function(buttonType, functionToCall, datasourceName, modalId, scope) {
+
+            var buttonId = app.common.generateId();
+            var compileTemplateAngular = function(buttonType, functionToCall, datasourceName, modalId) {
+              var template;
+              if (buttonType == 'save')
+                template = '<button id="#BUTTONID#" aria-label="#ARIALABELSAVE#" class="btn btn-primary btn-fab ng-binding grid-save-button-modal k-button" data-component="crn-button" ng-click="#FUNCTIONCALL#" onclick="(!#DATASOURCENAME#.missingRequiredField(true)?$(\'##MODALID#\').modal(\'hide\'):void(0))"><span class="k-icon k-i-check"></span></button>';
+              else
+                template = '<button id="#BUTTONID#" aria-label="#ARIALABELCANCEL#" type="button" class="btn btn-default btn-fab ng-binding k-button" data-component="crn-button" data-dismiss="modal"><span class="k-icon k-i-cancel"></span></button>'
+              template = template
+                  .split('#BUTTONID#').join(buttonId)
+                  .split('#FUNCTIONCALL#').join(functionToCall)
+                  .split('#DATASOURCENAME#').join(datasourceName)
+                  .split('#ARIALABELSAVE#').join($translate.instant('SaveChanges'))
+                  .split('#ARIALABELCANCEL#').join($translate.instant('CancelChanges'))
+                  .split('#MODALID#').join(modalId);
 
-          let currentWindowWidth = $(window).width();
+              var waitRender = setInterval(function() {
+                if ($('#' + buttonId).length > 0) {
+                  scope.safeApply(function() {
+                    var x = angular.element($('#' + buttonId ));
+                    $compile(x)(scope);
+                    clearInterval(waitRender);
+                  });
+                }
+              },200);
 
-          let getDevice = function(device) {
-            let wd;
-            column.widthDevices.forEach( d => {
-              if (d.device === device)
-                wd = d;
+              return template;
+            };
+            buttonCall = compileTemplateAngular(buttonType, functionToCall, datasourceName, modalId);
+            return buttonCall;
+          },
+          addButtonsInModal: function(modal, datasourceName, scope) {
+            var $footerModal = $('#' + modal).find('.modal-footer');
+            if (!$footerModal.find('.grid-save-button-modal').length) {
+              var functionToCall = datasourceName + '.post();'
+              var buttonSave = this.generateModalSaveOrCancelButtonCall('save', functionToCall, datasourceName, modal, scope);
+              $footerModal.append(buttonSave);
+              var buttonCancel = this.generateModalSaveOrCancelButtonCall('cancel', null, null, null, scope);
+              $footerModal.append(buttonCancel);
+            }
+          },
+          getObjectId: function(obj) {
+            if (!obj)
+              obj = "";
+            else if (obj instanceof Date) {
+              var momentDate = moment.utc(obj);
+              obj = new Date(momentDate.format('YYYY-MM-DDTHH:mm:ss'));
+            }
+            else if (typeof obj === 'object') {
+              //Verifica se tem id, senão pega o primeiro campo
+              if (obj["id"])
+                obj = obj["id"];
+              else {
+                for (var key in obj) {
+                  obj = obj[key];
+                  break;
+                }
+              }
+            }
+            return obj;
+          },
+          encodeHTML: function(value){
+            return value.replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&apos;');
+          },
+          decodeHTML: function(value){
+            return value.replace(/&apos;/g, "'")
+                .replace(/&quot;/g, '"')
+                .replace(/&gt;/g, '>')
+                .replace(/&lt;/g, '<')
+                .replace(/&amp;/g, '&');
+          },
+          getColumnByField: function(options, fieldName) {
+            var selected = null;
+            options.columns.forEach(function(column)  {
+              if (column.field == fieldName)
+                selected = column;
             });
+            return selected;
+          },
 
-            //Se não tiver definido o width para determinada resolução procura a proxima acima, se n tiver acima, pega a que existir
-            if (wd === undefined) {
-              if (device === "deviceSmall")
-                wd = getDevice("deviceMedium");
-              else if (device === "deviceMedium")
-                wd = getDevice("deviceDesktop");
-              else if (device === "deviceDesktop")
-                wd = getDevice("deviceBig");
+          resizeGridUsingWidthForDevice: function(grid){
+            for (let idx = 0; idx < grid.columns.length; idx++) {
+              let widthDevice = this.getWidthForDevice(grid.columns[idx]);
+              grid.columns[idx].width = widthDevice.width;
+              if (!widthDevice.visible)
+                grid.hideColumn(idx);
               else
-                wd = column.widthDevices[0];
+                grid.showColumn(idx);
             }
-            return wd;
-          };
+            if (grid.options.hasSecurity) {
+              let $lastCol = $(grid.element.find('col')).last();
+              $lastCol.css('width','0px');
+            }
+          },
+
+          getWidthForDevice: function(column) {
+            let widthDeviceBig = 1210;
+            let widthDeviceDesktop = 1002;
+            let widthDeviceMedium = 778;
+            let widthDeviceSmall = 424;
 
+            let currentWindowWidth = $(window).width();
+
+            let getDevice = function(device) {
+              let wd;
+              column.widthDevices.forEach( d => {
+                if (d.device === device)
+                  wd = d;
+              });
+
+              //Se não tiver definido o width para determinada resolução procura a proxima acima, se n tiver acima, pega a que existir
+              if (wd === undefined) {
+                if (device === "deviceSmall")
+                  wd = getDevice("deviceMedium");
+                else if (device === "deviceMedium")
+                  wd = getDevice("deviceDesktop");
+                else if (device === "deviceDesktop")
+                  wd = getDevice("deviceBig");
+                else
+                  wd = column.widthDevices[0];
+              }
+              return wd;
+            };
 
-          let widthDevice = { width: column.width };
-          if (column.visible !== undefined && column.visible !== null)
-            widthDevice.visible = column.visible;
-          else
-            widthDevice.visible = !column.hidden;
 
-          if (column.widthDevices !== null && column.widthDevices !== undefined && column.widthDevices.length > 0) {
-            if (currentWindowWidth >= widthDeviceBig)
-              widthDevice = getDevice("deviceBig");
-            else if (currentWindowWidth >= widthDeviceDesktop && currentWindowWidth < widthDeviceBig)
-              widthDevice = getDevice("deviceDesktop");
-            else if (currentWindowWidth >= widthDeviceMedium && currentWindowWidth < widthDeviceDesktop)
-              widthDevice = getDevice("deviceMedium");
+            let widthDevice = { width: column.width };
+            if (column.visible !== undefined && column.visible !== null)
+              widthDevice.visible = column.visible;
             else
-              widthDevice = getDevice("deviceSmall");
-          }
-          return widthDevice;
-        },
+              widthDevice.visible = !column.hidden;
+
+            if (column.widthDevices !== null && column.widthDevices !== undefined && column.widthDevices.length > 0) {
+              if (currentWindowWidth >= widthDeviceBig)
+                widthDevice = getDevice("deviceBig");
+              else if (currentWindowWidth >= widthDeviceDesktop && currentWindowWidth < widthDeviceBig)
+                widthDevice = getDevice("deviceDesktop");
+              else if (currentWindowWidth >= widthDeviceMedium && currentWindowWidth < widthDeviceDesktop)
+                widthDevice = getDevice("deviceMedium");
+              else
+                widthDevice = getDevice("deviceSmall");
+            }
+            return widthDevice;
+          },
 
-        getColumns: function(options, datasource, scope, tooltips) {
-          var helperDirective = this;
+          getColumns: function(options, datasource, scope, tooltips) {
+            var helperDirective = this;
 
-          function getTemplate(column) {
-            var template = "#=showTreatedValue("+column.field+")#";
-            if (column.inputType == 'switch') {
-              template =
-                '<span class="k-switch km-switch k-widget km-widget k-switch-off km-switch-off" style="width: 100%">\
-              <span class="k-switch-wrapper km-switch-wrapper">\
-                <span class="k-switch-background km-switch-background" style="margin-left: #=' + column.field + ' ? "80%": "0%" #"></span>\
+            function getTemplate(column) {
+              var template = "#=showTreatedValue("+column.field+")#";
+              if (column.inputType == 'switch') {
+                template =
+                    '<span class="k-switch km-switch k-widget km-widget k-switch-off km-switch-off" style="width: 100%">\
+                  <span class="k-switch-wrapper km-switch-wrapper">\
+                    <span class="k-switch-background km-switch-background" style="margin-left: #=' + column.field + ' ? "80%": "0%" #"></span>\
                   </span>\
                   <span class="k-switch-container km-switch-container">\
                     <span class="k-switch-handle km-switch-handle" style=#=' + column.field + ' ? "float:right;margin-right:-1px": "margin-left:0%" #>\
                     </span>\
                   </span>\
                 </span>';
-            }
-            else if (column.inputType == 'checkbox' || column.type == 'boolean') {
-              template = "<input crn-set-indeterminate=#=" + column.field + "# type='checkbox' class='k-checkbox' #=" + column.field + " ? \"checked='checked'\": '' # />" +
-                "<label class='k-checkbox-label k-no-text'></label>"
-            }
-            else if (column.displayField && column.displayField.length > 0) {
-              if (hasMask(column.type) || (column.format && column.format != 'null')) {
-                template = "#= useMask("+column.displayField+",'"+column.format+"','"+column.type+"') #";
               }
-              else {
-                template = "#="+column.displayField+"#";
+              else if (column.inputType == 'checkbox' || column.type == 'boolean') {
+                template = "<input crn-set-indeterminate=#=" + column.field + "# type='checkbox' class='k-checkbox' #=" + column.field + " ? \"checked='checked'\": '' # />" +
+                    "<label class='k-checkbox-label k-no-text'></label>"
               }
+              else if (column.displayField && column.displayField.length > 0) {
+                if (hasMask(column.type) || (column.format && column.format != 'null')) {
+                  template = "#= useMask("+column.displayField+",'"+column.format+"','"+column.type+"') #";
+                }
+                else {
+                  template = "#="+column.displayField+"#";
+                }
+              }
+              else if (hasMask(column.type) || (column.format && column.format != 'null')   ) {
+                template = "#= useMask("+column.field+",'"+column.format+"','"+column.type+"') #";
+              }
+              else if (column.showAsImage) {
+                template = column.showAsImageTemplate ? column.showAsImageTemplate :  "<img src='#:${column.field}#'/>";
+                template = eval('`' + template + '`');
+              }
+              return template;
             }
-            else if (hasMask(column.type) || (column.format && column.format != 'null')   ) {
-              template = "#= useMask("+column.field+",'"+column.format+"','"+column.type+"') #";
-            }
-            else if (column.showAsImage) {
-              template = column.showAsImageTemplate ? column.showAsImageTemplate :  "<img src='#:${column.field}#'/>";
-              template = eval('`' + template + '`');
+
+            function hasMask(type){
+              if(type && (typeof type === "string")){
+                return (type.startsWith('date') || type.startsWith('month')
+                    || type.startsWith('time') || type.startsWith('week')
+                    || type.startsWith('money') || type.startsWith('number')
+                    || type.startsWith('tel') || type.startsWith('integer'));
+              }else{
+                return false;
+              }
             }
-            return template;
-          }
 
-          function hasMask(type){
-            if(type && (typeof type === "string")){
-              return (type.startsWith('date') || type.startsWith('month')
-                || type.startsWith('time') || type.startsWith('week')
-                || type.startsWith('money') || type.startsWith('number')
-                || type.startsWith('tel') || type.startsWith('integer'));
-            }else{
-              return false;
+            function getFormat(column) {
+              if (!hasMask(column.type))
+                return column.format;
+              return undefined;
             }
-          }
 
-          function getFormat(column) {
-            if (!hasMask(column.type))
-              return column.format;
-            return undefined;
-          }
+            function isRequired(fieldName) {
+              var required = false;
+              var selected = null;
+              if (datasource.schema.model.fields[fieldName]){
+                selected = datasource.schema.model.fields[fieldName];
+              }
+              if (selected)
+                required = !selected.nullable;
+              return required;
+            }
 
-          function isRequired(fieldName) {
-            var required = false;
-            var selected = null;
-            if (datasource.schema.model.fields[fieldName]){
-              selected = datasource.schema.model.fields[fieldName];
+            function getEditor(column) {
+              return editor.bind(this);
             }
-            if (selected)
-              required = !selected.nullable;
-            return required;
-          }
 
-          function getEditor(column) {
-            return editor.bind(this);
-          }
+            async function editor(container, opt) {
 
-          async function editor(container, opt) {
+              let compileAfterRender = (componentId) => {
+                return new Promise((resolve, reject) => {
+                  let waitRender = setInterval(function() {
+                    let $myElement = $('#' + componentId);
+                    if ($myElement.length > 0) {
+                      var x = angular.element($myElement);
+                      $compile(x)(scope);
+                      clearInterval(waitRender);
+                      resolve(componentId);
+                    }
+                  },10);
+                });
+              };
 
-            var column = this.getColumnByField(options, opt.field);
-            if (column.visibleCrud != undefined && !column.visibleCrud) {
-              container.parent().find('.k-edit-label [for='+ column.field +']').parent().remove();
-              container.remove();
-            }
-            var required = isRequired(opt.field) ? "required" : "";
-            var buttonId = app.common.generateId();
-            var $input = $('<input '+required+' name="' + opt.field + '" id="' + buttonId + '"from-grid=true />');
-            if (column.inputType == 'dynamicComboBox' || column.inputType == 'comboBox') {
-              var kendoConfig = app.kendoHelper.getConfigComboboxSync(column.comboboxOptions, scope);
-              kendoConfig.autoBind = true;
-              kendoConfig.optionLabel = undefined;
-              if (column.displayField) {
-                kendoConfig.change = function(e) {
-                  opt.model.set(column.displayField, this.text());
+              let changeGridModel = (value) => {
+                if (value !== opt.model[opt.field]) {
+                  opt.model[opt.field] = value;
                   opt.model.dirty = true;
-                  opt.model.dirtyFields[column.displayField] = true;
+                  opt.model.dirtyFields[opt.field] = true;
                 }
-              }
-              $input.appendTo(container).kendoDropDownList(kendoConfig, scope);
-            }
-            else if (column.inputType == 'slider') {
-              var kendoConfig = app.kendoHelper.getConfigSlider(column.sliderOptions);
-              $input.appendTo(container).kendoSlider(kendoConfig, scope);
-            }
-            else if (column.inputType == 'switch') {
-              var kendoConfig = app.kendoHelper.getConfigSwitch(column.switchOptions);
-              $input.appendTo(container).kendoMobileSwitch(kendoConfig, scope);
-            }
-            else if (column.inputType == 'checkbox' || column.type == 'boolean') {
-              var guid = app.common.generateId();
-              $input = $('<input id="'+guid+'" name="' + opt.field + '" class="k-checkbox" type="checkbox" ><label class="k-checkbox-label" for="'+guid+'"></label>');
-              $input.appendTo(container);
-            }
-            else if (column.inputType == 'date') {
-              $input.attr('cron-date', '');
-              $input.attr('options', JSON.stringify(column.dateOptions));
-              $input.data('initial-date', opt.model[opt.field]);
-              $input.appendTo(container).off('change');
-              var waitRender = setInterval(function() {
-                if ($('#' + buttonId).length > 0) {
-                  var x = angular.element($('#' + buttonId ));
-                  $compile(x)(scope);
-                  clearInterval(waitRender);
-
-                  $('#' + buttonId).on('change', function() {
-                    setTimeout(function() {
-                      opt.model[opt.field] = $('#' + buttonId ).data('rawvalue');
-                      opt.model.dirty = true;
-                      opt.model.dirtyFields[opt.field] = true;
-                    }.bind(this));
+              };
 
-                  });
+              var column = this.getColumnByField(options, opt.field);
+              if (column.visibleCrud != undefined && !column.visibleCrud) {
+                container.parent().find('.k-edit-label [for='+ column.field +']').parent().remove();
+                container.remove();
+              }
+              var required = isRequired(opt.field) ? "required" : "";
+              var buttonId = app.common.generateId();
+
+              let ngModel = `${options.dataSourceScreen.name}.active.${opt.field}`;
+              var $input = $(`<input ${required} name="${opt.field}" id="${buttonId}" from-grid=true ng-model="${ngModel}" />`); //
+              $input.data('change-grid-model', changeGridModel);
+              $input.data('column-type', column.type);
+
+              if (column.inputType == 'dynamicComboBox' || column.inputType == 'comboBox') {
+                var kendoConfig = app.kendoHelper.getConfigComboboxSync(column.comboboxOptions, scope);
+                kendoConfig.autoBind = true;
+                kendoConfig.optionLabel = undefined;
+                if (column.displayField) {
+                  kendoConfig.change = function(e) {
+                    opt.model.set(column.displayField, this.text());
+                    opt.model.dirty = true;
+                    opt.model.dirtyFields[column.displayField] = true;
+                  }
                 }
-              },10);
-            }
-            else {
-              $input.attr('type', column.type);
-              $input.attr('mask', column.format ? column.format : '');
-              if (column.format === '999.999.999-99;0' || column.format === '99.999.999/9999-99;0') {
-                $input.attr('valid', column.format === '999.999.999-99;0' ? 'cpf' : 'cnpj');
-                $input.attr('data-' + column.field.toLocaleLowerCase() + 'validation-msg', $translate.instant('invalid.' + $input.attr('valid')));
+                let dropdown = $input.appendTo(container).kendoDropDownList(kendoConfig, scope).data('kendoDropDownList');
+                $input.data('kendoDropDownList', dropdown);
+              }
+              else if (column.inputType == 'slider') {
+                var kendoConfig = app.kendoHelper.getConfigSlider(column.sliderOptions);
+                kendoConfig.change = (e) => scope.$apply(() => scope.$eval(`${ngModel}=${e.value}`));
+                let slider = $input.appendTo(container).kendoSlider(kendoConfig, scope).data('kendoSlider');
+                $input.data('kendoSlider', slider);
+              }
+              else if (column.inputType == 'switch') {
+                var kendoConfig = app.kendoHelper.getConfigSwitch(column.switchOptions);
+                $input.appendTo(container).kendoMobileSwitch(kendoConfig, scope);
+              }
+              else if (column.inputType == 'checkbox' || column.type == 'boolean') {
+                $input = $(`<input id="${buttonId}" name="${opt.field}" ng-false-value="false" ng-true-value="true" crn-allow-null-values="${!required}" class="k-checkbox" type="checkbox" from-grid=true ng-model="${ngModel}"><label class="k-checkbox-label" for="${buttonId}"></label>`);
+                $input.data('change-grid-model', changeGridModel);
+                $input.appendTo(container);
+              }
+              else if (column.inputType == 'date') {
+                $input.attr('cron-date', '');
+                $input.attr('options', JSON.stringify(column.dateOptions));
+                $input.data('initial-date', opt.model[opt.field]);
+                $input.attr('type', "datetime");
+                $input.appendTo(container).off('change');
               }
-              $input.attr('class', 'k-input k-textbox');
-              $input.data('initial-value', opt.model[opt.field]);
-              $input.appendTo(container);
-
-              var waitRender = setInterval(function() {
-                let myElement = $('#' + buttonId);
-                if (myElement.length > 0) {
-                  myElement.off('change');
-                  myElement.on('change', function() {
-                    let rawValue = myElement.data('rawvalue');
-                    let value = myElement.val();
-                    opt.model[opt.field] = rawValue || value;
-                    opt.model.dirty = true;
-                    opt.model.dirtyFields[opt.field] = true;
-                  });
-
-                  var x = angular.element(myElement);
-                  $compile(x)(scope);
-                  clearInterval(waitRender);
+              else {
+                $input.attr('type', column.type);
+                $input.attr('mask', column.format ? column.format : '');
+                if (column.format === '999.999.999-99;0' || column.format === '99.999.999/9999-99;0') {
+                  $input.attr('valid', column.format === '999.999.999-99;0' ? 'cpf' : 'cnpj');
+                  $input.attr('data-' + column.field.toLocaleLowerCase() + 'validation-msg', $translate.instant('invalid.' + $input.attr('valid')));
                 }
-              },10);
-            }
-
-          }
+                $input.css('text-align', column.alignment);
+                $input.attr('class', 'k-input k-textbox');
+                $input.data('initial-value', opt.model[opt.field]);
+                $input.appendTo(container);
+              }
 
-          function getCommandForEditButtonDatabase(opt, command) {
-            var cmd;
-            let idForCommand = app.common.generateId();
-            let ariaLabel = $translate.instant('Edit');
-            let template = `<a href class='k-button k-grid-edit k-grid-${idForCommand}' aria-label='${ariaLabel}'><span class='k-icon k-i-edit'></span></a>`;
-            if ((opt.editable == 'popupCustom') || (opt.editable == 'datasource')) {
-              cmd = {
-                name: idForCommand,
-                template: template,
-                click: function(e) {
-                  e.preventDefault();
-                  var tr = $(e.target).closest("tr");
-                  var grid = tr.closest('table');
-                  var item = this.dataItem(tr);
-                  var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-                  scope.safeApply(function() {
-                    if (!options.hideModalButtons) {
-                      helperDirective.addButtonsInModal(options.popupEdit, cronappDatasource.name, scope);
-                    }
+              compileAfterRender(buttonId).then((resultId) => {
+                $(`#${resultId}`).data('alreadycompiled', true);
+                $(`#${resultId}`).data('$compile', $compile);
+                $(`#${resultId}`).data('ref-component', options.refComponent)
+              });
 
-                    var currentItem = cronappDatasource.goTo(item);
-                    cronappDatasource.startEditing(currentItem, function(xxx) {});
-                    if (opt.editable != 'datasource') {
-                      cronapi.screen.showModal(options.popupEdit);
-                    }
-                    else {
-                      cronapi.internal.focusFormInput();
-                    }
-                  });
-                  return;
-                }
-              };
-            }
-            else {
-              cmd = {
-                name: command,
-                template: template,
-                text: { edit: " ", update: " ", cancel: " " },
-              };
             }
-            return cmd;
-          }
 
-          function getCommandForRemoveButtonDatabase(opt, command) {
-            var cmd;
-            let idForCommand = app.common.generateId();
-            let ariaLabel = $translate.instant('Remove');
-            let template = `<a href class='k-button k-grid-delete k-grid-${idForCommand}' aria-label='${ariaLabel}'><span class='k-icon k-i-close'></span></a>`;
-
-            if ((opt.editable == 'popupCustom') || (opt.editable == 'datasource')) {
-              cmd = {
-                name: idForCommand,
-                template: template,
-                click: function(e) {
-                  e.preventDefault();
-                  var tr = $(e.target).closest("tr");
-                  var item = this.dataItem(tr);
-                  var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-                  var self = this;
-                  scope.safeApply(function() {
-                    var currentItem = cronappDatasource.goTo(item);
-                    cronappDatasource.remove(currentItem);
-                  });
-                }
-              };
-            } else {
-              cmd = {
-                name: command,
-                template: template
-              };
+            function getCommandForEditButtonDatabase(opt, command) {
+              var cmd;
+              let idForCommand = app.common.generateId();
+              let ariaLabel = $translate.instant('Edit');
+              let template = `<a href class='k-button k-grid-edit k-grid-${idForCommand}' aria-label='${ariaLabel}'><span class='k-icon k-i-edit'></span></a>`;
+              if ((opt.editable == 'popupCustom') || (opt.editable == 'datasource')) {
+                cmd = {
+                  name: idForCommand,
+                  template: template,
+                  click: function(e) {
+                    e.preventDefault();
+                    var tr = $(e.target).closest("tr");
+                    var grid = tr.closest('table');
+                    var item = this.dataItem(tr);
+                    var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+                    scope.safeApply(function() {
+                      if (!options.hideModalButtons) {
+                        helperDirective.addButtonsInModal(options.popupEdit, cronappDatasource.name, scope);
+                      }
+
+                      var currentItem = cronappDatasource.goTo(item);
+                      cronappDatasource.startEditing(currentItem, function(xxx) {});
+                      if (opt.editable != 'datasource') {
+                        cronapi.screen.showModal(options.popupEdit);
+                      }
+                      else {
+                        cronapi.internal.focusFormInput();
+                      }
+                    });
+                    return;
+                  }
+                };
+              }
+              else {
+                cmd = {
+                  name: command,
+                  template: template,
+                  text: { edit: " ", update: " ", cancel: " " },
+                };
+              }
+              return cmd;
+            }
+
+            function getCommandForRemoveButtonDatabase(opt, command) {
+              var cmd;
+              let idForCommand = app.common.generateId();
+              let ariaLabel = $translate.instant('Remove');
+              let template = `<a href class='k-button k-grid-delete k-grid-${idForCommand}' aria-label='${ariaLabel}'><span class='k-icon k-i-close'></span></a>`;
+
+              if ((opt.editable == 'popupCustom') || (opt.editable == 'datasource')) {
+                cmd = {
+                  name: idForCommand,
+                  template: template,
+                  click: function(e) {
+                    e.preventDefault();
+                    var tr = $(e.target).closest("tr");
+                    var item = this.dataItem(tr);
+                    var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+                    var self = this;
+                    scope.safeApply(function() {
+                      var currentItem = cronappDatasource.goTo(item);
+                      cronappDatasource.remove(currentItem);
+                    });
+                  }
+                };
+              } else {
+                cmd = {
+                  name: command,
+                  template: template
+                };
+              }
+              return cmd;
             }
-            return cmd;
-          }
 
-          function getAggregate(column) {
-            if (column && column.aggregates) {
-              var aggregates = [];
-              column.aggregates.forEach(function(a) {
-                aggregates.push(a.type);
-              });
-              if (aggregates.length > 0)
-                return aggregates;
+            function getAggregate(column) {
+              if (column && column.aggregates) {
+                var aggregates = [];
+                column.aggregates.forEach(function(a) {
+                  aggregates.push(a.type);
+                });
+                if (aggregates.length > 0)
+                  return aggregates;
+              }
+              return undefined;
             }
-            return undefined;
-          }
 
-          function getAggregateFooter(column, group) {
-            if (column && column.aggregates) {
-              var footer = [];
-              column.aggregates.forEach(function(a) {
+            function getAggregateFooter(column, group) {
+              if (column && column.aggregates) {
+                var footer = [];
+                column.aggregates.forEach(function(a) {
 
-                var typeForLabel = '#=data.' + column.field + ' ? data.' + column.field + '.' + a.type + ' : 0 #';
-                if (a.type == 'average' || a.type == 'sum') {
-                  typeForLabel = "#=useMask(data." + column.field  + " ? data." + column.field + "." + a.type + " : 0" + ",'" + column.format + "','" + column.type + "')#";
-                }
+                  var typeForLabel = '#=data.' + column.field + ' ? data.' + column.field + '.' + a.type + ' : 0 #';
+                  if (a.type == 'average' || a.type == 'sum') {
+                    typeForLabel = "#=useMask(data." + column.field  + " ? data." + column.field + "." + a.type + " : 0" + ",'" + column.format + "','" + column.type + "')#";
+                  }
 
-                var typeForTemplate = group ? a.groupFooterTemplate : a.footerTemplate;
+                  var typeForTemplate = group ? a.groupFooterTemplate : a.footerTemplate;
 
-                if (typeForTemplate) {
-                  typeForTemplate = typeForTemplate + ': ';
-                } else {
-                  typeForTemplate = '';
-                }
+                  if (typeForTemplate) {
+                    typeForTemplate = typeForTemplate + ': ';
+                  } else {
+                    typeForTemplate = '';
+                  }
 
-                var footerTemplate = typeForTemplate + typeForLabel;
+                  var footerTemplate = typeForTemplate + typeForLabel;
 
-                if (column.alignment) {
-                  // alinha o rodapé ao conteúdo quando o alinhamento selecionado for 'Direita'
-                  if (column.alignment === 'right' && !group) {
-                    footerTemplate = '<div style="text-align: ' + column.alignment + '" class="k-fix-margin">' + footerTemplate + '</div>';
-                  } else {
-                    footerTemplate = '<div style="text-align: ' + column.alignment + '">' + footerTemplate + '</div>';
+                  if (column.alignment) {
+                    // alinha o rodapé ao conteúdo quando o alinhamento selecionado for 'Direita'
+                    if (column.alignment === 'right' && !group) {
+                      footerTemplate = '<div style="text-align: ' + column.alignment + '" class="k-fix-margin">' + footerTemplate + '</div>';
+                    } else {
+                      footerTemplate = '<div style="text-align: ' + column.alignment + '">' + footerTemplate + '</div>';
+                    }
                   }
-                }
 
-                footer.push(footerTemplate);
-              });
-              return footer.join('<br/>');
+                  footer.push(footerTemplate);
+                });
+                return footer.join('<br/>');
+              }
+              return undefined;
             }
-            return undefined;
-          }
 
-          function getAggregateHeader(column) {
-            if (hasMask(column.type) || (column.format && column.format != 'null')) {
-              return column.headerText +": #=useMask(value,'"+column.format+"','"+column.type+"')#";
+            function getAggregateHeader(column) {
+              if (hasMask(column.type) || (column.format && column.format != 'null')) {
+                return column.headerText +": #=useMask(value,'"+column.format+"','"+column.type+"')#";
+              }
+              return undefined;
             }
-            return undefined;
-          }
 
-          function getAttributes(column) {
-            let attributes = {};
-            if (column) {
-              if (column.alignment) {
-                attributes["style"] = "text-align: " + column.alignment + ";"
-              }
-              if (column.security) {
-                attributes["cronapp-security"] = column.security;
+            function getAttributes(column) {
+              let attributes = {};
+              if (column) {
+                if (column.alignment) {
+                  attributes["style"] = "text-align: " + column.alignment + ";"
+                }
+                if (column.security) {
+                  attributes["cronapp-security"] = column.security;
+                }
               }
+              return attributes;
             }
-            return attributes;
-          }
 
-          var columns = [];
-          if (options.columns) {
-            options.columns.forEach(function(column)  {
-
-              let widthDevice = this.getWidthForDevice(column);
-
-              if (column.dataType == "Database") {
+            var columns = [];
+            if (options.columns) {
+              options.columns.forEach(function(column)  {
 
-                var addColumn = {
-                  field: column.field,
-                  title: column.headerText,
-                  type: column.type,
-                  width: widthDevice.width,
-                  sortable: column.sortable,
-                  filterable: column.filterable,
-                  hidden: !widthDevice.visible
-                };
-                addColumn.template = getTemplate(column);
-                addColumn.format = getFormat(column);
-                addColumn.editor = getEditor.bind(this)(column);
-                addColumn.aggregates = getAggregate(column);
-                addColumn.footerTemplate = getAggregateFooter(column, false);
-                addColumn.groupFooterTemplate = getAggregateFooter(column, true);
-                addColumn.groupHeaderTemplate = getAggregateHeader(column);
-                addColumn.attributes = getAttributes(column);
-                addColumn.headerAttributes = addColumn.attributes;
-                addColumn.widthDevices = column.widthDevices;
-                columns.push(addColumn);
-              }
-              else if (column.dataType == "Command") {
-                //Se não for editavel, não adiciona colunas de comando
-                if (options.editable != 'no') {
-                  var command = column.command.split('|');
+                let widthDevice = this.getWidthForDevice(column);
 
-                  var commands = [];
-                  command.forEach(function(f) {
-                    var cmd;
-                    if ( f == "edit") {
-                      cmd = getCommandForEditButtonDatabase.bind(this)(options, f);
-                    }
-                    else {
-                      cmd = getCommandForRemoveButtonDatabase.bind(this)(options, f);
-                    }
-                    commands.push(cmd);
-                  }.bind(this));
+                if (column.dataType == "Database") {
 
                   var addColumn = {
-                    command: commands,
+                    field: column.field,
                     title: column.headerText,
-                    width: widthDevice.width ? widthDevice.width : 155,
-                    hidden: !widthDevice.visible,
-                    attributes: getAttributes(column)
+                    type: column.type,
+                    width: widthDevice.width,
+                    sortable: column.sortable,
+                    filterable: column.filterable,
+                    hidden: !widthDevice.visible
                   };
+                  addColumn.template = getTemplate(column);
+                  addColumn.format = getFormat(column);
+                  addColumn.editor = getEditor.bind(this)(column);
+                  addColumn.aggregates = getAggregate(column);
+                  addColumn.footerTemplate = getAggregateFooter(column, false);
+                  addColumn.groupFooterTemplate = getAggregateFooter(column, true);
+                  addColumn.groupHeaderTemplate = getAggregateHeader(column);
+                  addColumn.attributes = getAttributes(column);
+                  addColumn.headerAttributes = addColumn.attributes;
+                  addColumn.widthDevices = column.widthDevices;
                   columns.push(addColumn);
                 }
-              }
-              else if (column.dataType == "Blockly" || column.dataType == "Customized" || column.dataType == "CustomizedLink") {
-                var label = column.label == undefined ? '': column.label;
-                if (column.iconClass && label)
-                  label = '&nbsp;' + label;
+                else if (column.dataType == "Command") {
+                  //Se não for editavel, não adiciona colunas de comando
+                  if (options.editable != 'no') {
+                    var command = column.command.split('|');
+
+                    var commands = [];
+                    command.forEach(function(f) {
+                      var cmd;
+                      if ( f == "edit") {
+                        cmd = getCommandForEditButtonDatabase.bind(this)(options, f);
+                      }
+                      else {
+                        cmd = getCommandForRemoveButtonDatabase.bind(this)(options, f);
+                      }
+                      commands.push(cmd);
+                    }.bind(this));
 
-                var className = '';
-                if (column.dataType == "CustomizedLink") {
-                  className = 'k-custom-link';
-                }
-                else {
-                  className = 'k-custom-command' + (label ? ' k-button-with-label' : '');
+                    var addColumn = {
+                      command: commands,
+                      title: column.headerText,
+                      width: widthDevice.width ? widthDevice.width : 155,
+                      hidden: !widthDevice.visible,
+                      attributes: getAttributes(column)
+                    };
+                    columns.push(addColumn);
+                  }
                 }
-                if (column.theme)
-                  className += ' ' + column.theme;
+                else if (column.dataType == "Blockly" || column.dataType == "Customized" || column.dataType == "CustomizedLink") {
+                  var label = column.label == undefined ? '': column.label;
+                  if (column.iconClass && label)
+                    label = '&nbsp;' + label;
+
+                  var className = '';
+                  if (column.dataType == "CustomizedLink") {
+                    className = 'k-custom-link';
+                  }
+                  else {
+                    className = 'k-custom-command' + (label ? ' k-button-with-label' : '');
+                  }
+                  if (column.theme)
+                    className += ' ' + column.theme;
 
-                var tooltip = '';
-                if (column.tooltip && column.tooltip.length)
-                  tooltip = column.tooltip;
+                  var tooltip = '';
+                  if (column.tooltip && column.tooltip.length)
+                    tooltip = column.tooltip;
 
-                if (tooltip)  {
-                  var classForTooltip = app.common.generateId();
-                  tooltips[classForTooltip] = tooltip;
-                  className += ' ' + classForTooltip;
-                }
+                  if (tooltip)  {
+                    var classForTooltip = app.common.generateId();
+                    tooltips[classForTooltip] = tooltip;
+                    className += ' ' + classForTooltip;
+                  }
 
-                let idForCommand = app.common.generateId();
-                let ariaLabel = tooltip || label || idForCommand;
-                let template = `<a href class='k-button ${className} k-grid-${idForCommand}' aria-label='${ariaLabel}'><span class='${column.iconClass}'></span>${label}</a>`;
+                  let idForCommand = app.common.generateId();
+                  let ariaLabel = tooltip || label || idForCommand;
+                  let template = `<a href class='k-button ${className} k-grid-${idForCommand}' aria-label='${ariaLabel}'><span class='${column.iconClass}'></span>${label}</a>`;
 
-                var addColumn = {
-                  command: [{
-                    name: idForCommand,
-                    template: template,
-                    click: function(e) {
-                      e.preventDefault();
-                      var tr = $(e.target).closest("tr");
-                      var grid = tr.closest('table');
+                  var addColumn = {
+                    command: [{
+                      name: idForCommand,
+                      template: template,
+                      click: function(e) {
+                        e.preventDefault();
+                        var tr = $(e.target).closest("tr");
+                        var grid = tr.closest('table');
+
+                        var itemAsObj = this.dataItem(tr);
+                        var item = this.dataItem(tr);
+                        var index = $(grid.find('tbody')[0]).children().index(tr)
+
+
+                        var call = undefined;
+                        if (column.dataType == "Customized" || column.dataType == "CustomizedLink")
+                          call = column.execute;
+                        else
+                          call = generateBlocklyCall(column.blocklyInfo);
+
+                        var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+                        var currentGrid = options.refComponent;
+                        var selectedRows = [];
+                        currentGrid.select().each(function() {
+                          var gridRow = currentGrid.dataItem(this);
+                          cronappDatasource.data.forEach(function(dsRow) {
+                            if (dsRow.__$id == gridRow.__$id)
+                              selectedRows.push(dsRow);
+                          });
+                        });
 
-                      var itemAsObj = this.dataItem(tr);
-                      var item = this.dataItem(tr);
-                      var index = $(grid.find('tbody')[0]).children().index(tr)
+                        if (!(cronappDatasource.inserting || cronappDatasource.editing)) {
+                          var tr = e.currentTarget.parentElement.parentElement;
+                          this.select(tr);
+                        }
 
+                        let selectedRowsKeyOrObj = [];
+                        if(options.fieldType && options.fieldType === 'key') {
+                          item = helperDirective.changeObjectField(cronappDatasource, cronappDatasource.findObjInDs(item));
+                          selectedRows.forEach(row => {
+                            selectedRowsKeyOrObj.push(helperDirective.changeObjectField(cronappDatasource, cronappDatasource.findObjInDs(row)));
+                          });
+                        }
+                        else {
+                          selectedRowsKeyOrObj = selectedRows;
+                        }
 
-                      var call = undefined;
-                      if (column.dataType == "Customized" || column.dataType == "CustomizedLink")
-                        call = column.execute;
-                      else
-                        call = generateBlocklyCall(column.blocklyInfo);
-
-                      var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-                      var currentGrid = options.refComponent;
-                      var selectedRows = [];
-                      currentGrid.select().each(function() {
-                        var gridRow = currentGrid.dataItem(this);
-                        cronappDatasource.data.forEach(function(dsRow) {
-                          if (dsRow.__$id == gridRow.__$id)
-                            selectedRows.push(dsRow);
-                        });
-                      });
+                        var consolidated = {
+                          item: item,
+                          index: index
+                        }
 
-                      if (!(cronappDatasource.inserting || cronappDatasource.editing)) {
-                        var tr = e.currentTarget.parentElement.parentElement;
-                        this.select(tr);
+                        var contextVars = {
+                          'currentData': cronappDatasource.data,
+                          'datasource': cronappDatasource.copyWithoutAngularObj(),
+                          'selectedIndex': index,
+                          'index': index,
+                          'selectedRow': item,
+                          'consolidated': consolidated,
+                          'item': item,
+                          'selectedKeys': cronappDatasource.getKeyValues(cronappDatasource.findObjInDs(itemAsObj), true),
+                          'selectedRows': selectedRowsKeyOrObj
+                        };
+
+                        cronappDatasource.goTo(itemAsObj);
+                        scope.$eval(call, contextVars);
+                        return;
                       }
+                    }],
+                    width: widthDevice.width,
+                    title: column.headerText ? column.headerText: '',
+                    hidden: !widthDevice.visible,
+                    attributes: getAttributes(column)
+                  };
+                  columns.push(addColumn);
+                }
+                else if (column.dataType == "Selectable") {
+                  var checkColumn = {
+                    selectable: true,
+                    attributes: getAttributes(column)
+                  };
+                  columns.push(checkColumn);
+                }
+              }.bind(this));
+            }
 
-                      let selectedRowsKeyOrObj = [];
-                      if(options.fieldType && options.fieldType === 'key') {
-                        item = helperDirective.changeObjectField(cronappDatasource, cronappDatasource.findObjInDs(item));
-                        selectedRows.forEach(row => {
-                          selectedRowsKeyOrObj.push(helperDirective.changeObjectField(cronappDatasource, cronappDatasource.findObjInDs(row)));
-                        });
-                      }
-                      else {
-                        selectedRowsKeyOrObj = selectedRows;
-                      }
+            return columns;
+          },
+          getPageAble: function(options) {
+            var pageable = {
+              refresh:  options.allowRefreshGrid,
+              pageSizes: options.allowSelectionTotalPageToShow,
+              buttonCount: 5
+            };
 
-                      var consolidated = {
-                        item: item,
-                        index: index
-                      }
+            if (!options.allowPaging)
+              pageable = options.allowPaging;
 
-                      var contextVars = {
-                        'currentData': cronappDatasource.data,
-                        'datasource': cronappDatasource.copyWithoutAngularObj(),
-                        'selectedIndex': index,
-                        'index': index,
-                        'selectedRow': item,
-                        'consolidated': consolidated,
-                        'item': item,
-                        'selectedKeys': cronappDatasource.getKeyValues(cronappDatasource.findObjInDs(itemAsObj), true),
-                        'selectedRows': selectedRowsKeyOrObj
-                      };
-
-                      cronappDatasource.goTo(itemAsObj);
-                      scope.$eval(call, contextVars);
-                      return;
-                    }
-                  }],
-                  width: widthDevice.width,
-                  title: column.headerText ? column.headerText: '',
-                  hidden: !widthDevice.visible,
-                  attributes: getAttributes(column)
-                };
-                columns.push(addColumn);
-              }
-              else if (column.dataType == "Selectable") {
-                var checkColumn = {
-                  selectable: true,
-                  attributes: getAttributes(column)
-                };
-                columns.push(checkColumn);
-              }
-            }.bind(this));
-          }
+            return pageable;
+          },
+          getToolbar: function(options, scope) {
 
-          return columns;
-        },
-        getPageAble: function(options) {
-          var pageable = {
-            refresh:  options.allowRefreshGrid,
-            pageSizes: options.allowSelectionTotalPageToShow,
-            buttonCount: 5
-          };
+            function generateToolbarTemplate(toolbarButton) {
+              let security = toolbarButton.security ? `cronapp-security="${toolbarButton.security}" class` : "class";
+              if (toolbarButton.template)
+                toolbarButton.template = toolbarButton.template.split("class").join(security);
+              let buttonTemplate =  { template: toolbarButton.template };
+              return buttonTemplate;
+            }
 
-          if (!options.allowPaging)
-            pageable = options.allowPaging;
+            var toolbar = [];
 
-          return pageable;
-        },
-        getToolbar: function(options, scope) {
-
-          function generateToolbarTemplate(toolbarButton) {
-            let security = toolbarButton.security ? `cronapp-security="${toolbarButton.security}" class` : "class";
-            if (toolbarButton.template)
-              toolbarButton.template = toolbarButton.template.split("class").join(security);
-            let buttonTemplate =  { template: toolbarButton.template };
-            return buttonTemplate;
-          }
+            options.toolBarButtons.forEach(function(toolbarButton) {
+              if (toolbarButton.type == "Native") {
+                //Se a grade for editavel, adiciona todos os commands
+                if (options.editable != 'no') {
+                  if ((options.editable == 'datasource' || options.editable == 'popupCustom') &&  toolbarButton.title == 'create') {
+                    var datasourceName = options.dataSourceScreen.name;
+                    var popupInsert = options.popupInsert;
+                    toolbarButton.methodCall = datasourceName + ".startInserting();";
+                    if (options.editable == 'popupCustom') {
+                      toolbarButton.methodCall = toolbarButton.methodCall + " cronapi.screen.showModal('"+popupInsert+"');";
+                    }
+                    else {
+                      toolbarButton.methodCall += "cronapi.internal.focusFormInput();"
+                    }
+                    var button = this.generateToolbarButtonCall(toolbarButton, scope, options);
+                    toolbar.push(button);
 
-          var toolbar = [];
-
-          options.toolBarButtons.forEach(function(toolbarButton) {
-            if (toolbarButton.type == "Native") {
-              //Se a grade for editavel, adiciona todos os commands
-              if (options.editable != 'no') {
-                if ((options.editable == 'datasource' || options.editable == 'popupCustom') &&  toolbarButton.title == 'create') {
-                  var datasourceName = options.dataSourceScreen.name;
-                  var popupInsert = options.popupInsert;
-                  toolbarButton.methodCall = datasourceName + ".startInserting();";
-                  if (options.editable == 'popupCustom') {
-                    toolbarButton.methodCall = toolbarButton.methodCall + " cronapi.screen.showModal('"+popupInsert+"');";
+                    if (!options.hideModalButtons) {
+                      this.addButtonsInModal(popupInsert, datasourceName, scope);
+                    }
                   }
                   else {
-                    toolbarButton.methodCall += "cronapi.internal.focusFormInput();"
-                  }
-                  var button = this.generateToolbarButtonCall(toolbarButton, scope, options);
-                  toolbar.push(button);
-
-                  if (!options.hideModalButtons) {
-                    this.addButtonsInModal(popupInsert, datasourceName, scope);
+                    let toolbarOp = this.generateToolbarButtonCall(toolbarButton, scope, options);
+                    toolbar.push(toolbarOp);
                   }
                 }
+                //Senão, adiciona somente commands que não sejam de crud
                 else {
-                  let toolbarOp = this.generateToolbarButtonCall(toolbarButton, scope, options);
-                  toolbar.push(toolbarOp);
+                  if (toolbarButton.title == "pdf" || toolbarButton.title == "excel") {
+                    toolbar.push(toolbarButton.title);
+                  }
                 }
               }
-              //Senão, adiciona somente commands que não sejam de crud
-              else {
-                if (toolbarButton.title == "pdf" || toolbarButton.title == "excel") {
-                  toolbar.push(toolbarButton.title);
+              else if (toolbarButton.type == "Blockly" || toolbarButton.type == "Customized") {
+                var buttonBlockly = this.generateToolbarButtonCall(toolbarButton, scope, options);
+                toolbar.push(buttonBlockly);
+              }
+              else if (toolbarButton.type == "SaveOrCancelChanges") {
+                if (options.editable != 'no') {
+                  var buttonSaveOrCancel = this.generateToolbarButtonCall(toolbarButton, scope, options);
+                  toolbar.push(buttonSaveOrCancel);
                 }
               }
-            }
-            else if (toolbarButton.type == "Blockly" || toolbarButton.type == "Customized") {
-              var buttonBlockly = this.generateToolbarButtonCall(toolbarButton, scope, options);
-              toolbar.push(buttonBlockly);
-            }
-            else if (toolbarButton.type == "SaveOrCancelChanges") {
-              if (options.editable != 'no') {
-                var buttonSaveOrCancel = this.generateToolbarButtonCall(toolbarButton, scope, options);
-                toolbar.push(buttonSaveOrCancel);
+              else if (toolbarButton.type == "Template" || toolbarButton.type == "Title") {
+                let buttonTemplate = generateToolbarTemplate(toolbarButton);
+                toolbar.push(buttonTemplate);
               }
-            }
-            else if (toolbarButton.type == "Template" || toolbarButton.type == "Title") {
-              let buttonTemplate = generateToolbarTemplate(toolbarButton);
-              toolbar.push(buttonTemplate);
-            }
 
-          }.bind(this));
-
-          if (toolbar.length == 0)
-            toolbar = undefined;
-          return toolbar;
-        },
-        getEditable: function(options) {
-          var editable = {
-            mode:  options.editable,
-            confirmation: false
-          };
-          if (options.editable == 'batch') {
-            editable = true;
-          }
-          else if (options.editable == 'no' || options.editable == 'popupCustom' || options.editable == 'datasource') {
-            editable = false;
-          }
-          return editable;
-        },
-        getTooltipsDefault: function() {
-          var tooltips = {
-            k_grid_edit : $translate.instant('Edit'),
-            k_grid_delete: $translate.instant('Remove'),
-            k_grid_update: $translate.instant('Save'),
-            k_grid_cancel: $translate.instant('Cancel')
-          };
-          return tooltips;
-        },
-        setTooltips: function($divContainer, tooltips) {
-          for (var key in tooltips) {
-            var classFilter = '.' + key.replace(/_/g,'-');
-            $divContainer.kendoTooltip({
-              filter: classFilter,
-              content: function(e){
-                var classKey = e.sender.options.filter.substr(1).replace(/-/g,'_');
-                return tooltips[classKey];
-              }
-            });
-          }
-        },
-        generateKendoGridInit: function(options, scope, ngModelCtrl, attrs, tooltips) {
+            }.bind(this));
 
-          var helperDirective = this;
-          function detailInit(e) {
-            //Significa que está fechando o detalhe (não é para fazer nada)
-            if (e.masterRow.find('a').hasClass('k-i-expand')) {
-              collapseCurrent(this, e.detailRow, e.masterRow);
-              return;
+            if (toolbar.length == 0)
+              toolbar = undefined;
+            return toolbar;
+          },
+          getEditable: function(options) {
+            var editable = {
+              mode:  options.editable,
+              confirmation: false
+            };
+            if (options.editable == 'batch') {
+              editable = true;
+            }
+            else if (options.editable == 'no' || options.editable == 'popupCustom' || options.editable == 'datasource') {
+              editable = false;
             }
+            return editable;
+          },
+          getTooltipsDefault: function() {
+            var tooltips = {
+              k_grid_edit : $translate.instant('Edit'),
+              k_grid_delete: $translate.instant('Remove'),
+              k_grid_update: $translate.instant('Save'),
+              k_grid_cancel: $translate.instant('Cancel')
+            };
+            return tooltips;
+          },
+          setTooltips: function($divContainer, tooltips) {
+            for (var key in tooltips) {
+              var classFilter = '.' + key.replace(/_/g,'-');
+              $divContainer.kendoTooltip({
+                filter: classFilter,
+                content: function(e){
+                  var classKey = e.sender.options.filter.substr(1).replace(/-/g,'_');
+                  return tooltips[classKey];
+                }
+              });
+            }
+          },
+          generateKendoGridInit: function(options, scope, ngModelCtrl, attrs, tooltips) {
 
-            var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-            if (!(cronappDatasource.inserting || cronappDatasource.editing)) {
-              if (this.selectable) {
-                this.select(e.masterRow);
+            var helperDirective = this;
+            function detailInit(e) {
+              //Significa que está fechando o detalhe (não é para fazer nada)
+              if (e.masterRow.find('a').hasClass('k-i-expand')) {
+                collapseCurrent(this, e.detailRow, e.masterRow);
+                return;
               }
-              else {
-                setToActiveInCronappDataSource.bind(this)(e.data);
-                collapseAllExcecptCurrent(this, e.detailRow, e.masterRow);
+
+              var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+              if (!(cronappDatasource.inserting || cronappDatasource.editing)) {
+                if (this.selectable) {
+                  this.select(e.masterRow);
+                }
+                else {
+                  setToActiveInCronappDataSource.bind(this)(e.data);
+                  collapseAllExcecptCurrent(this, e.detailRow, e.masterRow);
+                }
+                //Obtendo todos os detalhes da grade atual, fechando e removendo todos (exceto o que esta sendo aberto agora)
+                e.sender.options.listCurrentOptions.forEach(function(currentOptions) {
+                  var currentKendoGridInit = helperDirective.generateKendoGridInit(currentOptions, scope, undefined, undefined, tooltips);
+
+                  var $gridDiv = $("<div/>");
+                  var grid = $gridDiv.appendTo(e.detailCell).kendoGrid(currentKendoGridInit).data('kendoGrid');
+                  app.kendoHelper.receivePushData(grid);
+                  currentOptions.refComponent = grid;
+                  //Resize da tela para ajustar obter o widthDevices correto
+                  window.addEventListener("resize", () => { helperDirective.resizeGridUsingWidthForDevice(grid) });
+
+                  helperDirective.setTooltips($gridDiv, tooltips);
+                });
               }
-              //Obtendo todos os detalhes da grade atual, fechando e removendo todos (exceto o que esta sendo aberto agora)
-              e.sender.options.listCurrentOptions.forEach(function(currentOptions) {
-                var currentKendoGridInit = helperDirective.generateKendoGridInit(currentOptions, scope, undefined, undefined, tooltips);
+              else
+                collapseAllExcecptCurrent(this, null, null);
 
-                var $gridDiv = $("<div/>");
-                var grid = $gridDiv.appendTo(e.detailCell).kendoGrid(currentKendoGridInit).data('kendoGrid');
-                app.kendoHelper.receivePushData(grid);
-                currentOptions.refComponent = grid;
-                //Resize da tela para ajustar obter o widthDevices correto
-                window.addEventListener("resize", () => { helperDirective.resizeGridUsingWidthForDevice(grid) });
 
-                helperDirective.setTooltips($gridDiv, tooltips);
-              });
             }
-            else
-              collapseAllExcecptCurrent(this, null, null);
 
+            var collapseAllExcecptCurrent = function(grid, trDetail, trMaster) {
 
-          }
-
-          var collapseAllExcecptCurrent = function(grid, trDetail, trMaster) {
-
-            var masters = grid.table.find('.k-master-row');
-            masters.each(function() {
-              if (trMaster == null || this != trMaster[0]) {
-                grid.collapseRow(this);
-              }
-            });
+              var masters = grid.table.find('.k-master-row');
+              masters.each(function() {
+                if (trMaster == null || this != trMaster[0]) {
+                  grid.collapseRow(this);
+                }
+              });
 
-            var details = grid.table.find('.k-detail-row');
-            details.each(function() {
-              if (trDetail == null || this != trDetail[0]) {
-                $(this).remove();
-              }
-            });
+              var details = grid.table.find('.k-detail-row');
+              details.each(function() {
+                if (trDetail == null || this != trDetail[0]) {
+                  $(this).remove();
+                }
+              });
 
-          };
+            };
 
-          var collapseCurrent = function(grid, trDetail, trMaster) {
+            var collapseCurrent = function(grid, trDetail, trMaster) {
 
-            var masters = grid.table.find('.k-master-row');
-            masters.each(function() {
-              if (trMaster != null || this == trMaster[0]) {
-                grid.collapseRow(this);
-              }
-            });
+              var masters = grid.table.find('.k-master-row');
+              masters.each(function() {
+                if (trMaster != null || this == trMaster[0]) {
+                  grid.collapseRow(this);
+                }
+              });
 
-            var details = grid.table.find('.k-detail-row');
-            details.each(function() {
-              if (trDetail != null || this == trDetail[0]) {
-                $(this).remove();
-              }
-            });
+              var details = grid.table.find('.k-detail-row');
+              details.each(function() {
+                if (trDetail != null || this == trDetail[0]) {
+                  $(this).remove();
+                }
+              });
 
-          };
+            };
 
-          var setToActiveInCronappDataSource = function(item) {
-            var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-            if (!(cronappDatasource.inserting || cronappDatasource.editing))
-              scope.safeApply(cronappDatasource.goTo(item));
-          };
+            var setToActiveInCronappDataSource = function(item) {
+              var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+              if (!(cronappDatasource.inserting || cronappDatasource.editing))
+                scope.safeApply(cronappDatasource.goTo(item));
+            };
 
-          var compileListing = function(e) {
-            if (e.sender.tbody && e.sender.tbody.length) {
+            var compileListing = function(e) {
+              if (e.sender.tbody && e.sender.tbody.length && !$(e.sender.tbody).find('.k-grid-edit-row').length) {
 
-              var toCompile = e.sender.tbody;
-              if (toCompile.parent() && toCompile.parent().parent() && toCompile.parent().parent().parent() )
-                toCompile = toCompile.parent().parent().parent();
+                var toCompile = e.sender.tbody;
+                if (toCompile.parent() && toCompile.parent().parent() && toCompile.parent().parent().parent() )
+                  toCompile = toCompile.parent().parent().parent();
 
-              scope.safeApply(function() {
-                var trs = $(toCompile);
-                var x = angular.element(trs);
-                //setTimeout apenas para sair da thread
-                setTimeout(()=> {
+                scope.safeApply(function() {
+                  var trs = $(toCompile);
+                  var x = angular.element(trs);
                   $compile(x)(scope);
                   if (options.refComponent) {
                     helperDirective.resizeGridUsingWidthForDevice(options.refComponent);
                   }
-                },100);
-              });
-            }
-          };
+                });
+              }
+            };
 
-          var anyFilterableColumn = function(options) {
-            var hasFilterableColumn = false;
-            if (options.columns) {
-              for (var i = 0; i<options.columns.length; i++) {
-                if (options.columns[i].dataType == "Database") {
-                  if (options.columns[i].filterable){
-                    hasFilterableColumn = true;
-                    break;
+            var anyFilterableColumn = function(options) {
+              var hasFilterableColumn = false;
+              if (options.columns) {
+                for (var i = 0; i<options.columns.length; i++) {
+                  if (options.columns[i].dataType == "Database") {
+                    if (options.columns[i].filterable){
+                      hasFilterableColumn = true;
+                      break;
+                    }
                   }
                 }
               }
-            }
-            return hasFilterableColumn;
-          };
+              return hasFilterableColumn;
+            };
 
-          var getVisibleColumnByIdx = function(idx) {
-            var result;
-            var currIdx = 0;
-            options.columns.forEach(function(column)  {
-              if (column.dataType == "Database") {
-                if (currIdx == idx && column.visible) {
-                  result = column;
+            var getVisibleColumnByIdx = function(idx) {
+              var result;
+              var currIdx = 0;
+              options.columns.forEach(function(column)  {
+                if (column.dataType == "Database") {
+                  if (currIdx == idx && column.visible) {
+                    result = column;
+                  }
+                  if (column.visible)
+                    currIdx++;
                 }
-                if (column.visible)
-                  currIdx++;
-              }
-            });
-            return result;
-          };
+              });
+              return result;
+            };
 
-          var excelExport = function(e) {
-            let sheet = e.workbook.sheets[0];
-            let regexAngular = new RegExp("\{\{(.*?)\}\}");
-
-            for (let rowIndex = 1; rowIndex < sheet.rows.length; rowIndex++) {
-              let row = sheet.rows[rowIndex];
-              for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex ++) {
-
-                let column = getVisibleColumnByIdx(cellIndex);
-                //Formata pro excel e adiciona o timezone
-                if (column && row.cells[cellIndex].value instanceof Date) {
-                  let dateValue = new Date(row.cells[cellIndex].value.getTime());
-                  dateValue.setMinutes(dateValue.getMinutes() + dateValue.getTimezoneOffset());
-                  dateValue.setSeconds(dateValue.getSeconds());
-                  row.cells[cellIndex].value = dateValue;
-                  if (column.type == 'time')
-                    row.cells[cellIndex].format = "[$-x-systime]hh:mm:ss";
-                  else if (column.type == 'datetime')
-                    row.cells[cellIndex].format = "dd/mm/yyyy hh:mm:ss;@";
-                }
+            var excelExport = function(e) {
+              let sheet = e.workbook.sheets[0];
+              let regexAngular = new RegExp("\{\{(.*?)\}\}");
+
+              for (let rowIndex = 1; rowIndex < sheet.rows.length; rowIndex++) {
+                let row = sheet.rows[rowIndex];
+                for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex ++) {
+
+                  let column = getVisibleColumnByIdx(cellIndex);
+                  //Formata pro excel e adiciona o timezone
+                  if (column && row.cells[cellIndex].value instanceof Date) {
+                    let dateValue = new Date(row.cells[cellIndex].value.getTime());
+                    dateValue.setMinutes(dateValue.getMinutes() + dateValue.getTimezoneOffset());
+                    dateValue.setSeconds(dateValue.getSeconds());
+                    row.cells[cellIndex].value = dateValue;
+                    if (column.type == 'time')
+                      row.cells[cellIndex].format = "[$-x-systime]hh:mm:ss";
+                    else if (column.type == 'datetime')
+                      row.cells[cellIndex].format = "dd/mm/yyyy hh:mm:ss;@";
+                  }
 
-                if (row.type === "footer") {
-                  if (row.cells[cellIndex].value) {
-                    let rawValue = row.cells[cellIndex].value;
-                    let content = $(rawValue)[0].innerHTML;
-                    let regexExecution = regexAngular.exec(content);
-                    if (regexExecution && regexExecution.length > 1) {
-                      content = content.replace(regexExecution[0],"");
-                      let evaluatedExpression = scope.$eval(regexExecution[1]);
-                      row.cells[cellIndex].value = `${content}${evaluatedExpression}`;
+                  if (row.type === "footer") {
+                    if (row.cells[cellIndex].value) {
+                      let rawValue = row.cells[cellIndex].value;
+                      let content = $(rawValue)[0].innerHTML;
+                      let regexExecution = regexAngular.exec(content);
+                      if (regexExecution && regexExecution.length > 1) {
+                        content = content.replace(regexExecution[0],"");
+                        let evaluatedExpression = scope.$eval(regexExecution[1]);
+                        row.cells[cellIndex].value = `${content}${evaluatedExpression}`;
+                      }
                     }
                   }
                 }
               }
-            }
-          };
+            };
 
 
 
-          var datasource = app.kendoHelper.getDataSource(options.dataSourceScreen.entityDataSource, scope, options.allowPaging, options.pageCount, options.columns, options.groupings);
+            var datasource = app.kendoHelper.getDataSource(options.dataSourceScreen.entityDataSource, scope, options.allowPaging, options.pageCount, options.columns, options.groupings);
 
-          var columns = this.getColumns(options, datasource, scope, tooltips);
-          var pageAble = this.getPageAble(options);
-          var toolbar = this.getToolbar(options, scope);
-          var editable = this.getEditable(options);
-          var filterable = anyFilterableColumn(options);
+            var columns = this.getColumns(options, datasource, scope, tooltips);
+            var pageAble = this.getPageAble(options);
+            var toolbar = this.getToolbar(options, scope);
+            var editable = this.getEditable(options);
+            var filterable = anyFilterableColumn(options);
 
-          var kendoGridInit = {
-            hasSecurity: options.columns.filter(c => c.security).length,
-            toolbar: toolbar,
-            pdf: {
-              allPages: true,
-              avoidLinks: true,
-              paperSize: "A4",
-              margin: { top: "2cm", left: "1cm", right: "1cm", bottom: "1cm" },
-              landscape: true,
-              repeatHeaders: true,
-              scale: 0.8
-            },
-            dataSource: datasource,
-            editable: editable,
-            height: options.height,
-            groupable: options.allowGrouping,
-            sortable: options.allowSorting,
-            filterable: true,
-            pageable: pageAble,
-            columns: columns,
-            selectable: options.allowSelectionRow,
-            detailInit: (options.details && options.details.length > 0) ? detailInit : undefined,
-            listCurrentOptions: (options.details && options.details.length > 0) ? options.details : undefined,
-            excelExport: excelExport,
-            edit: function(e) {
-              this.dataSource.transport.options.disableAndSelect(e);
-              var container = e.container;
-              var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-              if (e.model.isNew() && !e.model.dirty) {
-                var model = e.model;
-                cronappDatasource.startInserting(null, function(active) {
-                  for (var key in active) {
-                    if (model.fields[key]) {
-                      if (model.fields[key].validation && model.fields[key].validation.required) {
-                        var input = container.find("input[name='" + key + "']");
-                        if (input.length) {
-                          //TODO: Verificar com a telerik https://stackoverflow.com/questions/22179758/kendo-grid-using-model-set-to-update-the-value-of-required-fields-triggers-vali
-                          input.val(active[key]).trigger('change');
+            var kendoGridInit = {
+              hasSecurity: options.columns.filter(c => c.security).length,
+              toolbar: toolbar,
+              pdf: {
+                allPages: true,
+                avoidLinks: true,
+                paperSize: "A4",
+                margin: { top: "2cm", left: "1cm", right: "1cm", bottom: "1cm" },
+                landscape: true,
+                repeatHeaders: true,
+                scale: 0.8
+              },
+              dataSource: datasource,
+              editable: editable,
+              height: options.height,
+              groupable: options.allowGrouping,
+              sortable: options.allowSorting,
+              filterable: true,
+              pageable: pageAble,
+              columns: columns,
+              selectable: options.allowSelectionRow,
+              detailInit: (options.details && options.details.length > 0) ? detailInit : undefined,
+              listCurrentOptions: (options.details && options.details.length > 0) ? options.details : undefined,
+              excelExport: excelExport,
+              edit: function(e) {
+                this.dataSource.transport.options.disableAndSelect(e);
+                var container = e.container;
+                var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+                if (e.model.isNew()) {
+                  var model = e.model;
+                  cronappDatasource.startInserting(null, function(active) {
+                    for (var key in active) {
+                      if (model.fields[key]) {
+                        if (model.fields[key].validation && model.fields[key].validation.required) {
+                          var input = container.find("input[name='" + key + "']");
+                          if (input.length) {
+                            //TODO: Verificar com a telerik https://stackoverflow.com/questions/22179758/kendo-grid-using-model-set-to-update-the-value-of-required-fields-triggers-vali
+                            input.val(active[key]).trigger('change');
+                          }
                         }
+                        model.set(key, active[key]);
                       }
-                      model.set(key, active[key]);
                     }
-                  }
-                });
-              }
-              else if (!e.model.isNew() && !e.model.dirty) {
-                scope.safeApply(function() {
-                  var currentItem = cronappDatasource.goTo(e.model);
-                  cronappDatasource.startEditing(currentItem, function(xxx) {});
-                });
-              }
+                  });
+                }
+                else if (!e.model.isNew() && !e.model.dirty) {
+                  scope.safeApply(function() {
+                    var currentItem = cronappDatasource.goTo(e.model);
+                    cronappDatasource.startEditing(currentItem, function(xxx) {});
+                  });
+                }
 
-              if (attrs && attrs.ngEdit) {
-                scope.$eval(attrs.ngEdit);
-              }
+                if (attrs && attrs.ngEdit) {
+                  scope.$eval(attrs.ngEdit);
+                }
 
-              compileListing(e);
-            },
-            change: function(e) {
-              var item = this.dataItem(this.select());
-              setToActiveInCronappDataSource.bind(this)(item);
-              var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-              if(options.fieldType && options.fieldType === 'key'){
-                cronappDatasource.active = helperDirective.changeObjectField(cronappDatasource, cronappDatasource.active);
-              }
-              if (ngModelCtrl) {
-                if ("multiple" === options.allowSelectionRowType) {
-                  let selecteds = [];
-                  this.select().each((i, row)=> {
-                    let item = this.dataItem(row);
-                    let objInDs = cronappDatasource.findObjInDs(item, false);
-                    if(options.fieldType && options.fieldType === 'key'){
-                      objInDs = helperDirective.changeObjectField(cronappDatasource, objInDs);
-                    }
-                    if (objInDs !== null){
-                      selecteds.push(objInDs);
-                    }
-                  });
-                  ngModelCtrl.$setViewValue(selecteds);
+                compileListing(e);
+              },
+              change: function(e) {
+                var item = this.dataItem(this.select());
+                setToActiveInCronappDataSource.bind(this)(item);
+                var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+                if(options.fieldType && options.fieldType === 'key'){
+                  cronappDatasource.active = helperDirective.changeObjectField(cronappDatasource, cronappDatasource.active);
                 }
-                else{
-                  if (item) {
-                    ngModelCtrl.$setViewValue(cronappDatasource.active);
+                if (ngModelCtrl) {
+                  if ("multiple" === options.allowSelectionRowType) {
+                    let selecteds = [];
+                    this.select().each((i, row)=> {
+                      let item = this.dataItem(row);
+                      let objInDs = cronappDatasource.findObjInDs(item, false);
+                      if(options.fieldType && options.fieldType === 'key'){
+                        objInDs = helperDirective.changeObjectField(cronappDatasource, objInDs);
+                      }
+                      if (objInDs !== null){
+                        selecteds.push(objInDs);
+                      }
+                    });
+                    ngModelCtrl.$setViewValue(selecteds);
                   }
-                  else {
-                    ngModelCtrl.$setViewValue(null);
+                  else{
+                    if (item) {
+                      ngModelCtrl.$setViewValue(cronappDatasource.active);
+                    }
+                    else {
+                      ngModelCtrl.$setViewValue(null);
+                    }
                   }
                 }
-              }
-              collapseAllExcecptCurrent(this, this.select().next(), this.select());
+                collapseAllExcecptCurrent(this, this.select().next(), this.select());
 
-              if (attrs && attrs.ngChange) {
-                scope.$eval(attrs.ngChange);
-              }
-
-              compileListing(e);
-            },
-            cancel: function(e) {
-              var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-              scope.safeApply(cronappDatasource.cancel());
-              this.dataSource.transport.options.enableAndSelect(e);
-              setTimeout(function() {
-                if (attrs && attrs.ngCancel) {
-                  scope.$eval(attrs.ngCancel);
+                if (attrs && attrs.ngChange) {
+                  scope.$eval(attrs.ngChange);
                 }
 
                 compileListing(e);
-              }.bind(this));
-            },
-            dataBound: function(e) {
-              setTimeout(() => this.dataSource.transport.options.selectActiveInGrid(), 100);
+              },
+              cancel: function(e) {
+                var cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+                scope.safeApply(cronappDatasource.cancel());
+                this.dataSource.transport.options.enableAndSelect(e);
+                setTimeout(function() {
+                  if (attrs && attrs.ngCancel) {
+                    scope.$eval(attrs.ngCancel);
+                  }
 
-              if (attrs && attrs.ngDataBound) {
-                scope.$eval(attrs.ngDataBound);
-              }
+                  compileListing(e);
+                }.bind(this));
+              },
+              dataBound: function(e) {
+                setTimeout(() => this.dataSource.transport.options.selectActiveInGrid(), 100);
 
-              for(let i=0;i<this.columns.length;i++){
-                let col = helperDirective.getColumnByField(options, this.columns[i].field);
-                if (col.visible)
-                  this.showColumn(i);
-              }
-              if ($('div.k-grouping-header').length == 0) {
-                if (options.groupings) {
-                  options.groupings.forEach((c) => this.hideColumn(c.field));
+                if (attrs && attrs.ngDataBound) {
+                  scope.$eval(attrs.ngDataBound);
                 }
-              }
-              else {
-                $("div.k-group-indicator").each((i,v) => {
-                  this.hideColumn($(v).data("field"));
+
+                for(let i=0;i<this.columns.length;i++){
+                  let col = helperDirective.getColumnByField(options, this.columns[i].field);
+                  if (col.visible)
+                    this.showColumn(i);
+                }
+                if ($('div.k-grouping-header').length == 0) {
+                  if (options.groupings) {
+                    options.groupings.forEach((c) => this.hideColumn(c.field));
+                  }
+                }
+                else {
+                  $("div.k-group-indicator").each((i,v) => {
+                    this.hideColumn($(v).data("field"));
+                  });
+                }
+                //Colocando tabindex para poder focar - acessibilidade
+                let grid = this;
+                setTimeout(function() {
+                  if (grid.pager) {
+                    grid.pager.element.find("a").not(".k-state-disabled").attr("tabindex", "0");
+                  }
                 });
+
+                compileListing(e);
               }
-              //Colocando tabindex para poder focar - acessibilidade
-              let grid = this;
-              setTimeout(function() {
-                if (grid.pager) {
-                  grid.pager.element.find("a").not(".k-state-disabled").attr("tabindex", "0");
-                }
-              });
+            };
 
-              compileListing(e);
+            if (kendoGridInit.selectable) {
+              if ("multiple" == options.allowSelectionRowType) {
+                kendoGridInit.selectable = "multiple"
+              }
             }
-          };
+            kendoGridInit.originalSelectable = kendoGridInit.selectable;
 
-          if (kendoGridInit.selectable) {
-            if ("multiple" == options.allowSelectionRowType) {
-              kendoGridInit.selectable = "multiple"
+            if (attrs && attrs.ngBeforeEdit) {
+              kendoGridInit.beforeEdit =  function(e) {scope.$eval(attrs.ngBeforeEdit);};
+            }
+            if (attrs && attrs.ngDataBinding) {
+              kendoGridInit.dataBinding = function(e) {scope.$eval(attrs.ngDataBinding);};
+            }
+            if (attrs && attrs.ngSave) {
+              kendoGridInit.save = function(e) {scope.$eval(attrs.ngSave);};
+            }
+            if (attrs && attrs.ngSaveChanges) {
+              kendoGridInit.saveChanges = function(e) {scope.$eval(attrs.ngSaveChanges);};
+            }
+            if (attrs && attrs.ngRemove) {
+              kendoGridInit.remove = function(e) {scope.$eval(attrs.ngRemove);};
             }
-          }
-          kendoGridInit.originalSelectable = kendoGridInit.selectable;
 
-          if (attrs && attrs.ngBeforeEdit) {
-            kendoGridInit.beforeEdit =  function(e) {scope.$eval(attrs.ngBeforeEdit);};
-          }
-          if (attrs && attrs.ngDataBinding) {
-            kendoGridInit.dataBinding = function(e) {scope.$eval(attrs.ngDataBinding);};
-          }
-          if (attrs && attrs.ngSave) {
-            kendoGridInit.save = function(e) {scope.$eval(attrs.ngSave);};
-          }
-          if (attrs && attrs.ngSaveChanges) {
-            kendoGridInit.saveChanges = function(e) {scope.$eval(attrs.ngSaveChanges);};
-          }
-          if (attrs && attrs.ngRemove) {
-            kendoGridInit.remove = function(e) {scope.$eval(attrs.ngRemove);};
-          }
+            return kendoGridInit;
 
-          return kendoGridInit;
+          },
+          link: function (scope, element, attrs, ngModelCtrl) {
 
-        },
-        link: function (scope, element, attrs, ngModelCtrl) {
+            if (element.children().length)
+              return;
 
-          if (element.children().length)
-            return;
+            var $templateDyn = $('<div></div>');
+            var baseUrl = 'node_modules/cronapp-lib-js/dist/js/kendo-ui/js/messages/kendo.messages.';
+            if ($translate.use() == 'pt_br')
+              baseUrl += "pt-BR.min.js";
+            else
+              baseUrl += "en-US.min.js";
 
-          var $templateDyn = $('<div></div>');
-          var baseUrl = 'node_modules/cronapp-lib-js/dist/js/kendo-ui/js/messages/kendo.messages.';
-          if ($translate.use() == 'pt_br')
-            baseUrl += "pt-BR.min.js";
-          else
-            baseUrl += "en-US.min.js";
 
+            this.initCulture();
+            var helperDirective = this;
+            $.getScript(baseUrl, function () {
 
-          this.initCulture();
-          var helperDirective = this;
-          $.getScript(baseUrl, function () {
+              var options = JSON.parse(attrs.options || "{}");
 
-            var options = JSON.parse(attrs.options || "{}");
+              app.kendoHelper.getCorrectlyDS(options.dataSourceScreen.entityDataSource.name, scope).batchPost = false;
+              var batchMode = options.batchMode == undefined || options.batchMode;
+              if (batchMode && options.editable != 'datasource' && app.kendoHelper.getCorrectlyDS(options.dataSourceScreen.entityDataSource.name, scope) && !app.kendoHelper.getCorrectlyDS(options.dataSourceScreen.entityDataSource.name, scope).dependentLazyPost) {
+                app.kendoHelper.getCorrectlyDS(options.dataSourceScreen.entityDataSource.name, scope).batchPost = true;
 
-            scope[options.dataSourceScreen.entityDataSource.name].batchPost = false;
-            var batchMode = options.batchMode == undefined || options.batchMode;
-            if (batchMode && options.editable != 'datasource' && scope[options.dataSourceScreen.entityDataSource.name] && !scope[options.dataSourceScreen.entityDataSource.name].dependentLazyPost) {
-              scope[options.dataSourceScreen.entityDataSource.name].batchPost = true;
-
-              options.toolBarButtons = options.toolBarButtons || [];
-              options.toolBarButtons.push({
-                type: "SaveOrCancelChanges",
-                title: $translate.instant('SaveChanges'),
-                methodCall: options.dataSourceScreen.entityDataSource.name + ".postBatchData()",
-                saveButton: true
-              });
-              options.toolBarButtons.push({
-                type: "SaveOrCancelChanges",
-                title: $translate.instant('CancelChanges'),
-                methodCall: options.dataSourceScreen.entityDataSource.name + ".cancelBatchData()",
-                saveButton: false
-              });
-            }
+                options.toolBarButtons = options.toolBarButtons || [];
+                options.toolBarButtons.push({
+                  type: "SaveOrCancelChanges",
+                  title: $translate.instant('SaveChanges'),
+                  methodCall: options.dataSourceScreen.entityDataSource.name + ".postBatchData()",
+                  saveButton: true
+                });
+                options.toolBarButtons.push({
+                  type: "SaveOrCancelChanges",
+                  title: $translate.instant('CancelChanges'),
+                  methodCall: options.dataSourceScreen.entityDataSource.name + ".cancelBatchData()",
+                  saveButton: false
+                });
+              }
+
+              var tooltips = helperDirective.getTooltipsDefault();
+              var kendoGridInit = helperDirective.generateKendoGridInit(options, scope, ngModelCtrl, attrs, tooltips);
+              kendoGridInit.scrollable = attrs.scrollable === "true";
+
+              var grid = $templateDyn.kendoGrid(kendoGridInit).data('kendoGrid');
+              app.kendoHelper.receivePushData(grid);
+              options.refComponent = grid;
+
+              //Resize da tela para ajustar obter o widthDevices correto
+              window.addEventListener("resize", () => { helperDirective.resizeGridUsingWidthForDevice(grid) });
 
-            var tooltips = helperDirective.getTooltipsDefault();
-            var kendoGridInit = helperDirective.generateKendoGridInit(options, scope, ngModelCtrl, attrs, tooltips);
-            kendoGridInit.scrollable = attrs.scrollable === "true";
-
-            var grid = $templateDyn.kendoGrid(kendoGridInit).data('kendoGrid');
-            app.kendoHelper.receivePushData(grid);
-            options.refComponent = grid;
-
-            //Resize da tela para ajustar obter o widthDevices correto
-            window.addEventListener("resize", () => { helperDirective.resizeGridUsingWidthForDevice(grid) });
-
-            helperDirective.setTooltips($templateDyn, tooltips);
-
-            scope.safeApply(function() {
-              if (scope[options.dataSourceScreen.entityDataSource.name]) {
-
-                $templateDyn.find('.k-filter-row').show();
-                $templateDyn.find('.k-pager-sizes').show();
-                $templateDyn.find('.k-pager-nav').show();
-                $templateDyn.find('.k-pager-numbers').show();
-                $templateDyn.find('.k-pager-refresh.k-link').show();
-                $templateDyn.find('.saveorcancelchanges').hide();
-
-                scope[options.dataSourceScreen.entityDataSource.name].addDataSourceEvents(
-                  {
-                    "pendingchanges": function(value) {
-                      if (value) {
-                        $templateDyn.find('.k-filter-row').hide();
-                        $templateDyn.find('.k-pager-sizes').hide();
-                        $templateDyn.find('.k-pager-nav').hide();
-                        $templateDyn.find('.k-pager-numbers').hide();
-                        $templateDyn.find('.k-pager-refresh.k-link').hide();
-                        $templateDyn.find('.saveorcancelchanges').show();
-                      } else {
-                        $templateDyn.find('.k-filter-row').show();
-                        $templateDyn.find('.k-pager-sizes').show();
-                        $templateDyn.find('.k-pager-nav').show();
-                        $templateDyn.find('.k-pager-numbers').show();
-                        $templateDyn.find('.k-pager-refresh.k-link').show();
-                        $templateDyn.find('.saveorcancelchanges').hide();
+              helperDirective.setTooltips($templateDyn, tooltips);
+
+              scope.safeApply(function() {
+                if (app.kendoHelper.getCorrectlyDS(options.dataSourceScreen.entityDataSource.name, scope)) {
+
+                  $templateDyn.find('.k-filter-row').show();
+                  $templateDyn.find('.k-pager-sizes').show();
+                  $templateDyn.find('.k-pager-nav').show();
+                  $templateDyn.find('.k-pager-numbers').show();
+                  $templateDyn.find('.k-pager-refresh.k-link').show();
+                  $templateDyn.find('.saveorcancelchanges').hide();
+
+                  app.kendoHelper.getCorrectlyDS(options.dataSourceScreen.entityDataSource.name, scope).addDataSourceEvents(
+                      {
+                        "pendingchanges": function(value) {
+                          if (value) {
+                            $templateDyn.find('.k-filter-row').hide();
+                            $templateDyn.find('.k-pager-sizes').hide();
+                            $templateDyn.find('.k-pager-nav').hide();
+                            $templateDyn.find('.k-pager-numbers').hide();
+                            $templateDyn.find('.k-pager-refresh.k-link').hide();
+                            $templateDyn.find('.saveorcancelchanges').show();
+                          } else {
+                            $templateDyn.find('.k-filter-row').show();
+                            $templateDyn.find('.k-pager-sizes').show();
+                            $templateDyn.find('.k-pager-nav').show();
+                            $templateDyn.find('.k-pager-numbers').show();
+                            $templateDyn.find('.k-pager-refresh.k-link').show();
+                            $templateDyn.find('.saveorcancelchanges').hide();
+                          }
+                        }
                       }
-                    }
-                  }
-                );
+                  );
+
+                  app.kendoHelper.getCorrectlyDS(options.dataSourceScreen.entityDataSource.name, scope).addDataSourceEvents(
+                      {
+                        "afterchanges": function(value) {
+                          //QAIBT-610
+                          //grid.dataSource.filter([]);
+                        }
+                      }
+                  );
+                }
+              });
 
-                scope[options.dataSourceScreen.entityDataSource.name].addDataSourceEvents(
-                  {
-                    "afterchanges": function(value) {
-                      //QAIBT-610
-                      //grid.dataSource.filter([]);
-                    }
-                  }
-                );
-              }
             });
 
-          });
+            element.html($templateDyn);
+            $compile($templateDyn)(element.scope());
 
-          element.html($templateDyn);
-          $compile($templateDyn)(element.scope());
+          }
+        };
+      }])
 
-        }
-      };
-    }])
-  
-    .directive('src', function($compile) {
-      return {
-        restrict: 'A',
-        link: function(scope, element, attrs, ctrl) {
-          if (element[0].tagName === "IMG" ) {
-            if (cronapi.internal.isBase64(attrs.src) ) {
-              setTimeout(() => $(element[0]).attr("src", "data:image/png;base64," + attrs.src));
+      .directive('src', function($compile) {
+        return {
+          restrict: 'A',
+          link: function(scope, element, attrs, ctrl) {
+            if (element[0].tagName === "IMG" ) {
+              if (cronapi.internal.isBase64(attrs.src) ) {
+                setTimeout(() => $(element[0]).attr("src", "data:image/png;base64," + attrs.src));
+              }
             }
           }
         }
-      }
-    })
+      })
 
       .directive('cronTreeView', ['$compile', '$translate', function($compile, $translate) {
-          return {
-              restrict: 'E',
-              replace: true,
-              require: 'ngModel',
-              scope: true,
-              getDataSource: function(options, scope, ngModelCtrl) {
-
-                  let id = options.dataSourceScreen.schema.filter(field => { return field.key === true })[0].name;
-                  let schema = {
-                      model: {
-                          id: id,
-                          hasChildren: function(item) {
-                              return item["hasChildren"];
-                          }
-                      }
-                  }
+        return {
+          restrict: 'E',
+          replace: true,
+          require: 'ngModel',
+          scope: true,
+          getDataSource: function(options, scope, ngModelCtrl) {
+
+            let id = options.dataSourceScreen.schema.filter(field => { return field.key === true })[0].name;
+            let schema = {
+              model: {
+                id: id,
+                hasChildren: function(item) {
+                  return item["hasChildren"];
+                }
+              }
+            }
 
-                  let getAllParent = function(cronappDatasource, item, ids, resolve, reject) {
+            let getAllParent = function(cronappDatasource, item, ids, resolve, reject) {
 
-                      if (item[schema.model.id])
-                          ids.push(item[schema.model.id]);
+              if (item[schema.model.id])
+                ids.push(item[schema.model.id]);
 
-                      let odataUrl = `${cronappDatasource.entity}?$filter=${schema.model.id} eq '${item[options.selfRelationshipField]}'&$format=json&$inlinecount=allpages`;
-                      if (item[options.selfRelationshipField]) {
-                          $.ajax({
-                              url: odataUrl,
-                              success: (itemResult) => {
-                              getAllParent(cronappDatasource, itemResult.d.results[0], ids, resolve, reject);
-                      },
-                          beforeSend: (xhr) => {
-                              if (window.uToken) {
-                                  xhr.setRequestHeader ("X-AUTH-TOKEN", window.uToken);
-                              }
-                          },
-                          error: () => reject(),
-                              type: 'GET',
-                      });
-                      }
-                      else {
-                          resolve(ids);
-                      }
-                  };
+              let odataUrl = `${cronappDatasource.entity}?$filter=${schema.model.id} eq '${item[options.selfRelationshipField]}'&$format=json&$inlinecount=allpages`;
+              if (item[options.selfRelationshipField]) {
+                $.ajax({
+                  url: odataUrl,
+                  success: (itemResult) => {
+                    getAllParent(cronappDatasource, itemResult.d.results[0], ids, resolve, reject);
+                  },
+                  beforeSend: (xhr) => {
+                    if (window.uToken) {
+                      xhr.setRequestHeader ("X-AUTH-TOKEN", window.uToken);
+                    }
+                  },
+                  error: () => reject(),
+                  type: 'GET',
+                });
+              }
+              else {
+                resolve(ids);
+              }
+            };
 
-                  let reloadAndExpand = function(data) {
-                      let finish = () => {
-                          let promise = new Promise((resolve, reject) => {
-                              getAllParent(this.options.cronappDatasource, data, [], resolve, reject);
-                      });
-                          promise.then(expandIds => {
-                              this.options.kendoObj.expandPath(expandIds.reverse());
-                      });
-                      };
-                      this.options.kendoObj.dataSource.bind("requestEnd", finish);
-                      this.options.kendoObj.dataSource.read();
-                  };
+            let reloadAndExpand = function(data) {
+              let finish = () => {
+                let promise = new Promise((resolve, reject) => {
+                  getAllParent(this.options.cronappDatasource, data, [], resolve, reject);
+                });
+                promise.then(expandIds => {
+                  this.options.kendoObj.expandPath(expandIds.reverse());
+                });
+              };
+              this.options.kendoObj.dataSource.bind("requestEnd", finish);
+              this.options.kendoObj.dataSource.read();
+            };
 
-                  let helperDirective = this;
-                  let waitingPromise = false;
-                  let datasource = new kendo.data.HierarchicalDataSource({
-                      transport: {
-                          push: function(callback) {
+            let helperDirective = this;
+            let waitingPromise = false;
+            let datasource = new kendo.data.HierarchicalDataSource({
+              transport: {
+                push: function(callback) {
 
-                              if (!helperDirective.dataSourceEventsPush && this.options.cronappDatasource) {
-                                  helperDirective.dataSourceEventsPush = {
-                                      create: function(data) {
+                  if (!helperDirective.dataSourceEventsPush && this.options.cronappDatasource) {
+                    helperDirective.dataSourceEventsPush = {
+                      create: function(data) {
 
-                                          reloadAndExpand.bind(this)(data);
+                        reloadAndExpand.bind(this)(data);
 
-                                      }.bind(this),
-                                      update: function(data) {
+                      }.bind(this),
+                      update: function(data) {
 
-                                          reloadAndExpand.bind(this)(data);
+                        reloadAndExpand.bind(this)(data);
 
-                                      }.bind(this),
-                                      delete: function(data) {
+                      }.bind(this),
+                      delete: function(data) {
 
-                                          reloadAndExpand.bind(this)(data);
-                                          ngModelCtrl.$setViewValue(null);
+                        reloadAndExpand.bind(this)(data);
+                        ngModelCtrl.$setViewValue(null);
 
-                                      }.bind(this),
-                                      overRideRefresh: function(data) {
+                      }.bind(this),
+                      overRideRefresh: function(data) {
 
-                                          this.options.fromRefresh = true;
-                                          this.options.kendoObj.dataSource.read();
-                                          ngModelCtrl.$setViewValue(null);
+                        this.options.fromRefresh = true;
+                        this.options.kendoObj.dataSource.read();
+                        ngModelCtrl.$setViewValue(null);
 
-                                      }.bind(this),
-                                      read: function(data) {
+                      }.bind(this),
+                      read: function(data) {
 
-                                          if (!waitingPromise) {
-                                              this.options.kendoObj.dataSource.read();
-                                              ngModelCtrl.$setViewValue(null);
-                                          }
+                        if (!waitingPromise) {
+                          this.options.kendoObj.dataSource.read();
+                          ngModelCtrl.$setViewValue(null);
+                        }
 
-                                      }.bind(this)
-                                  };
+                      }.bind(this)
+                    };
 
-                                  this.options.cronappDatasource.addDataSourceEvents(helperDirective.dataSourceEventsPush);
-                              }
-                          },
-
-                          read:  function (e) {
-
-                              let conditionIsEmpty = (condition) => {
-                                  let result = true;
-                                  if (condition) {
-                                      let jsonCondition = JSON.parse(condition);
-                                      if (jsonCondition.expression && jsonCondition.expression.args) {
-                                          jsonCondition.expression.args.forEach((a)=> {
-                                              if (a.right !== '' && a.right !== "''" && a.right !== undefined)
-                                          result = false;
-                                      });
-                                      }
-                                  }
-                                  return result;
-                              };
+                    this.options.cronappDatasource.addDataSourceEvents(helperDirective.dataSourceEventsPush);
+                  }
+                },
 
+                read:  function (e) {
 
-                              let cronappDatasource = this.options.cronappDatasource;
+                  let conditionIsEmpty = (condition) => {
+                    let result = true;
+                    if (condition) {
+                      let jsonCondition = JSON.parse(condition);
+                      if (jsonCondition.expression && jsonCondition.expression.args) {
+                        jsonCondition.expression.args.forEach((a)=> {
+                          if (a.right !== '' && a.right !== "''" && a.right !== undefined)
+                            result = false;
+                        });
+                      }
+                    }
+                    return result;
+                  };
 
-                              for (key in e.data)
-                                  if(e.data[key] == undefined)
-                                      delete e.data[key];
 
-                              let logicFilter = { filter: { logic: "and", filters:[] } };
-                              for (let key in e.data) {
-                                  let kendoFilter = {
-                                      field: options.selfRelationshipField,
-                                      operator: "eq",
-                                      value: e.data[key]
-                                  };
-                                  logicFilter.filter.filters.push(kendoFilter);
-                              }
+                  let cronappDatasource = this.options.cronappDatasource;
 
-                              let condition = cronappDatasource.condition;
-                              let conditionEmpty = conditionIsEmpty(condition);
-                              let paramsOData = { $inlinecount: "allpages", $format: "json", $filter: `${options.selfRelationshipField} eq null`};
+                  for (key in e.data)
+                    if(e.data[key] == undefined)
+                      delete e.data[key];
 
-                              if (logicFilter.filter.filters.length) {
-                                  cronappDatasource.condition = '';
-                                  paramsOData = kendo.data.transports.odata.parameterMap(logicFilter, 'read');
-                              }
-                              else if (this.options.fromRefresh) {
-                                  this.options.fromRefresh = false;
-                                  if (!conditionEmpty) {
-                                      cronappDatasource.cleanup();
-                                      paramsOData = { $inlinecount: "allpages", $format: "json"};
-                                  }
-                              }
+                  let logicFilter = { filter: { logic: "and", filters:[] } };
+                  for (let key in e.data) {
+                    let kendoFilter = {
+                      field: options.selfRelationshipField,
+                      operator: "eq",
+                      value: e.data[key]
+                    };
+                    logicFilter.filter.filters.push(kendoFilter);
+                  }
 
-                              cronappDatasource.rowsPerPage = e.data.pageSize;
-                              cronappDatasource.offset = (e.data.page - 1);
-
-
-                              let fetchData = {};
-                              fetchData.params = paramsOData;
-
-                              helperKendoDs = this;
-
-                              cronappDatasource.fetch(fetchData, {
-                                  success:  function(data) {
-
-                                      let all = data.map(item => {
-                                          let odataUrl = `${this.entity}/$count?$filter=${options.selfRelationshipField} eq '${item[schema.model.id]}'`;
-                                          return new Promise((resolve, reject)=> {
-                                              $.ajax({
-                                                url: odataUrl,
-                                                success: (count) => {
-                                                  item["hasChildren"] = eval(count) > 0;
-                                                  resolve();
-                                                },
-                                                beforeSend: (xhr) => {
-                                                  if (window.uToken) {
-                                                      xhr.setRequestHeader ("X-AUTH-TOKEN", window.uToken);
-                                                  }
-                                                },
-                                                error: () => reject(),
-                                                type: 'GET',
-                                              });
-                                          });
-                                      });
-                                      waitingPromise = true;
-                                      Promise.all(all).then(() => {
-                                        e.success(data);
-                                        waitingPromise = false;
-                                      });
-                                  },
-                                  canceled:  function(data) {
-                                      e.error("canceled", "canceled", "canceled");
-                                  }
-                              }, true);
+                  let condition = cronappDatasource.condition;
+                  let conditionEmpty = conditionIsEmpty(condition);
+                  let paramsOData = { $inlinecount: "allpages", $format: "json", $filter: `${options.selfRelationshipField} eq null`};
 
-                              if (condition)
-                                  cronappDatasource.condition = condition;
+                  if (logicFilter.filter.filters.length) {
+                    cronappDatasource.condition = '';
+                    paramsOData = kendo.data.transports.odata.parameterMap(logicFilter, 'read');
+                  }
+                  else if (this.options.fromRefresh) {
+                    this.options.fromRefresh = false;
+                    if (!conditionEmpty) {
+                      cronappDatasource.cleanup();
+                      paramsOData = { $inlinecount: "allpages", $format: "json"};
+                    }
+                  }
 
-                          },
-                          options: {
-                              fromRead: false,
-                              cronappDatasource: scope[options.dataSourceScreen.name]
-                          }
-                      },
-                      schema: schema
-                  });
-                  return datasource;
-              },
-              link: function (scope, element, attrs, ngModelCtrl) {
+                  cronappDatasource.rowsPerPage = e.data.pageSize;
+                  cronappDatasource.offset = (e.data.page - 1);
 
-                  let $templateDyn = $('<div></div>');
-                  let options = JSON.parse(attrs.options);
 
-                  let helperDirective = this;
+                  let fetchData = {};
+                  fetchData.params = paramsOData;
 
-                  let changeObjectField = function(dataSource, obj){
-                      obj = dataSource.getKeyValues(obj);
-                      var keys = Object.keys(obj);
-                      if(keys.length === 1){
-                          obj = obj[keys];
-                      }
-                      return obj;
-                  };
+                  helperKendoDs = this;
+
+                  cronappDatasource.fetch(fetchData, {
+                    success:  function(data) {
+
+                      let all = data.map(item => {
+                        let odataUrl = `${this.entity}/$count?$filter=${options.selfRelationshipField} eq '${item[schema.model.id]}'`;
+                        return new Promise((resolve, reject)=> {
+                          $.ajax({
+                            url: odataUrl,
+                            success: (count) => {
+                              item["hasChildren"] = eval(count) > 0;
+                              resolve();
+                            },
+                            beforeSend: (xhr) => {
+                              if (window.uToken) {
+                                xhr.setRequestHeader ("X-AUTH-TOKEN", window.uToken);
+                              }
+                            },
+                            error: () => reject(),
+                            type: 'GET',
+                          });
+                        });
+                      });
+                      waitingPromise = true;
+                      Promise.all(all).then(() => {
+                        e.success(data);
+                        waitingPromise = false;
+                      });
+                    },
+                    canceled:  function(data) {
+                      e.error("canceled", "canceled", "canceled");
+                    }
+                  }, true);
+
+                  if (condition)
+                    cronappDatasource.condition = condition;
+
+                },
+                options: {
+                  fromRead: false,
+                  cronappDatasource: app.kendoHelper.getCorrectlyDS(options.dataSourceScreen.name, scope)
+                }
+              },
+              schema: schema
+            });
+            return datasource;
+          },
+          link: function (scope, element, attrs, ngModelCtrl) {
 
-                  let kendoObj = $templateDyn.kendoTreeView({
-                      dataSource: helperDirective.getDataSource(options, scope, ngModelCtrl),
-                      dataTextField: options.textField,
-                      dataImageUrlField: options.imageUrlField,
-                      change: function(e) {
-                          let item = this.dataItem(this.select());
+            let $templateDyn = $('<div></div>');
+            let options = JSON.parse(attrs.options);
 
-                          let cronappDatasource = this.dataSource.transport.options.cronappDatasource;
-                          scope.safeApply(cronappDatasource.goTo(item));
+            let helperDirective = this;
 
-                          if(options.fieldType && options.fieldType === 'key')
-                              cronappDatasource.active = changeObjectField(cronappDatasource, cronappDatasource.active);
+            let changeObjectField = function(dataSource, obj){
+              obj = dataSource.getKeyValues(obj);
+              var keys = Object.keys(obj);
+              if(keys.length === 1){
+                obj = obj[keys];
+              }
+              return obj;
+            };
 
-                          ngModelCtrl.$setViewValue(cronappDatasource.active);
-                      }
-                  }).data('kendoTreeView');
-                  kendoObj.dataSource.transport.options.kendoObj = kendoObj;
+            let kendoObj = $templateDyn.kendoTreeView({
+              dataSource: helperDirective.getDataSource(options, scope, ngModelCtrl),
+              dataTextField: options.textField,
+              dataImageUrlField: options.imageUrlField,
+              change: function(e) {
+                let item = this.dataItem(this.select());
+
+                let cronappDatasource = this.dataSource.transport.options.cronappDatasource;
+                scope.safeApply(cronappDatasource.goTo(item));
 
-                  element.html($templateDyn);
-                  $compile($templateDyn)(element.scope());
+                if(options.fieldType && options.fieldType === 'key')
+                  cronappDatasource.active = changeObjectField(cronappDatasource, cronappDatasource.active);
 
+                ngModelCtrl.$setViewValue(cronappDatasource.active);
               }
-          };
+            }).data('kendoTreeView');
+            kendoObj.dataSource.transport.options.kendoObj = kendoObj;
+
+            element.html($templateDyn);
+            $compile($templateDyn)(element.scope());
+
+          }
+        };
       }])
 
       .directive('cronSelect', function ($compile) {
@@ -3377,7 +3378,7 @@
                 _ngModelCtrl.$setViewValue(this.value());
               }.bind(combobox));
             }
-  
+
             var combobox;
             if (select.dontAllowOutsideList === true) {
               combobox = $element.kendoDropDownList(options).data('kendoDropDownList');
@@ -3396,6 +3397,7 @@
                   internalInput.attr("required", "required");
                 internalInput.attr("ng-model", attrs.ngModel);
                 internalInput.attr("id", attrs.id);
+                internalInput.attr("validationmessage", attrs.validationmessage);
                 let $parent = internalInput.parent();
                 internalInput.on('change',() => {
                   if (attrs.ngRequired === "true") {
@@ -3584,7 +3586,7 @@
                                     found = _goTo(_scope, _combobox, data);
                                   }
                                   if (found) {
-                                   modelSetter(_scope, found[select.dataValueField]);
+                                    modelSetter(_scope, found[select.dataValueField]);
                                   }
                                 } else {
                                   modelSetter(_scope, null);
@@ -3609,6 +3611,10 @@
               };
             }
 
+            options.messages =  {
+              noData: attrs.noResultsMessage ? attrs.noResultsMessage : "NO DATA FOUND"
+            };
+
             options.change = attrs.ngChange ? function (){scope.$eval(attrs.ngChange)}: undefined;
             options.close = attrs.ngClose ? function (){scope.$eval(attrs.ngClose)}: undefined;
             options.dataBound = attrs.ngDataBound ? function (){scope.$eval(attrs.ngDataBound)}: undefined;
@@ -3628,7 +3634,8 @@
             var parent = element.parent();
             var id = attrs.id ? ' id="' + attrs.id + '"' : '';
             var name = attrs.name ? ' name="' + attrs.name + '"' : '';
-            var inputSelect = $('<input style="width: 100%;"' + id + name + ' class="cronDynamicSelect" ng-model="' + attrs.ngModel + '"/>');
+            var validationmessage = attrs.validationmessage ? ' validationmessage="' + attrs.validationmessage + '"' : '';
+            var inputSelect = $('<input style="width: 100%;"' + id + name + validationmessage + ' class="cronDynamicSelect" ng-model="' + attrs.ngModel + '"/>');
 
             //https://stackoverflow.com/questions/21948067/issues-with-ng-required-directive-angular-js
             attrs.$observe('required', function(value) {
@@ -3650,6 +3657,8 @@
               $(combobox.element[0]).attr('class','cron-select-offscreen');
             }
 
+            $(combobox.wrapper).children('.k-dropdown-wrap').children('.k-select').before(inputSelect);
+
             var forceChangeModel = function(value) {
               if (combobox.isEvaluating) {
                 setTimeout(function() {
@@ -3714,7 +3723,7 @@
                       dataSourceScreen.fetch({
                         params: {
                           $top: 1
-                          }
+                        }
                       }, {
                         success: function(data) {
                           if (data.length) {
@@ -3783,7 +3792,7 @@
                     }
                   }
 
-                 _compileAngular(scope, options.combobox.element[0]);
+                  _compileAngular(scope, options.combobox.element[0]);
                 });
 
               }
@@ -3911,7 +3920,13 @@
             var parent = element.parent();
             var id = attrs.id ? ' id="' + attrs.id + '"' : '';
             var name = attrs.name ? ' name="' + attrs.name + '"' : '';
-            $(parent).append('<div style="width: 100%;"> <input style="width: 100%;"' + id + name + ' class="cronMultiSelect" ng-model="' + attrs.ngModel + '"/> </div>');
+
+            let required = attrs.ngRequired && eval(attrs.ngRequired) ? `required="required"`: '';
+            $(parent).append(`<div style="width: 100%;"> <input style="width: 100%;" ${id} ${name} ${required} class="cronMultiSelect" ng-model="${attrs.ngModel}"/> </div>`);
+            $(parent).find('label').attr('for',attrs.id);
+            let $inp = $(`${attrs.id}`);
+            $compile($inp)(scope);
+
             var $element = $(parent).find('input.cronMultiSelect');
             $(element).remove();
 
@@ -4025,7 +4040,7 @@
                 combobox.readonly(_scope.$eval(attrs.crnReadonly));
               });
             }
-            
+
             var convertArray = function(value) {
               var result = [];
               if (value) {
@@ -4038,6 +4053,16 @@
 
             scope.$watchCollection(function(){return ngModelCtrl.$modelValue}, function(value, old){
               var silent = $(combobox).data('silent');
+
+              if (value.length === 0) {
+                $(`#${attrs.id}`).addClass('ng-empty');
+                attrs.ngRequired && eval(attrs.ngRequired) && $(`#${attrs.id}`).attr('required', 'required');
+              }
+              else {
+                $(`#${attrs.id}`).removeClass('ng-empty');
+                $(`#${attrs.id}`).removeAttr('required');
+              }
+
               $(combobox).data('silent', false);
               if (!silent && (JSON.stringify(value) !== JSON.stringify(old))) {
                 if (relactionDS.relationDataSource && relactionDS.relationField) {
@@ -4076,11 +4101,12 @@
             var parent = element.parent();
             var id = attrs.id ? ' id="' + attrs.id + '"' : '';
             var name = attrs.name ? ' name="' + attrs.name + '"' : '';
+            var validationmessage = attrs.validationmessage ? ' validationmessage="' + attrs.validationmessage + '"' : '';
             var required = '';
             if (attrs.ngRequired || attrs.required) {
               required = ' required ';
             }
-            $(parent).append('<input style="width: 100%;" ' + id + name + required + ' class="cronAutoComplete" ng-model="' + attrs.ngModel + '"/>');
+            $(parent).append('<input style="width: 100%;" ' + id + name + required + validationmessage + ' class="cronAutoComplete" ng-model="' + attrs.ngModel + '"/>');
             var $element = $(parent).find('input.cronAutoComplete');
             $(element).remove();
 
@@ -4090,6 +4116,20 @@
               });
             }
 
+            if(attrs.autoExpand == "true"){
+                $element.on('focus', function (e) {
+                    autoComplete.search();
+                });
+              }
+
+            options.messages =  {
+                noData: attrs.noResultsMessage ? attrs.noResultsMessage : "NO DATA FOUND"
+            };
+
+            if(attrs.firstOptionOnBlur == "false"){
+                options.suggest = false;
+            }
+
             var autoComplete = $element.kendoAutoComplete(options).data('kendoAutoComplete');
             autoComplete.enable(true);
 
@@ -4148,6 +4188,7 @@
             if ($element.data('alreadycompiled'))
               return;
             $element.data('alreadycompiled',true);
+            $element.data('$compile', $compile);
 
             if (attrs.fromGrid) {
               $element = $(element);
@@ -4163,30 +4204,7 @@
 
             var datePicker = app.kendoHelper.buildKendoMomentPicker($element, options, scope, ngModelCtrl);
 
-            if (attrs.fromGrid) {
-              var initialDate = $element.data('initial-date');
-              var unmaskedvalue = function() {
-                var momentDate = null;
-
-                var valueDate =  $(this).val();
-                if (initialDate) {
-                  valueDate = initialDate;
-                  initialDate = undefined;
-                }
-
-                if (useUTC) {
-                  momentDate = moment(valueDate, options.momentFormat).utcOffset(window.timeZoneOffset);
-                } else {
-                  momentDate = moment(valueDate, options.momentFormat);
-                }
-
-                datePicker.value(momentDate.format(options.momentFormat));
-                $(this).data('rawvalue', momentDate.toDate());
-              }
-              $(element).on('keydown', unmaskedvalue).on('keyup', unmaskedvalue).on('change', unmaskedvalue);
-              unmaskedvalue.bind($element)();
-            }
-            else {
+            if (!attrs.fromGrid) {
               if (ngModelCtrl) {
                 ngModelCtrl.$formatters.push(function (value) {
                   var selDate = null;
@@ -4212,7 +4230,7 @@
                   if (value) {
                     var momentDate = null;
                     if (useUTC) {
-                      momentDate = moment(datePicker._oldText, options.momentFormat).utcOffset(window.timeZoneOffset);;
+                      momentDate = moment(datePicker._oldText, options.momentFormat).utcOffset(window.timeZoneOffset);
                     } else {
                       momentDate = moment(datePicker._oldText, options.momentFormat);
                     }
@@ -4507,92 +4525,175 @@
         }
       })
 
-      .directive('cronDynamicMenu', ['$compile', '$translate', function($compile, $translate){
+      .directive('cronDynamicMenu', ['$compile', '$translate', function ($compile, $translate) {
         'use strict';
-
-        return {
-          restrict: 'EA',
-          populateItems: function(items) {
-            var template = '';
-
-            if (items && items != null && Array.isArray(items)) {
-              items.forEach(function(item) {
-                var security = (item.security && item.security != null) ? ' cronapp-security="' + item.security + '" ' : '';
-                var action = (item.action && item.action != null) ? ' ng-click="' + item.action + '" ' : '';
-                var hide = (item.hide && item.hide != null) ? ' ng-hide="' + item.hide + '" ' : '';
-                var iconClass = (item.iconClass && item.iconClass != null) ? '<i class="'+ item.iconClass +'"></i>&nbsp;' : '';
-                var title = '<span></span>';
-                if (item.title)
-                  title = '<span>' + $translate.instant(item.title) + '</span>';
-
-                template = template + '<li'+ hide +'><a href=""' + security + action + '>' + iconClass + title + '</a></li>';
-              });
-
-              if (template != '') {
-                template = '<ul class="dropdown-menu">' + template + '</ul>';
+        const populateSubitems = (item) => {
+          var subitem = item.menuItems;
+          var templateSubitens = '';
+  
+          subitem.forEach((subitem) => {
+            var securitySubitem = (subitem.security && subitem.security != null) ? ' cronapp-security="' + subitem.security + '" ' : '';
+            var actionSubitem = (subitem.action && subitem.action != null) ? ' ng-click="' + subitem.action + '" ' : '';
+            var hideSubitem = (subitem.hide && subitem.hide != null) ? ' ng-hide="' + subitem.hide + '" ' : '';
+            var iconClassSubitem = (subitem.iconClass && subitem.iconClass != null) ? '<i class="' + subitem.iconClass + '"></i>&nbsp;' : '';
+            var titleSubitem = '<span></span>';
+            var caretSubitem = (subitem.menuItems && Array.isArray(subitem.menuItems) && (subitem.menuItems.length > 0)) ? '<span class="caret submenu"></span>' : '';
+  
+            if (subitem.title) {
+              titleSubitem = '<span>' + $translate.instant(subitem.title) + '</span>';
+            }
+  
+            if (subitem.menuItems.length > 0) {
+              templateSubitens = templateSubitens + '<li class="dropdown-submenu">\
+                      <a class="dropdown-item dropdown-toggle" role="button" aria-haspopup="true" aria-expanded="false" href=""' + securitySubitem + actionSubitem + '>' + iconClassSubitem + titleSubitem + caretSubitem + '</a>\
+                      ' + populateItems(subitem.menuItems) + '\
+                    </li>';
+  
+            } else {
+              templateSubitens = templateSubitens + '<li class="dropdown-submenu">\
+                      <a  role="button" aria-haspopup="true" aria-expanded="false" href=""' + securitySubitem + actionSubitem + '>' + iconClassSubitem + titleSubitem + caretSubitem + '</a>\
+                    </li>';
+            }
+          });
+  
+          if (templateSubitens != '') {
+            templateSubitens = '<ul class="dropdown-menu">' + templateSubitens + '</ul>';
+          }
+  
+          return templateSubitens;
+        };
+  
+        const populateItems = (items) => {
+          var templateItens = '';
+  
+          if (items && items.length > 0 && Array.isArray(items)) {
+            items.forEach(function (item) {
+  
+              var security = (item.security && item.security != null) ? ' cronapp-security="' + item.security + '" ' : '';
+              var action = (item.action && item.action != null) ? ' ng-click="' + item.action + '" ' : '';
+              var hide = (item.hide && item.hide != null) ? ' ng-hide="' + item.hide + '" ' : '';
+              var iconClass = (item.iconClass && item.iconClass != null) ? '<i class="' + item.iconClass + '"></i>&nbsp;' : '';
+              var title = '<span></span>';
+              var caret = (item.menuItems && Array.isArray(item.menuItems) && (item.menuItems.length > 0)) ? '<span class="caret submenu"></span>' : '';
+  
+              if (item.title) {
+                title = '<span>' + $translate.instant(item.title) + '</span>';
+              }
+  
+              if (item.menuItems.length > 0) {
+                templateItens = templateItens + '\
+                        <li class="dropdown-submenu" ' + hide + '> \
+                          <a  href="" ' + action + ' class="dropdown-item dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">' + iconClass + title + caret + ' </a> \
+                            ' + populateSubitems(item) + '\
+                        </li>';
+              } else {
+                templateItens = templateItens + '\
+                        <li class="dropdown-submenu" ' + hide + '> \
+                          <a  href="" ' + action + ' class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">' + iconClass + title + caret + ' </a> \
+                        </li>';
               }
+  
+            });
+  
+            if (templateItens != '') {
+              templateItens = '<ul class="dropdown-menu">' + templateItens + '</ul>';
             }
-
-            return template;
-          },
-          populateMenu: function(menuOptions, isVertical) {
+          }
+  
+          return templateItens;
+        }
+        return {
+          restrict: 'EA',
+          populateMenu: function (menuOptions, isVertical) {
             var template = '';
-
-            if (menuOptions && menuOptions!= null && menuOptions.subMenuOptions && menuOptions.subMenuOptions != null && Array.isArray(menuOptions.subMenuOptions)){
-              var _populateItems = this.populateItems;
-              menuOptions.subMenuOptions.forEach(function(menu) {
+  
+            if (menuOptions && menuOptions != null && menuOptions.subMenuOptions && menuOptions.subMenuOptions != null && Array.isArray(menuOptions.subMenuOptions)) {
+  
+              menuOptions.subMenuOptions.forEach(function (menu) {
+  
                 var security = (menu.security && menu.security != null) ? ' cronapp-security="' + menu.security + '" ' : '';
                 var action = (menu.action && menu.action != null) ? ' ng-click="' + menu.action + '" ' : '';
                 var caret = (menu.menuItems && Array.isArray(menu.menuItems) && (menu.menuItems.length > 0)) ? '<span class="caret"></span>' : '';
                 var hide = (menu.hide && menu.hide != null) ? ' ng-hide="' + menu.hide + '" ' : '';
-                var iconClass = (menu.iconClass && menu.iconClass != null) ? '<i class="'+ menu.iconClass +'"></i>&nbsp;' : '';
+                var iconClass = (menu.iconClass && menu.iconClass != null) ? '<i class="' + menu.iconClass + '"></i>&nbsp;' : '';
                 var title = '<span></span>'
-                if (menu.title)
+  
+                if (menu.title) {
                   title = '<span>' + $translate.instant(menu.title) + '</span>';
-
-                template = template  + '\
-                <li class="dropdown component-holder crn-menu-item '+(isVertical?'col-md-12 padding-0':'')+'" data-component="crn-menu-item"' + security + hide + '>\
-                  <a href="" ' + action + ' class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">\
-                  ' + iconClass + title + caret +  '\
-                  </a> \
-                  ' + _populateItems(menu.menuItems) + '\
-                </li>';
+                }
+  
+                template = template + '\
+                      <li class="dropdown nav-item '+ (isVertical ? 'col-md-12 padding-0' : '') + '"' + security + hide + '>\
+                        <a href="" ' + action + ' class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">\
+                        ' + iconClass + title + caret + '\
+                        </a> \
+                        ' + populateItems(menu.menuItems) + '\
+                      </li>';
+  
               })
             }
-
+  
             return template;
           },
-          link: function(scope, element, attrs) {
+          link: function (scope, element, attrs) {
             $translate.onReady(() => {
               //Somente fica na vertical se for o menu principal da IDE (E estiver configurado para isso)
-              let isVertical =  element.closest('.crn-navigator-vertical').length;
-
-              var TEMPLATE_MAIN = '<ul class="nav navbar-nav '+(isVertical?'col-md-12 padding-0':'')+' " style="float:left"></ul>';
+              let isVertical = element.closest('.crn-navigator-vertical').length;
+  
+              var TEMPLATE_MAIN = '<ul  class="nav navbar-nav ' + (isVertical ? 'col-md-12 padding-0' : '') + ' " style="float:left"></ul>';
               var options = {};
               try {
                 options = JSON.parse(attrs.options);
-              } catch(e) {
+              } catch (e) {
                 console.log('CronDynamicMenu: Invalid configuration!')
               }
-
+  
               var main = $(TEMPLATE_MAIN);
               main.attr('id', attrs.id);
-              
+  
               var menus = this.populateMenu(options, isVertical);
               main.append(menus);
               if (isVertical) {
-                main.append( $('#navbar2 li:first').addClass('col-md-12 padding-0') );
+                main.append($('#navbar2 li:first').addClass('col-md-12 padding-0'));
               }
-
+  
               var newElement = angular.element(main);
               element.html('');
               element.append(main);
-              element.attr('id' , null);
+              element.attr('id', null);
               $compile(newElement)(scope);
+  
+              var multilevelAction = attrs.multilevelAction;
+  
+              if (multilevelAction === 'hover') {
+                $('.dropdown-menu .dropdown-submenu').on('mouseover', function () {
+                  var subMenu = $(this).children('ul.dropdown-menu');
+                  subMenu.addClass('displayBlock');
+                });
+  
+                $('.dropdown-menu .dropdown-submenu').on('mouseout', function () {
+                  var subMenu = $(this).children('ul.dropdown-menu');
+                  subMenu.removeClass('displayBlock');
+                });
+              }
+              if (multilevelAction === 'click') {
+                $('.dropdown-menu a.dropdown-toggle').on('click', function (e) {
+                  if (!$(this).next().hasClass('show')) {
+                    $(this).parents('.dropdown-menu').first().find('.show').removeClass("show");
+                  }
+                  var $subMenu = $(this).next(".dropdown-menu");
+                  $subMenu.toggleClass('show');
+                  $(this).parents('li.nav-item.dropdown').on('hidden.bs.dropdown', function (e) {
+                    $('.dropdown-submenu .show').removeClass("show");
+                  });
+                  return false;
+                });
+              }
+  
             });
           }
         }
-    }])
+      }])
 
       .directive('ngInitialValue', function($parse) {
         return {
@@ -4640,47 +4741,37 @@
           link: function (scope, el, attrs, ctrl) {
             ctrl.$formatters = [];
             ctrl.$parsers = [];
-            let falseValue = attrs.ngFalseValue ? attrs.ngFalseValue.split("'").join("") : "false";
-            let trueValue = attrs.ngTrueValue ? attrs.ngTrueValue.split("'").join("") : "true";
+
+            let falseValue = attrs.ngFalseValue ? attrs.ngFalseValue.split("'").join("") : false;
+            let trueValue = attrs.ngTrueValue ? attrs.ngTrueValue.split("'").join("") : true;
 
             if (attrs.crnAllowNullValues == 'true') {
               ctrl.$render = function () {
                 let viewValue = ctrl.$viewValue;
                 el.data('checked', viewValue);
-                viewValue =  '' + viewValue;
                 switch (viewValue) {
                   case true:
                   case trueValue:
                     el.prop('indeterminate', false);
                     el.prop('checked', true);
+                    viewValue = trueValue;
                     break;
                   case false:
                   case falseValue:
                     el.prop('indeterminate', false);
                     el.prop('checked', false);
+                    viewValue = falseValue;
                     break;
                   default:
+                    viewValue = null;
                     el.prop('indeterminate', true);
                 }
+                ctrl.$setViewValue(viewValue);
               };
-              el.bind('click', function () {
-                let checked;
-                switch (el.data('checked')) {
-                  case false:
-                  case falseValue:
-                    checked = attrs.ngTrueValue ? trueValue : true;
-                    break;
-                  default:
-                    checked = attrs.ngFalseValue ? falseValue : false;
-                }
-                ctrl.$setViewValue(checked);
-                scope.$apply(ctrl.$render);
-              });
             } else if (attrs.crnAllowNullValues == 'false') {
               ctrl.$render = function () {
                 let viewValue = ctrl.$viewValue;
-                viewValue =  '' + viewValue;
-                if (viewValue === undefined || viewValue === null) {
+                if (ctrl.$viewValue === undefined || ctrl.$viewValue === null) {
                   ctrl.$setViewValue(false);
                   viewValue = false;
                 }
@@ -4694,27 +4785,30 @@
                   case trueValue:
                     el.prop('indeterminate', false);
                     el.prop('checked', true);
+                    viewValue = trueValue;
                     break;
                   default:
                     el.prop('indeterminate', false);
                     el.prop('checked', false);
+                    viewValue = falseValue;
                     break;
                 }
+                ctrl.$setViewValue(viewValue);
               };
-              el.bind('click', function () {
-                let checked;
-                switch (el.data('checked')) {
-                  case false:
-                  case falseValue:
-                    checked = attrs.ngTrueValue ? trueValue : true;
-                    break;
-                  default:
-                    checked = attrs.ngFalseValue ? falseValue : false;
-                }
-                ctrl.$setViewValue(checked);
-                scope.$apply(ctrl.$render);
-              });
             }
+            el.bind('click', function () {
+              let checked;
+              switch (el.data('checked')) {
+                case false:
+                case falseValue:
+                  checked = attrs.ngTrueValue ? trueValue : true;
+                  break;
+                default:
+                  checked = attrs.ngFalseValue ? falseValue : false;
+              }
+              ctrl.$setViewValue(checked);
+              scope.$apply(ctrl.$render);
+            });
           }
         };
       }])
@@ -4740,24 +4834,88 @@
       }])
 
       .directive('updateLanguage', function($rootScope) {
-          return {
-              link: function( scope, element ) {
-                  var listener = function( event, translationResp ) {
-                      var defaultLang = "en",
-                          currentlang = translationResp.language;
-
-                      if (currentlang  === 'pt_br')
-                        currentlang = "pt-br";
-                      else if (currentlang.startsWith('en'))
-                        currentlang = "en";
-
-                      element.attr("lang", currentlang || defaultLang );
-                  };
+        return {
+          link: function( scope, element ) {
+            var listener = function( event, translationResp ) {
+              var defaultLang = "en",
+                  currentlang = translationResp.language;
+
+              if (currentlang  === 'pt_br')
+                currentlang = "pt-br";
+              else if (currentlang.startsWith('en'))
+                currentlang = "en";
+
+              element.attr("lang", currentlang || defaultLang );
+            };
+
+            $rootScope.$on('$translateChangeSuccess', listener);
+          }
+        };
+      })
 
-                  $rootScope.$on('$translateChangeSuccess', listener);
+      .directive("fromGrid", ($compile) => {
+        return {
+          restrict: 'A',
+          priority: -999999,
+          exist: (element) => {
+            let id = element.attr('id');
+            return $(`#${id}`).length;
+          },
+          isFromGrid: (attr) => {
+            return attr.fromGrid === "true";
+          },
+          isCompiled: (element) => {
+            return element.data('alreadycompiled');
+          },
+          getDateAs: function (element, value, as) {
+            let mask = element.data('mask');
+            let useUTC = element.data('useUTC');
+            return formatWithMomentAs(mask, useUTC, value, as);
+          },
+          prepareValue: function (element, value) {
+            let columnType = element.data('column-type') || '';
+            if (columnType.startsWith('date')) {
+              value = this.getDateAs(element, value, "date");
+            }
+            return value;
+          },
+          formatComponent: function (element, value) {
+            let kendoObj = element.data('kendoDropDownList') || element.data('kendoSlider');
+            let columnType = element.data('column-type') || '';
+            if (columnType.startsWith('date')) {
+              element.val(this.getDateAs(element, value, "string"));
+            }
+            else if (kendoObj) {
+              kendoObj.value(value);
+            }
+          },
+          compileGridListing: function(element, scope) {
+            let sender = element.data('ref-component');
+            if (sender && sender.tbody && sender.tbody.length && !$(sender.tbody).find('.k-grid-edit-row').length) {
+              var toCompile = sender.tbody;
+              setTimeout(() => {
+                scope.safeApply(() => {
+                  var trs = $(toCompile);
+                  var x = angular.element(trs);
+                  $compile(x)(scope);
+                });
+              });
+            }
+          },
+          link: function (scope, element, attr) {
+            scope.$watch(attr.ngModel, (value) => {
+              if (this.isFromGrid(attr) && this.exist(element) && this.isCompiled(element)) {
+                value = this.prepareValue(element, value);
+                this.formatComponent(element, value);
+                this.compileGridListing(element, scope);
+                call = element.data('change-grid-model');
+                call && call(value);
               }
-          };
+            });
+          }
+        }
       })
+
 }(app));
 
 function maskDirectiveAsDate($compile, $translate, $parse) {
@@ -4785,6 +4943,7 @@ function maskDirective($compile, $translate, $parse, attrName) {
       if ($element.data('alreadycompiled'))
         return;
       $element.data('alreadycompiled', true);
+      $element.data('$compile', $compile);
 
       var type = $element.attr("type");
 
@@ -4866,6 +5025,9 @@ function maskDirective($compile, $translate, $parse, attrName) {
           useUTC = false;
         }
 
+        $element.data('mask', mask);
+        $element.data('useUTC', useUTC);
+
         if ($element.attr('from-grid')) {
           var openPopup = function() {
             var popup = $(this).offset();
@@ -4898,16 +5060,20 @@ function maskDirective($compile, $translate, $parse, attrName) {
             setTimeout(openPopup.bind(this), 100);
           });
           $element.on('dp.change', function () {
-            var momentDate = null;
-            if (useUTC) {
-              momentDate = moment($element.val(), mask).utcOffset(window.timeZoneOffset);
-            } else {
-              momentDate = moment($element.val(), mask);
-            }
-            if (type == 'time' || type == 'time-local') {
-              momentDate = momentDate.year(1970).dayOfYear(1).month(0);
-            }
-            $element.data('rawvalue', momentDate.toDate());
+            scope.safeApply(function () {
+              var momentDate = null;
+              if (useUTC) {
+                momentDate = moment($element.val(), mask).utcOffset(window.timeZoneOffset, true);
+              } else {
+                momentDate = moment($element.val(), mask);
+              }
+              if (type == 'time' || type == 'time-local') {
+                momentDate = momentDate.year(1970).dayOfYear(1).month(0);
+              }
+              if (momentDate.isValid() && ngModelCtrl) {
+                modelSetter(scope, momentDate.toDate());
+              }
+            });
           });
           if ($element.data('initial-value')) {
             var initialValue = $element.data('initial-value');
@@ -4926,46 +5092,33 @@ function maskDirective($compile, $translate, $parse, attrName) {
           $element.wrap("<div style=\"position:relative\"></div>");
         }
         $element.datetimepicker(options);
-
-        $element.on('dp.change', function () {
-          if ($(this).is(":visible")) {
-            $(this).trigger('change');
-            scope.safeApply(function () {
-              var value = $element.val();
-              var momentDate = null;
-              if (useUTC) {
-                momentDate = moment(value, mask).utcOffset(window.timeZoneOffset, true);
-              } else {
-                momentDate = moment(value, mask);
-              }
-              if (type == 'time' || type == 'time-local') {
-                momentDate = momentDate.year(1970).dayOfYear(1).month(0);
-              }
-              if (momentDate.isValid() && ngModelCtrl) {
-                modelSetter(scope, momentDate.toDate());
-              }
-            });
-          }
-        });
-
-        if (ngModelCtrl) {
-          ngModelCtrl.$formatters.push(function (value) {
-            if (value) {
-              var momentDate = null;
-
-              if (useUTC) {
-                momentDate = moment(value).utcOffset(window.timeZoneOffset);
-                if(!momentDate.isValid()){
-                  momentDate = moment(value, mask).utcOffset(window.timeZoneOffset);
-                }
-              } else {
-                momentDate = moment(value);
-                if(!momentDate.isValid()){
+        if (attrs.fromGrid !== "true") {
+          $element.on('dp.change', function () {
+            if ($(this).is(":visible")) {
+              $(this).trigger('change');
+              scope.safeApply(function () {
+                var value = $element.val();
+                var momentDate = null;
+                if (useUTC) {
+                  momentDate = moment(value, mask).utcOffset(window.timeZoneOffset, true);
+                } else {
                   momentDate = moment(value, mask);
                 }
-              }
+                if (type == 'time' || type == 'time-local') {
+                  momentDate = momentDate.year(1970).dayOfYear(1).month(0);
+                }
+                if (momentDate.isValid() && ngModelCtrl) {
+                  modelSetter(scope, momentDate.toDate());
+                }
+              });
+            }
+          });
+        }
 
-              return momentDate.format(mask);
+        if (ngModelCtrl ) {
+          ngModelCtrl.$formatters.push(function (value) {
+            if (value) {
+              return formatWithMomentAs(mask, useUTC, value, "string");
             }
 
             if(value === null){
@@ -5068,29 +5221,20 @@ function maskDirective($compile, $translate, $parse, attrName) {
         $(element).inputmask(inputmaskType, ipOptions);
         useInputMaskPlugin(element, ngModelCtrl, scope, modelSetter, mask);
       }
-      else if (type == 'text' || type == 'tel') {
+      else if (type == 'text' || type == 'tel' || type == 'string') {
         if(!attrs.maskPlaceholder){
           $element.mask(mask);
           useMaskPlugin(element, ngModelCtrl, scope, modelSetter, removeMask);
         }
         else{
           options = {};
-          options['placeholder'] = attrs.maskPlaceholder
+          options['placeholder'] = attrs.maskPlaceholder;
           $(element).inputmask(mask, options);
           if(removeMask){
             useInputMaskPlugin(element, ngModelCtrl, scope, modelSetter, mask);
           }
         }
       }
-      else {
-        if ($element.attr('from-grid')) {
-          var unmaskedvalue = function() {
-            $(this).data('rawvalue',$(this).val());
-          }
-          $(element).on('keydown', unmaskedvalue).on('keyup', unmaskedvalue);
-          $element.mask(mask);
-        }
-      }
     }
   }
 }
@@ -5242,6 +5386,16 @@ function transformText() {
 
 
 app.kendoHelper = {
+  getCorrectlyDS: (name, scope) => {
+    if (scope[name].apiVersion) {
+      return scope[name];
+    }
+    else {
+      let ds = scope.$parent[name];
+      scope[name] = ds;
+      return ds;
+    }
+  },
   receivePushData: comp => !comp || !comp.dataSource || (comp.dataSource.transport.options.refComponent = comp),
   getSchema: function(dataSource) {
     var parseAttribute = [
@@ -5339,8 +5493,8 @@ app.kendoHelper = {
     };
 
     var pageSize = 10;
-    if (scope[dataSource.name])
-      pageSize = scope[dataSource.name].rowsPerPage;
+    if (app.kendoHelper.getCorrectlyDS(dataSource.name, scope))
+      pageSize = app.kendoHelper.getCorrectlyDS(dataSource.name, scope).rowsPerPage;
 
     //Quando não for data UTC
     var offsetMiliseconds = new Date().getTimezoneOffset() * 60000;
@@ -5435,7 +5589,7 @@ app.kendoHelper = {
             if (this.options.isComponentInDocument(this.options.refComponent)) {
               let current = this.options.getCurrentCallbackForPush(callback, this.options.refComponent);
               let acceptedMethod = current[type];
-              
+
               if (acceptedMethod) {
                 acceptedMethod(data);
               }
@@ -5535,13 +5689,13 @@ app.kendoHelper = {
             if (dataSource.append) {
               append = dataSource.append;
             }
-  
+
             var fetchOptions = {};
             //indicates that the search has already been clicked, set the fetchOptions orign to loadDataStrategy
             if (cronappDatasource.loadDataStrategy === "button" && cronappDatasource.data.length > 0) {
               fetchOptions.origin = cronappDatasource.loadDataStrategy;
             }
-  
+
             cronappDatasource.append = append;
             cronappDatasource.fetch(fetchData, {
               success:  function(data) {
@@ -5625,7 +5779,7 @@ app.kendoHelper = {
               return callback;
             return component;
           },
-          cronappDatasource: scope[dataSource.name]
+          cronappDatasource: app.kendoHelper.getCorrectlyDS(dataSource.name, scope)
         }
       },
       pageSize: pageSize,
@@ -5955,39 +6109,32 @@ app.kendoHelper = {
       useUTC = false;
     }
 
-    if (!$element.attr('from-grid')) {
-      var onChange = function() {
-        var value = $element.val();
-        if (!value || value.trim() == '') {
-          if (ngModelCtrl)
-            ngModelCtrl.$setViewValue('');
-        } else {
-          var momentDate = null;
-
-          if (useUTC) {
-            momentDate = moment(value, options.momentFormat).utcOffset(window.timeZoneOffset);
-          } else {
-            momentDate = moment(value, options.momentFormat);
-          }
-
-          if (ngModelCtrl && momentDate.isValid()) {
-            ngModelCtrl.$setViewValue(momentDate.toDate());
-            $element.data('changed', true);
-          }
-        }
-      }
+    $element.data('mask', options.momentFormat);
+    $element.data('useUTC', useUTC);
 
-      if (scope) {
-        options['change'] = function() {
-          scope.$apply(function () {
-            onChange();
-          });
-        };
+    var onChange = function() {
+      var value = $element.val();
+      if (!value || value.trim() == '') {
+        if (ngModelCtrl)
+          ngModelCtrl.$setViewValue('');
       } else {
-        options['change'] = onChange;
+        var valueDate = formatWithMomentAs(options.momentFormat, useUTC, value, "date");
+        if (ngModelCtrl) {
+          ngModelCtrl.$setViewValue(valueDate);
+          $element.data('changed', true);
+        }
       }
     }
 
+    if (scope) {
+      options['change'] = function() {
+        scope.$apply(function () {
+          onChange();
+        });
+      };
+    } else {
+      options['change'] = onChange;
+    }
 
     if (options.type == 'date') {
       return $element.kendoDatePicker(options).data('kendoDatePicker');
@@ -6088,3 +6235,29 @@ window.useMask = function(value, format, type) {
 
   return mask;
 };
+
+window.formatWithMomentAs = function (mask, useUTC, value, as) {
+
+  if (!value) return;
+
+  let momentDate = null;
+
+  if (value instanceof Date || value.startsWith('/Date')) {
+    if (useUTC) {
+      momentDate = moment(value).utcOffset(window.timeZoneOffset);
+    } else {
+      momentDate = moment(value);
+    }
+  }
+  else  {
+    if (useUTC) {
+      momentDate = moment(value, mask).utcOffset(window.timeZoneOffset, true);
+    } else {
+      momentDate = moment(value, mask);
+    }
+  }
+  if (as === 'string') {
+    return momentDate.format(mask);
+  }
+  return momentDate.toDate();
+};