analytics/webcontent/bi/js/schedule/app/appControler.js

/*
 * Licensed Materials - Property of IBM
 * 
 * IBM Cognos Products: SHARE
 * 
 * (C) Copyright IBM Corp. 2015, 2016
 * 
 * US Government Users Restricted Rights - Use, duplication or disclosure
 * restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define([
        "jquery", 
        "q",
    	'bi/sharecommon/utils/translator'
], function($, Q, t) {
    var controler = {};

    controler.SUBSCRIPTION_SLIDEOUT_PANE_WIDTH = '400px';

    /* Controller functions for User Credentials/UPS */
    /**
     * @param glassContext required; the glass context the view has
     * @param data optional; parameters from the user to create credentials from
     */
    controler.createUserCredential = function(glassContext, data) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.createUserCredential(glassContext, data).then(function() {
                deferred.resolve();
            }, function(errorObj) {
                deferred.reject(errorObj);
            });
        });
        return deferred.promise;
    };

    /**
     * @param glassContext required; the glass context the view has
     */
    controler.getUserCredential = function(glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.getUserCredential(glassContext).then(function() {
                deferred.resolve();
            }, function() {
                deferred.reject();
            });
        });
        return deferred.promise;
    };

    /* Controller functions for SCHEDULES */
    /**
     * @param scheduleDesc The details needed to construct a schedule
     */
    controler.createSchedule = function(scheduleDesc, glassContext) {
        var deferred = Q.defer();

        require(["bi/schedule/service/service"], function(service) {
            service.createOrUpdateSchedule(scheduleDesc, glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
            	deferred.reject(err);
            });
        });
        return deferred.promise;
    };
    
    controler.updateSchedule = function(descriptor, glassContext) {
    	var deferred = Q.defer();

        require(["bi/schedule/service/service"], function(service) {
            service.createOrUpdateSchedule(descriptor, glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
            	deferred.reject();
            });
        });
        return deferred.promise;
    };
    
    controler.deleteSchedule = function(descriptor, glassContext) {
    	var deferred = Q.defer();

        require(["bi/schedule/service/service"], function(service) {
            service.deleteSchedule(descriptor, glassContext).then(function(result) {
                deferred.resolve();
            }).fail(function(err) {
            	deferred.reject();
            });
        });
        return deferred.promise;
    };

    controler.getSchedule = function(reportId, glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.getSchedule(reportId, glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject(err);
            });
        });
        return deferred.promise;
    };


	controler.getRawSchedule = function(scheduleId, glassContext) {
		var deferred = Q.defer();
		require(['bi/schedule/service/service'], function(service) {
			service.readRawSchedule(scheduleId, glassContext).then(function(result) {
				return deferred.resolve(result);
			}.bind(this)).fail(function(err) {
				return deferred.reject(err);
			});
		});
		return deferred.promise;
	};

	controler.updateSaveToCloudOptions = function(scheduleId, saveToCloudOptions, glassContext) {
		if (scheduleId && saveToCloudOptions) {
			var deferred = Q.defer();
			require(['bi/schedule/service/service'], function(service) {
				controler.getRawSchedule(scheduleId, glassContext).then(function(result) {
					return service.updateScheduleCloudOptions(result.data[0], saveToCloudOptions, glassContext);
				}).then(function(result) {
					return deferred.resolve(result);
				}.bind(this)).fail(function(err) {
					return deferred.reject(err);
				});
			});
			return deferred.promise;
		} else {
			return Promise.resolve();
		}	
	};



    controler.getSingleSchedule = function(scheduleDesc, glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.getSingleSchedule(scheduleDesc, glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {});

        });
        return deferred.promise;
    };


    /* Controller functions for SUBSCRIPTIONS */
    /**
     * Construct and show the subscription pane (slides out from the right)
     */
    controler.showSubscriptionPane = function(glassContext, descriptor, launchPoint, callback) {
        var deferred = Q.defer();
        var content = {
            'module': 'bi/schedule/views/SubscriptionView',
            'glassContext': glassContext,
            'descriptor': descriptor
        };

        if(callback !== undefined) {
            content.callback = callback;
        }

        glassContext.appController.showSlideOut({
            'position':'right',
            'content': content,
            'width': controler.SUBSCRIPTION_SLIDEOUT_PANE_WIDTH,
			'enableTabLooping': true,
			'label': t.translate('subscription_header_region'),
			'launchPoint': launchPoint
        });
        return deferred.promise;
    };

    /**
     * Construct and show the subscription management view
     */
    controler.showSubscriptionManagementPane = function(glassContext) {
        var deferred = Q.defer();
        var context = {
            id: "subscribe_mgmt",
            content: {}
        };
        glassContext.appController.openAppView('subscribe_mgmt', context);
        deferred.resolve();
        return deferred.promise;
    };

    /**
     * Create a subscription with the passed in data
     * 
     * @param subscriptionDesc The details of the subscription
     */
    controler.createSubscription = function(subscriptionDesc, glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.createSubscription(subscriptionDesc, glassContext).then(function(result) {
                deferred.resolve();
            }).fail(function(err) {
                deferred.reject();
            });
        });
        return deferred.promise;
    };

    /**
     * Update a subscription
     * 
     * @param descriptor The updated subscription information to use
     */
    controler.updateSubscription = function(descriptor, glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.updateSubscription(descriptor, glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject();
            });
        });
        return deferred.promise;
    };

    /**
     * Fetch a list of subscriptions from the server
     */
    controler.getSubscriptions = function(glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.getSubscriptions(glassContext).then(function(result) {
            	deferred.resolve(result);
            }).fail(function(err) {
            	deferred.reject(err);
            });
        });
        
        return deferred.promise;
    };

    controler.deleteSubscription = function(subscriptionId, glassContext) {
    	var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.deleteSubscription(subscriptionId, glassContext).then(function(result) {
            	deferred.resolve(result);
            }).fail(function(err) {
            	deferred.reject(err);
            });
        });
        
        return deferred.promise;
    };
    
    /**
     * Get information about a single subscription via its subscription Id
     * @param subscriptionId The subscription Id to use to get subscription information 
     */
    controler.getSubscriptionDetails = function(subscriptionId, glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.getSubscriptionDetails(subscriptionId, glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject(err);
            });
        });
        return deferred.promise;
    };

    /**
     * Get view run history about a single subscription via its subscription Id
     * @param {String} subscriptionId - The subscription Id to use to get run history information
     * @param {Object} glassContext - The glass context object
     */
    controler.getSubscriptionRunHistory = function(subscriptionId, glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.getObjectProperties(subscriptionId, glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject(err);
            });
        });
        return deferred.promise;
    };

    /**
     * Construct and show the versions pane (slides out from the right)
     */
    controler.showVersionsPane = function(glassContext, properties, launchPoint) {
        var content = {
            'module': 'bi/content_apps/VersionsView',
            'glassContext': glassContext,
            'objectInformation': properties.data[0]
        };

        glassContext.appController.showSlideOut({
            'position':'right',
            'content': content,
            'width': '350px',
            'enableTabLooping': true,
            'label': t.translate('schedule_subscription_version_aria_label'),
            'launchPoint': launchPoint
        });
    };

    /**
     * Get printers for the logged in user
     */
    controler.getPrinters = function(glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.getPrinters(glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject(err);
            });
        });
        return deferred.promise;
    };

    /**
     * Get archive locations for output to file systems
     */
    controler.getArchiveLocations = function(glassContext) {
        var deferred = Q.defer();
        require(["bi/schedule/service/service"], function(service) {
            service.getArchiveLocations(glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject(err);
            });
        });
        return deferred.promise;
	};
	
	controler.getS3ConnectionDetails = function(glassContext) {
		var deferred = Q.defer();
		require(["bi/schedule/service/service"], function(service) {
            service.getS3ConnectionDetails(glassContext).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject(err);
            });
        });
		return deferred.promise;
	};

	controler.getS3LocationsDetails = function(glassContext, id) {
		var deferred = Q.defer();
		require(["bi/schedule/service/service"], function(service) {
            service.getS3LocationsDetails(glassContext, id).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject(err);
            });
        });
		return deferred.promise;
	};

	controler.getS3LocationParentConnectionID = function(glassContext, id) {
		var deferred = Q.defer();
		require(["bi/schedule/service/service"], function(service) {
            service.getS3LocationParentConnectionID(glassContext, id).then(function(result) {
                deferred.resolve(result);
            }).fail(function(err) {
                deferred.reject(err);
            });
        });
		return deferred.promise;
	};

    return controler;
});