angular.module('app.yangman').controller('RequestsListCtrl', RequestsListCtrl);
RequestsListCtrl.$inject = [
- '$filter', '$mdDialog', '$scope', 'HandleFileService', 'PathUtilsService', 'RequestsService', 'YangmanService',
+ '$filter', '$mdDialog', '$scope', 'YMHandleFileService', 'PathUtilsService', 'RequestsService', 'YangmanService',
+ 'YangmanDesignService', 'constants',
];
- function RequestsListCtrl($filter, $mdDialog, $scope, HandleFileService, PathUtilsService, RequestsService,
- YangmanService) {
+ /**
+ * Controller for requests lists, means History requests and Collections requests
+ * @param $filter
+ * @param $mdDialog
+ * @param $scope
+ * @param YMHandleFileService
+ * @param PathUtilsService
+ * @param RequestsService
+ * @param YangmanService
+ * @param YangmanDesignService
+ * @constructor
+ */
+ function RequestsListCtrl($filter, $mdDialog, $scope, YMHandleFileService, PathUtilsService, RequestsService,
+ YangmanService, YangmanDesignService, constants) {
var vm = this;
- vm.collectionList = RequestsService.createEmptyCollectionList('yangman_collectionsList');
- vm.collectionsSortAsc = true;
+ /**
+ * List of all collections containing requests, loads even for history controller to use collection names
+ * in saving requests dialog
+ * @type {*|CollectionList}
+ */
+ vm.collectionList = null;
+ vm.constants = constants;
+
+ /**
+ *
+ * @type {*|HistoryList}
+ */
+ vm.requestList = null;
vm.mainList = null;
- vm.requestList = RequestsService.createEmptyHistoryList('yangman_requestsList');
+ vm.collectionsSortAsc = true;
vm.search = '';
+ // methods
+ vm.clearCollectionList = clearCollectionList;
vm.clearFilter = clearFilter;
vm.clearHistoryList = clearHistoryList;
- vm.clearCollectionList = clearCollectionList;
vm.colMatchingReqsCount = colMatchingReqsCount;
- vm.deselectAllRequests = deselectAllRequests;
+ vm.deselectAllFilteredRequests = deselectAllFilteredReqs;
vm.downloadCollection = downloadCollection;
vm.executeRequest = executeRequest;
vm.fakeFilter = fakeFilter;
vm.filterColName = filterColName;
vm.filterReq = filterReq;
vm.init = init;
- vm.loadRequests = loadRequests;
vm.readCollectionFromFile = readCollectionFromFile;
- vm.selectAllRequests = selectAllRequests;
+ vm.selectAllFilteredRequests = selectAllFilteredReqs;
vm.selectRequest = selectRequest;
vm.showData = showData;
vm.showDgDeleteCollection = showDgDeleteCollection;
vm.showDgDeleteRequests = showDgDeleteRequests;
vm.showDgEditCollection = showDgEditCollection;
vm.showDgSaveReq = showDgSaveReq;
- vm.toggleCollectionsSort = toggleCollectionsSort;
vm.showForm = showForm;
-
- $scope.$on('YANGMAN_REFRESH_COLLECTIONS', loadCollectionRequest);
- $scope.$on('YANGMAN_REFRESH_HISTORY', loadHistoryRequests);
-
- loadRequests();
+ vm.toggleCollectionsSort = toggleCollectionsSort;
+ vm.selectOnlyThisRequest = selectOnlyThisRequest;
+ vm.deselectAllRequests = deselectAllRequests;
+ vm.filterCollReq = filterCollReq;
/**
* Save request obje to collection from other controller
/**
* Clear history requests list and save to storage
*/
- function clearHistoryList(ev) {
+ function clearHistoryList(event) {
+
+ YangmanDesignService.disableMdMenuItem(event);
+
var confirm = $mdDialog.confirm()
.title($filter('translate')('YANGMAN_DELETE_HISTORY_CONFIRM_TITLE'))
.textContent($filter('translate')('YANGMAN_DELETE_HISTORY_CONFIRM_TEXT'))
.ariaLabel($filter('translate')('YANGMAN_DELETE_HISTORY_CONFIRM_TITLE'))
- .targetEvent(ev)
+ .targetEvent(event)
.ok($filter('translate')('YANGMAN_OK'))
.cancel($filter('translate')('YANGMAN_CANCEL'));
$mdDialog.show(confirm).then(function (){
vm.requestList.clear();
vm.requestList.saveToStorage();
- $scope.rootBroadcast('YANGMAN_REFRESH_HISTORY', loadHistoryRequests);
+ loadHistoryList();
+ YangmanDesignService.enableMdMenuItem(event);
+ }, function (){
+ YangmanDesignService.enableMdMenuItem(event);
});
}
/**
* Clear collections requests list and save to storage
*/
- function clearCollectionList(ev) {
+ function clearCollectionList(event) {
var confirm = $mdDialog.confirm()
.title($filter('translate')('YANGMAN_DELETE_COLLECTION_CONFIRM_TITLE'))
.textContent($filter('translate')('YANGMAN_DELETE_COLLECTION_CONFIRM_TEXT'))
.ariaLabel($filter('translate')('YANGMAN_DELETE_COLLECTION_CONFIRM_TITLE'))
- .targetEvent(ev)
+ .targetEvent(event)
.ok($filter('translate')('YANGMAN_OK'))
.cancel($filter('translate')('YANGMAN_CANCEL'));
+ YangmanDesignService.disableMdMenuItem(event);
+
$mdDialog.show(confirm).then(function (){
vm.collectionList.clear();
vm.collectionList.saveToStorage();
- $scope.rootBroadcast('YANGMAN_REFRESH_COLLECTIONS', loadCollectionRequest);
+ $scope.rootBroadcast(constants.YANGMAN_REFRESH_COLLECTIONS);
+ YangmanDesignService.enableMdMenuItem(event);
+ }, function () {
+ YangmanDesignService.enableMdMenuItem(event);
});
}
* @param params
*/
function saveBcstedHistoryRequest(broadcastEvent, params) {
- vm.requestList.addRequestToList(params.params);
- vm.requestList.groupListByDate();
+ vm.requestList.addItemToList(params.params);
vm.requestList.saveToStorage();
- loadHistoryRequests();
+ loadHistoryList();
+ (params.cbk || angular.noop)();
}
/**
* Clear value of input file used to import collection
+ * todo: move to design utils
*/
function clearFileInputValue(){
angular.element(document).find('#importCollection').val('');
* @param $fileContent
*/
function readCollectionFromFile($fileContent) {
- var data = $fileContent,
- checkArray = [
- 'sentData',
- 'receivedData',
- 'path',
- 'collection',
- 'method',
- 'status',
- 'name',
- ];
-
- if (data && YangmanService.validateFile(data, checkArray)){
+ var data = $fileContent;
+
+ if (data && YangmanService.validateFile(data, constants.COLLECTION_CHECK_ARRAY)){
try {
vm.collectionList.loadListFromFile(data);
vm.collectionList.saveToStorage();
+ $scope.rootBroadcast(constants.YANGMAN_REFRESH_COLLECTIONS);
clearFileInputValue();
}
catch (e) {
else {
clearFileInputValue();
}
+ removeButtonBackground();
+
+ function removeButtonBackground() {
+ $('#importCollection').next().css({ 'background': 'transparent' });
+ }
}
function toggleCollectionsSort() {
*/
function downloadCollection(collection) {
- var cListJSON = vm.collectionList.getCollectionInJSON(collection.name);
+ var cListJSON = vm.collectionList.getCollectionInRawJSON(collection.name);
- HandleFileService.downloadFile(collection.name + '.json', cListJSON, 'json', 'charset=utf-8',
+ YMHandleFileService.downloadFile(collection.name + '.json', cListJSON, 'json', 'charset=utf-8',
function (){},
function (e){
console.error('ExportCollection error:', e);
* @param reqObj
*/
function showForm(reqObj) {
- var data = reqObj.method === 'GET' ? reqObj.receivedData : reqObj.sentData;
+ var data = reqObj.sentData;
+
+ // exception for get meth
+ if ( reqObj.method === constants.OPERATION_GET ) {
+ data = reqObj.receivedData;
+ }
+
+ $scope.rootBroadcast(
+ constants.YANGMAN_SET_CODEMIRROR_DATA_RECEIVED, { data: reqObj.setDataForView(reqObj.receivedData) }
+ );
+ $scope.rootBroadcast(
+ constants.YANGMAN_SET_CODEMIRROR_DATA_SENT, { data: reqObj.setDataForView(reqObj.sentData) }
+ );
+
+ $scope.rootBroadcast(constants.YANGMAN_SET_ERROR_DATA,
+ reqObj.receivedData && reqObj.receivedData.hasOwnProperty('errors') ? reqObj.receivedData : {});
- $scope.rootBroadcast('YANGMAN_FILL_NODE_FROM_REQ', { requestUrl: reqObj.path, requestData: data },
+ $scope.rootBroadcast(constants.YANGMAN_FILL_NODE_FROM_REQ, { requestUrl: reqObj.path, requestData: data },
function (){
- $scope.setRightPanelSection('form');
- $scope.rootBroadcast('YANGMAN_HEADER_INIT', { path: reqObj.path, method: reqObj.method });
+ $scope.setRightPanelSection(constants.DISPLAY_TYPE_FORM);
+ $scope.rootBroadcast(constants.YANGMAN_HEADER_INIT, {
+ path: reqObj.path,
+ method: reqObj.method,
+ statusObj: {
+ status: reqObj.responseStatus,
+ statusText: reqObj.responseStatusText,
+ time: reqObj.responseTime,
+ },
+ });
if ( $scope.node ) {
+ // prepare data for filling form
+ data = $scope.node.type === constants.NODE_RPC ?
+ YangmanService.prepareReceivedData(
+ $scope.node,
+ reqObj.method,
+ reqObj.receivedData,
+ reqObj.sentData,
+ constants.DISPLAY_TYPE_FORM
+ ) : data;
+
// try to fill node
YangmanService.fillNodeFromResponse($scope.node, data);
$scope.node.expanded = true;
* @param reqObj
*/
function executeRequest(reqObj) {
- $scope.rootBroadcast(
- 'YANGMAN_HEADER_INIT',
- { path: reqObj.path, method: reqObj.method },
- function (){
- $scope.rootBroadcast(
- 'YANGMAN_EXECUTE_WITH_DATA',
- { data: reqObj.sentData },
- function (historyReq){
- showData(historyReq);
- }
- );
- }
- );
-
+ showData(reqObj);
+ $scope.rootBroadcast(constants.YANGMAN_EXECUTE_WITH_DATA,{ data: reqObj.sentData });
}
-
/**
- * Show current reqObj json data in right panel section
+ * Method for setup data into CM, Header, find api, subapi, node
* @param reqObj
- * @param dataType
+ * @param status
*/
- function showData(reqObj) {
+ function showData(reqObj, select){
+ var headerObj = {
+ path: reqObj.path,
+ method: reqObj.method,
+ };
+
+ // action select request
+ if ( select ) {
+ headerObj.statusObj = {
+ status: reqObj.responseStatus,
+ statusText: reqObj.responseStatusText,
+ time: reqObj.responseTime,
+ };
+
+ $scope.rootBroadcast(
+ constants.YANGMAN_SET_ERROR_DATA,
+ reqObj.receivedData && reqObj.receivedData.hasOwnProperty('errors') ? reqObj.receivedData : {}
+ );
+ }
- $scope.setRightPanelSection('req-data');
- $scope.setJsonView(true, reqObj.method !== 'GET');
+ $scope.setRightPanelSection(constants.DISPLAY_TYPE_REQ_DATA);
+ $scope.setJsonView(true, reqObj.method !== constants.OPERATION_GET);
- $scope.rootBroadcast('YANGMAN_HEADER_INIT', { path: reqObj.path, method: reqObj.method });
+ $scope.rootBroadcast(constants.YANGMAN_HEADER_INIT, headerObj);
+ $scope.rootBroadcast(constants.YANGMAN_FILL_NODE_FROM_REQ, { requestUrl: reqObj.path });
$scope.rootBroadcast(
- 'YANGMAN_SET_CODEMIRROR_DATA_SENT',
- { data: reqObj.setDataForView(reqObj.sentData) }
- );
- $scope.rootBroadcast(
- 'YANGMAN_SET_CODEMIRROR_DATA_RECEIVED',
+ constants.YANGMAN_SET_CODEMIRROR_DATA_RECEIVED,
{ data: reqObj.setDataForView(reqObj.receivedData) }
);
- var data = reqObj.method === 'GET' ? reqObj.receivedData : reqObj.sentData;
-
- $scope.rootBroadcast('YANGMAN_FILL_NODE_FROM_REQ', { requestUrl: reqObj.path, leftpanel: 0},
- function (){
- if ( $scope.node ) {
- // try to fill node
- YangmanService.fillNodeFromResponse($scope.node, data);
- $scope.node.expanded = true;
- }
-
- }
+ $scope.rootBroadcast(
+ constants.YANGMAN_SET_CODEMIRROR_DATA_SENT,
+ { data: reqObj.setDataForView(reqObj.sentData) }
);
}
/**
* Dialog for deleting either selected requests or reqObj
*
- * @param ev
+ * @param event
* @param reqObj
*/
- function showDgDeleteRequests(ev, reqObj){
+ function showDgDeleteRequests(event, reqObj){
+
var confirm = $mdDialog.confirm()
.title($filter('translate')('YANGMAN_DELETE_REQ_CONFIRM_TITLE'))
.textContent($filter('translate')('YANGMAN_DELETE_REQ_CONFIRM_TEXT'))
.ariaLabel($filter('translate')('YANGMAN_DELETE_REQ_CONFIRM_TITLE'))
- .targetEvent(ev)
+ .targetEvent(event)
.ok($filter('translate')('YANGMAN_OK'))
.cancel($filter('translate')('YANGMAN_CANCEL'));
+ YangmanDesignService.disableMdMenuItem(event);
+
$mdDialog.show(confirm).then(function (){
if (reqObj){
vm.mainList.deleteRequestItem(reqObj);
}
else {
- vm.mainList.selectedRequests.forEach(function (elem){
+ vm.mainList.getSelectedItems(
+ vm.mainList === vm.collectionList ? filterCollReq : filterReq
+ ).forEach(function (elem){
vm.mainList.deleteRequestItem(elem);
});
}
vm.mainList.saveToStorage();
- $scope.rootBroadcast('YANGMAN_REFRESH_HISTORY');
+
+ if (vm.mainList === vm.requestList) {
+ loadHistoryList();
+ }
+ else {
+ refreshCollectionsWithExpansion();
+ }
+ }, function (){
+ YangmanDesignService.enableMdMenuItem(event);
});
}
/**
- * Dialog for delete collection
+ * Dialog for deleting collection and refreshing collections
* @param ev
* @param collObj
*/
.ok($filter('translate')('YANGMAN_OK'))
.cancel($filter('translate')('YANGMAN_CANCEL'));
+ YangmanDesignService.disableMdMenuItem(ev);
+
$mdDialog.show(confirm).then(function (){
- ev.stopPropagation();
vm.collectionList.deleteCollection(collObj);
vm.collectionList.saveToStorage();
- $scope.broadcastFromRoot('YANGMAN_REFRESH_COLLECTIONS');
+ refreshCollectionsWithExpansion();
+ }, function (){
+ YangmanDesignService.enableMdMenuItem(ev);
});
}
* @returns {boolean}
*/
function filterReq(reqObj){
- return reqObj.path.indexOf(vm.search) !== -1;
+ var searchPhrase = vm.search.toLocaleLowerCase();
+ return reqObj.path.toLowerCase().indexOf(searchPhrase) > -1 ||
+ reqObj.collection.toLowerCase().indexOf(searchPhrase) > -1 ||
+ reqObj.method.toLowerCase() === searchPhrase;
}
/**
* @returns {boolean}
*/
function filterColName(colObj){
- return colObj.name.indexOf(vm.search) !== -1;
+ return colObj.name.toLowerCase().indexOf(vm.search.toLowerCase()) > -1;
}
/**
return true;
}
+
/**
* Show dialog for saving reqObj to collection (used for duplicate req too)
* @param ev
targetEvent: ev,
clickOutsideToClose: true,
locals: {
- requests: reqObj ? [reqObj] : vm.requestList.selectedRequests,
+ requests: reqObj ? [reqObj] : vm.mainList.getSelectedItems(
+ vm.mainList === vm.collectionList ? filterCollReq : filterReq
+ ),
collectionNames: vm.collectionList.getCollectionNames(),
duplicate: duplicate || false,
},
*/
function saveRequests(requests){
requests.forEach(function (reqObj){
- vm.collectionList.addRequestToList(reqObj);
+ vm.collectionList.addItemToList(RequestsService.clearUnnecessaryProperties(reqObj.clone()));
vm.collectionList.saveToStorage();
- $scope.broadcastFromRoot('YANGMAN_REFRESH_COLLECTIONS');
+ refreshCollectionsWithExpansion();
});
}
function changeCollectionName(names){
vm.collectionList.renameCollection(names[0], names[1]);
vm.collectionList.saveToStorage();
- $scope.broadcastFromRoot('YANGMAN_REFRESH_COLLECTIONS');
+ refreshCollectionsWithExpansion();
}
/**
- * Create collection duplicate and save
+ * Create collection duplicate, save and refresh collections
* @param {array} names 0. element is old name, 1. element is new name
*/
function duplicateCollection(names){
vm.collectionList.duplicateCollection(names[0], names[1]);
vm.collectionList.saveToStorage();
- $scope.broadcastFromRoot('YANGMAN_REFRESH_COLLECTIONS');
+ refreshCollectionsWithExpansion();
}
+ function selectNewestRequest() {
+ vm.mainList.toggleReqSelection(true, vm.mainList.getNewestRequest());
+ }
+
+ function loadCollectionsList() {
+ vm.collectionList.loadListFromStorage();
+ }
+
+ function loadHistoryList() {
+ vm.requestList.loadListFromStorage();
+ }
/**
*
- * @param list collectionList or requestList object
+ * @param mainList collectionList or requestList object
*/
- function init(list){
- vm.mainList = list;
+ function init(mainList){
+
+ vm.collectionList = RequestsService.createEmptyCollectionList('yangman_collectionsList');
+ // collections are loaded for both history and collections tab
+ loadCollectionsList();
+
+ vm.requestList = RequestsService.createEmptyHistoryList('yangman_requestsList');
+
+
+ // if request was selected, deselect requests in all other instances of RequestsListCtrl
+ $scope.$on(constants.YANGMAN_DESELECT_REQUESTS, function (event, params) {
+ if (params.params.broadcastingCtrl !== vm) {
+ deselectAllRequests();
+ }
+ });
+
+ $scope.$on(constants.YANGMAN_REFRESH_COLLECTIONS, function (event, params){
+ loadCollectionsList();
+ (params.cbk || angular.noop)();
+ });
- if (list === vm.requestList){
+ // list type dependend operations
+ if (mainList === 'history') {
+
+ vm.mainList = vm.requestList;
+ loadHistoryList();
+
+ $scope.$on(constants.YANGMAN_REFRESH_HISTORY, loadHistoryList);
// saving from request header after execution
- $scope.$on('YANGMAN_SAVE_EXECUTED_REQUEST', saveBcstedHistoryRequest);
+ $scope.$on(constants.YANGMAN_SAVE_EXECUTED_REQUEST, saveBcstedHistoryRequest);
+ // select newest request
+ $scope.$on(constants.YANGMAN_SELECT_THE_NEWEST_REQUEST, selectNewestRequest);
+ }
+ else {
+ vm.mainList = vm.collectionList;
// saving from request header
- $scope.$on('YANGMAN_SAVE_REQUEST_TO_COLLECTION', saveRequestFromExt);
+ $scope.$on(constants.YANGMAN_SAVE_REQUEST_TO_COLLECTION, saveRequestFromExt);
+ // saving collections expanded status on refresh
+ $scope.$on(constants.YANGMAN_REFRESH_AND_EXPAND_COLLECTIONS, function(){
+ var expandedColNames = vm.collectionList.getExpandedCollectionNames();
+ $scope.rootBroadcast(constants.YANGMAN_REFRESH_COLLECTIONS, {}, function (){
+ vm.collectionList.expandCollectionByNames(expandedColNames);
+ });
+ });
}
}
+
/**
- * Loading history request and grouping by date
+ * Request in list selection
+ * For history reqs it is possible multiselect, thats why event.ctrlKey is used
+ * @param event
+ * @param requestObj
*/
- function loadHistoryRequests(){
- vm.requestList.loadListFromStorage();
- vm.requestList.groupListByDate();
+ function selectRequest(event, requestObj){
+ $scope.rootBroadcast(constants.YANGMAN_DESELECT_REQUESTS, { broadcastingCtrl: vm });
+ vm.mainList.toggleReqSelection(!event.ctrlKey, requestObj);
+ if (!event.ctrlKey){
+ if ($scope.rightPanelSection === constants.DISPLAY_TYPE_FORM) {
+ vm.showForm(requestObj, true);
+ }
+ else {
+ vm.showData(requestObj, true);
+ }
+ }
}
/**
- * Loading collections
+ * Mark only requestObj in current list as selected
+ * Used for example when user clicks on request submenu
+ * @param requestObj
*/
- function loadCollectionRequest(){
- vm.collectionList.loadListFromStorage();
+ function selectOnlyThisRequest(requestObj){
+ vm.mainList.toggleReqSelection(true, requestObj);
}
/**
- * Loading both history and collections reqs
+ * Deselect history requests
*/
- function loadRequests(){
- loadHistoryRequests();
- loadCollectionRequest();
+ function deselectAllFilteredReqs(){
+ vm.mainList.deselectAllFilteredItems(vm.mainList === vm.collectionList ? filterCollReq : vm.filterReq);
+ }
+
+ function deselectAllRequests() {
+ vm.mainList.deselectAllItems();
}
/**
- * Request in list selection
- * For history reqs it is possible multiselect, thats why event.ctrlKey is used
- * @param event
- * @param requestObj
+ * Select history requests
*/
- function selectRequest(event, requestObj){
- vm.mainList.toggleReqSelection(!event.ctrlKey, requestObj);
- $scope.setHistoryReqsSelected(vm.requestList.selectedRequests.length > 0);
+ function selectAllFilteredReqs(){
+ vm.mainList.selectAllFilteredItems(vm.mainList === vm.collectionList ? filterCollReq : vm.filterReq);
}
/**
- * Deselect history requests
+ * Use when selecting filtered requests if they are saved to some collection
+ * Additional filter is if the collection of the request is expanded
+ * @param request
+ * @returns {*|boolean}
*/
- function deselectAllRequests(){
- vm.mainList.deselectReq();
+ function filterCollReq(request) {
+ return vm.collectionList.getCollection(request.collection).expanded && vm.filterReq(request);
}
/**
- * Select history requests
+ * Refresh and expand collections
*/
- function selectAllRequests(){
- vm.mainList.selectReq(vm.mainList.dateGroups[0].requests);
+ function refreshCollectionsWithExpansion(){
+ $scope.rootBroadcast(constants.YANGMAN_REFRESH_AND_EXPAND_COLLECTIONS);
}
}
Code Review / dlux.git / blobdiff