Comunicação da aplicação com o framework

	index.stateProvider
	/** 
	 * Estado pai, a hierarquia de states é feita através do '.', e todo estado novo tem que
	 * ter um estado pai, que nesse caso é abstrato. Este status precisa apenas de uma
	 * template com o elemento <ui-view> para conter os estados filhos.
	 */
	.state('totvs-pnk/mapping', {
		abstract: true,
		template: '<br><ui-view/>'
	})
	/** 
	 * Estado inicial da tela deve ser o estado pai com o sufixo '.start' este estado será
	 * ativado automaticamente quando a tela for carregada.
	 * a URL deve ser compativel com a tela inicial.
	 * No estado tambem definimos o controller usado na template do estado, e definimos
	 * o nome do controller em 'controllerAs' para ser utilizado na view.
	 * tambem definimos a template ou templateUrl com o HTML da tela da view.
	 *
	 * Para ententer o motivo de utilizar o controllerAs e outras tecnicas neste fonte,
	 * deve ser lido o seguinte artigo:
	 * http://www.technofattie.com/2014/03/21/five-guidelines-for-avoiding-scope-soup-in-angular.html
	 *
	 */
	.state('totvs-pnk/mapping.start', {
		url: '/totvs-pnk/mapping/',
		controller: 'totvs-pnk.mapping.ListCtrl',
		controllerAs: 'controller',
		templateUrl: '/totvs-pnk/html/mapping/mapping.list.html'
	})
	/**
	 * Notar que outros estados tambem são filhos com sufixos conforme o objetivo da tela, assim
	 * como o padrão da URL, controller e template.
	 */
	.state('totvs-pnk/mapping.edit', {
		url: '/totvs-pnk/mapping/edit/:id',
		controller: 'totvs-pnk.mapping.EditCtrl',
		controllerAs: 'controller',
		templateUrl: '/totvs-pnk/html/mapping/mapping.edit.html'
	});

	index.register.controller('totvs-pnk.mapping.ListCtrl', controllerMappingListCtrl);
	index.register.controller('totvs-pnk.mapping.EditCtrl', controllerMappingEditCtrl);

	function controllerMappingListCtrl(loadedModules, mappingResource, $location, sessionContext, $log,
		messageHolder, modalService, serviceHelper, filterByService) {
		var listCtrl = this;
		angular.extend(this, filterByService);
		angular.extend(this, mappingResource);
}

	serviceTaskControl.$inject = ['sessionContext', 'html-framework.Helper', 'portal-crm.Legend',
									'portal-crm.task.Service', 'portal-crm.task.AdvancedSearch', 'html-framework.FilterBy',
									'portal-crm.task.ModalService', 'portal-crm.history.ModalService'];
	function serviceTaskControl(sessionContext, helperService, legendService,
								taskService, taskAdvancedSearchService, filterByService,
								serviceTaskModal, serviceHistoryModal) {
		var service = {};
		angular.extend(service, filterByService);
		angular.extend(service, taskAdvancedSearchService);
		angular.extend(service, {

			legend : legendService,
			helper : helperService,
			// Variable
			listResult : undefined,
			totalRecords : undefined,
			quickSearchText : undefined,
			isAdvancedSearch : undefined,
			applyFilterUser : true,

			loadDefaults : function() {
				var _self = this;
				_self.listResult = [];
				_self.totalRecords = 0;
				_self.quickSearchText = '';
				_self.isAdvancedSearch = false;
				taskService.isOnlyResponsibleExecuteTask(function(result) {
					_self.isOnlyResponsibleExecuteTask = result;
				});
				taskService.isToOpenHistoryAfterExecute(function(result) {
					_self.isToOpenHistoryAfterExecute = result;
				});
			}

		});
		return service;
	} // serviceTaskControl

		if (loadedModules.startModule(sessionContext.i18n("mappings"), 'totvs-pnk.mapping.ListCtrl', this)) {
			mappingResource.findRecords(null, 20, null, listCtrl.listCallback);
		};

	serviceAccountControl.$inject = ['sessionContext', 'html-framework.Helper', 'portal-crm.Legend',
									'portal-crm.account.Service', 'portal-crm.account.AdvancedSearch', 'html-framework.FilterBy',
									'portal-crm.history.ModalService', 'portal-crm.task.ModalService', 'portal-crm.support.ModalService'];
	function serviceAccountControl(sessionContext, helperService, legendService,
									accountService, accountAdvancedSearchService, filterByService,
									serviceHistoryModal, serviceTaskModal, serviceSupportModal) {
		var service = {};
		angular.extend(service, filterByService);
		angular.extend(service, accountAdvancedSearchService);
		angular.extend(service, {
			// Services
			legend : legendService,
			helper : helperService,
			context : sessionContext,
			service : accountService,
			// Variable
			listResult : undefined,
			totalRecords : undefined,
			quickSearchText : undefined,
			isAdvancedSearch : undefined,
			// Retorna se o usuario tem permissao para remover a conta
			canRemove : function(account) {
				if (account.accountType == 1) {
					return true;
				}
				return false;
			}
		});
		return service;

		listCtrl.preSavedFilters = {
			'PUBLISHED': [{
				property: 'published',
				restriction: 'EQUALS',
				value: true
				}],
			'UNPUBLISHED': [{
					property: 'published',
					restriction: 'EQUALS',
					value: false
					},
				{
					property: 'publicationDate',
					restriction: 'EQUALS',
					value: undefined
					}],
			'NOTPUBLISHED': [{
				property: 'published',
				restriction: 'EQUALS',
				value: false
				}]
		};

		this.setQuickFilter = function (quickFilterName) {
			this.clearDefaultData(false);
			this.clearSearchModel();
			var filterClause = [];
			if (listCtrl.preSavedFilters) {
				var filters = listCtrl.preSavedFilters;
				for (var index in filters) {
					if (filters.hasOwnProperty(index)) {
						if (index == quickFilterName) {
							filterClause = filters[index];
						}
					}
				}
			}
			if (filterClause.length > 0) {
				angular.forEach(filterClause, function (itemFilter) {
					listCtrl.searchModel[itemFilter.property] = itemFilter.value;
				});
			}
			this.search(false, listCtrl);
		};

		this.applyFilters = function () {
			// Limpa a lista de filtros para refatoramento.
			this.clearFilter();
			// Adiciona os valores do model a lista de filtros
			var objSearch = listCtrl.searchModel;
			if (objSearch) {
				for (var key in objSearch) {
					if (objSearch.hasOwnProperty(key)) {
						this.addFilter(key, objSearch[key], 'l-' + key, objSearch[key]);
					}
				}
			}
        };

		this.afterRemove = function (obj) {
			var index = listCtrl.listResult.indexOf(obj);
			listCtrl.listResult.splice(index, 1);
			listCtrl.totalRecords--;
		}
		this.remove = function (model) {
			messageHolder.showQuestion('t-remove-mapping', 't-remove-mapping-confirmation', 'l-yes', 'l-no',
				function (result) {
					if (result === true) {
						mappingResource.deleteRecord(model.id, listCtrl.afterRemove(model));
					}
				});
		};

<!-- Código a ser inserido no HTML -->
	<form id="mappingForm" name="mappingForm" class="form-horizontal" role="form" data-ng-init="controller.setFormScope(this)">
	</form>
 
<!-- Código a ser inserido no Controller -->
		this.setFormScope = function (scope) {
			this.formScope = scope;
		}

this.save = function (action, model) {
var canSave = serviceHelper.validateForm(this.formScope.mappingForm);
if (canSave) {
   if (action == 'edit') {
        mappingResource.updateRecord(model.id, model);
   } 
   else 
   {
        model.published = false;
        mappingResource.saveRecord(model);
    }
}
};

		<field type="select" 
			   data-ng-model="controller.itemERP" 
			   zoom
			   zoom-service="totvs-pnk.item.Service" canclean>
			<label>{{ 'l-item' | i18n }}</label>
			<include>
				<ui-select-match placeholder="{{ 'l-item' | i18n }}">{{ $select.selected.name }}</ui-select-match>
				<ui-select-choices repeat="item in controller.flowItens track by $index" refresh="controller.searchItems($select.search)" 
								   refresh-delay="300">
					<span data-ng-bind-html="item.name | highlight: $select.search"></span>
				</ui-select-choices>
			</include>
		</field>

	serviceItem.$inject = ['html-framework.generic.Service', 'html-framework.generic-quick-search.Service',
						   'html-framework.generic-typeahead.Service', 'html-framework.generic-zoom.Service',
						   'totvs-pnk.item.Factory', 'html-framework.generic-crud.Service',
						   '$timeout', 'html-framework.generic-zoom.Service', 'html-framework.generic-typeahead.Service'];
	function serviceItem(genericService, genericQuickSearch, genericTypeaheadService,
		genericZoomService, factoryItem, genericCRUDService, $timeout, genericZoomService, genericTypeaheadService) {
		var service = {
			getFactory: function () {
				return factoryItem;
			},
			/**
			 * zoomName - é o nome que aparece no titulo do zoom, normalmente é o nome externo da tabela.
			 */
			zoomName: 'l-items',
			/**
			 * propertyFields - e um array de objetos com as propriedades label e property que definem
			 *                  os campos que deverão aparecer na opção do filtro do zoom.
			 */
			propertyFields: [{
					label: 'l-code',
					property: 'erpCode'
				},
				{
					label: 'l-name',
					property: 'name'
				},
				{
					label: 'l-description',
					property: 'description'
				}],
			/**
			 * tableHeader - é um array de objetos com as propriedades label e property que definem
			 *               as colunas que aparecem na tabela do zoom.
			 */
			tableHeader: [{
					label: 'l-erp-code',
					property: 'erpCode'
				},
				{
					label: 'l-name',
					property: 'name'
				},
				{
					label: 'l-description',
					property: 'description'
				}],
			
			returnValue: function () {
				return this.zoomResultList[this.selected];
			},
			/**
			 * applyFilter - é um metodo de carregar os dados do zoom, recebe como parametro um objeto
			 *               com as sequines propriedades:
			 *               init - contem o objeto informado no atributo zoom-init do zoom.
			 *               selectedFilter - contem o objeto do campo selecionado na pesquisa.
			 *               selectedFilterValue - contem o valor informado no campo de pesquisa.
			 *               more - valor logico informando se deve carregar mais dados no resultado
			 *                      ou iniciar uma nova pesquisa.
			 */
			applyFilter: function (parameters) {
				var _self = this;
				var value = parameters.selectedFilterValue;
				var startAt = (parameters.more ? _self.zoomResultList.length : 0);
				var filters = [
					{
						property: parameters.selectedFilter.property,
						value: value
					},
				];

				this.zoom(startAt,
					undefined,
					filters,
					function (result) {
						_self.resultTotal = 0;
						if (!parameters.more) {
							_self.zoomResultList = [];
						}
						angular.forEach(result, function (value) {
							if (value && value.$length) {
								_self.resultTotal = value.$length;
							}
							_self.zoomResultList.push(value);
						});
					});
			}
		};
		angular.extend(service, genericService);
		angular.extend(service, genericCRUDService);
		angular.extend(service, genericZoomService);
		angular.extend(service, genericTypeaheadService);
		return service;
	}

			var _self = this;
			this.afterSave = function (status, obj) {
				if (status == 'ok') {
					if (_self.relatedAction == 'edit') {
						var index = serviceHelper.findIndexByKeyValue(listCtrl.listResult, 'id', obj.id);
						if (index != -1) {
							listCtrl.listResult[index] = obj;
						}
					} else {
						listCtrl.listResult.unshift(obj);
						listCtrl.totalRecords++;
					}
				}
			};


			var params = {
				model: mapping,
				action: this.relatedAction
			};
			var strContext = $location.url().split('/')[1];
			modalService.init(params, this.afterSave, _self, '/' + strContext + '/html/mapping/mapping.edit.html', 'totvs-pnk.mapping.EditCtrl');

<!-- Código a ser inserido no HTML da Modal -->
	<modalfooter>
		<button class="btn btn-primary" data-ng-click="controller.save(controller.myParams.action, controller.myParams.model);">
			{{'btn-save' | i18n}}
		</button>
		<button class="btn btn-default" data-ng-click="controller.cancel();">
			{{'btn-cancel' | i18n}}
		</button>
	</modalfooter>


<!-- Código a ser inserido no Controller da Modal -->
		this.myParams = angular.copy(modalParams);
		this.cancel = function () {
			$modalInstance.dismiss('cancel');
		};
		this.save = function (action, model) {
			var canSave = serviceHelper.validateForm(this.formScope.mappingForm);
			if (canSave) {
				if (action == 'clone') {
					mappingResource.cloneMapping(model, function (result) {
						$modalInstance.close(result);
					});
				} else if (action == 'edit') {
					mappingResource.updateRecord(model.id, model, function (result) {
						$modalInstance.close(result);
					});
				} else {
					model.published = false;
					mappingResource.saveRecord(model, function (result) {
						$modalInstance.close(result);
					});
				}
			}
		};