/* global define */
define(['authAgents/SessionAuthAgent', 'authAgents/HttpBasicAuthAgent', 'ConnectionManager',
'ConnectionFeatureFactory', 'connections/XmlHttpRequestConnection', 'connections/MicrosoftXmlHttpRequestConnection',
'services/DiscoveryService', 'services/ContentService', 'services/ContentTypeService',
'services/UserService', 'utils/extend'],
function (SessionAuthAgent, HttpBasicAuthAgent, ConnectionManager,
ConnectionFeatureFactory, XmlHttpRequestConnection, MicrosoftXmlHttpRequestConnection,
DiscoveryService, ContentService, ContentTypeService,
UserService, extend) {
"use strict";
/**
* Creates an instance of CAPI - main object which handles the API initialization and gives ability to retrieve various services.
* Could be created only in one instance. Handles connections, authorization and REST paths discovery automatically.
*
* @class CAPI
* @constructor
* @param endPointUrl {String} url pointing to REST root
* @param authenticationAgent {Object} Instance of one of the AuthAgents (e.g. SessionAuthAgent, HttpBasicAuthAgent)
* @param [options] {Object} Object containing different options for the CAPI
* @param [options.rootPath='/api/ezp/v2/'] {String} the API root path
* @param [options.logRequests=false] {Boolean} whether to log requests
* @param [options.siteAccess=null] {String|null} siteaccess in which requests should be executed
* @example
* var authAgent = new SessionAuthAgent({
login: "admin",
password: "admin"
}),
jsCAPI = new CAPI(
'http://ez.git.local', authAgent, {
logRequests: true, // Whether we should log each request to the js console or not
rootPath: '/api/ezp/v2/', // Path to the REST root
connectionStack: [ // Array of connections, should be filled-in in preferred order
{connection: XmlHttpRequestConnection},
{connection: MicrosoftXmlHttpRequestConnection}
]
});
*/
var CAPI = function (endPointUrl, authenticationAgent, options) {
var defaultOptions,
mergedOptions,
connectionFactory,
connectionManager,
discoveryService,
contentService,
contentTypeService,
userService;
// Options used if not overwritten from the outside
defaultOptions = {
logRequests: false, // Whether we should log each request to the js console or not
rootPath: '/api/ezp/v2/', // Path to the REST root
connectionStack: [ // Array of connections, should be filled-in in preferred order
{connection: XmlHttpRequestConnection},
{connection: MicrosoftXmlHttpRequestConnection}
],
siteAccess: null
};
authenticationAgent.setCAPI(this);
// Merging provided options (if any) with defaults
mergedOptions = extend({}, defaultOptions, options);
connectionFactory = new ConnectionFeatureFactory(mergedOptions.connectionStack);
connectionManager = new ConnectionManager(endPointUrl, authenticationAgent, connectionFactory, mergedOptions.siteAccess);
connectionManager.logRequests = mergedOptions.logRequests;
discoveryService = new DiscoveryService(mergedOptions.rootPath, connectionManager);
/**
* Checks that the CAPI instance is logged in
*
* @method isLoggedIn
* @param {Function} callback
*/
this.isLoggedIn = function (callback) {
authenticationAgent.isLoggedIn(callback);
};
/**
* Logs in the user
*
* @method logIn
* @param {Object} [credentials]
* @param {String} credentials.login
* @param {String} credentials.password
* @param {Function} callback
*/
this.logIn = function (credentials, callback) {
if ( callback ) {
authenticationAgent.setCredentials(credentials);
} else {
callback = credentials;
}
authenticationAgent.logIn(callback);
};
/**
* Logs out the current user.
*
* @method logOut
* @param {Function} callback
*/
this.logOut = function (callback) {
authenticationAgent.logOut(callback);
};
/**
* Get instance of Content Service. Use ContentService to retrieve information and execute operations related to Content.
*
* @method getContentService
* @return {ContentService}
* @example
* var contentService = jsCAPI.getContentService();
* contentService.loadRoot(
* callback
* );
*/
this.getContentService = function () {
if (!contentService) {
contentService = new ContentService(
connectionManager,
discoveryService,
mergedOptions.rootPath
);
}
return contentService;
};
/**
* Get instance of Content Type Service. Use ContentTypeService to retrieve information and execute operations related to ContentTypes.
*
* @method getContentTypeService
* @return {ContentTypeService}
* @example
* var contentTypeService = jsCAPI.getContentTypeService();
* contentTypeService.loadContentType(
* '/api/ezp/v2/content/types/18',
* callback
* );
*/
this.getContentTypeService = function () {
if (!contentTypeService) {
contentTypeService = new ContentTypeService(
connectionManager,
discoveryService
);
}
return contentTypeService;
};
/**
* Get instance of User Service. Use UserService to retrieve information and execute operations related to Users.
*
* @method getUserService
* @return {UserService}
* @example
* var userService = jsCAPI.getUserService();
* userService.loadRootUserGroup(
* callback
* );
*/
this.getUserService = function () {
if (!userService) {
userService = new UserService(
connectionManager,
discoveryService,
mergedOptions.rootPath
);
}
return userService;
};
/**
* Get instance of Discovery Service. Use DiscoveryService to internally to discover
* resources URI and media type provided in the root resource.
*
* @method getDiscoveryService
* @return {DiscoveryService}
* @example
* var discoveryService = jsCAPI.getDiscoveryService();
* discoveryService.getInfoObject(
* "Trash",
* callback
* );
*/
this.getDiscoveryService = function () {
return discoveryService;
};
/**
* Gets the connection manager
*
* @method getConnectionManager
* @return {ConnectionManager}
* @example
* var connectionManager = jsCAPI.getConnectionManager();
* connectionManager.request(
* "GET",
* "/endpoint",
* "",
* {"Accept": "application/json"},
* callback
* );
*/
this.getConnectionManager = function () {
return connectionManager;
};
};
return CAPI;
});
