Schema Parser
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /** | |
| * @module schemaParser | |
| * @namespace CN | |
| * @description Handles the parsing of JSON from the MPP XML schemas into HTML. | |
| * Allows for custom HTML templates to deliver the full rendered | |
| * markup for a DCT, and also provides methods for accessing the | |
| * data for various DCT elements. | |
| * @requires CN | |
| * @author Eric Shepherd | |
| * @copyright 2008-2010 Conde Nast Digital | |
| * | |
| * @history: 0.8.0 EBS 12.2008 Alpha | |
| * 0.9.0 EBS 02.2009 Beta - added support for memoizing renderedHtml() function with parameters, so the same content can be used with different templates on a page. | |
| * 1.0.0 EBS 09.2009 Might as well make this production, it's been live for 6 months | |
| * 1.1.0 EBS 10.2009 Added methods for date, contributor, expanded headers to allow graphics and URL | |
| * 1.2.0 EBS 02.2010 Added methods for image annotations | |
| * 1.3.0rc1 EBS 03.2010 Added methods for mediaItems | |
| * 1.3.0rc2 EBS 03.2010 Removed need for templates (though no renderedHtml will be available) | |
| * 1.3.0rc3 EBS 03.2010 Changed internal API for annotations to be a template for compatibility with both photo and mediaItems. | |
| * 1.3.0rc4 EBS 04.2010 Added option to pass a content id to the parse() method if the json has already been parsed. | |
| * 1.3.0 EBS 04.2010 Removed if check so that renderedHtml can be stored per template and memoized. | |
| * 1.3.1 EBS 06.2010 Added passthru of templates from site js if it happens to load before this file. | |
| * 1.3.2 EBS 07.2010 Bug fixes, reformatting | |
| * | |
| * @notes In general, the schema parser will not provide methods unless | |
| * there is data for the method. That is, checking the presence | |
| * of rubric method will tell you whether there is a rubric. | |
| * The notable exception is photos, where the url, alt, etc | |
| * methods are always written, and you can check url() to find | |
| * out whether there is actual data, since it will return the | |
| * falsy empty string if no data is entered. | |
| */ | |
| /*global CN, console, window, document, jQuery, setTimeout, clearTimeout, clearInterval, setInterval */ /* for jsLint */ | |
| /** | |
| * Assists with converting JSON from DCTs into HTML for DOM insertion. | |
| * | |
| * @example CN.schemaParser.getInstance().parse(dct).rubric(); | |
| * @example CN.schemaParser.getInstance().parse(dct).photo.main(); | |
| * @example CN.schemaParser.getInstance().parse(dct).photo.main.annotations(); | |
| * @example CN.schemaParser.getInstance().parse(dct).renderedHtml('item'); // where 'item' is the template to use | |
| * | |
| * @class schemaParser | |
| * @singleton | |
| * @param {Object} templates An object of templates to use for rendering (optional) - will be passed through and returned | |
| * @return {Object} A getInstance() method and templates object (or null if param was not passed in) | |
| */ | |
| CN.schemaParser = function(templates) { | |
| var uniqueInstance, | |
| constructor, | |
| methods = {}, | |
| data = {}; | |
| constructor = function() { | |
| return { | |
| /** | |
| * Stores the json data by contentId lookup | |
| * @property data | |
| * @static | |
| */ | |
| data : data, | |
| /** | |
| * Parses a DCT, stores methods for accessing data in a dictionary | |
| * keyed to content ID. Pass either a DCT (json at the article, | |
| * list, or other main content level) or a contentId number for | |
| * looking up an already processed DCT. | |
| * | |
| * @method parse | |
| * @static | |
| * @param {Object|Number} dct A dct in json format, or a content id for a dct previously parsed. | |
| * @return {Object|False} Methods for accessing DCT content or false if dct param is a number but that piece of content hasn't been parsed. | |
| */ | |
| parse : function(dct) { | |
| var dctId = 'i' + ((CN.isNumber(dct)) ? dct : dct.metaData.id); | |
| // Public catalog of content ids for implementation to query | |
| if (!data[dctId]) { | |
| if (CN.isNumber(dct)) { | |
| return false; | |
| } else { | |
| data[dctId] = dct; | |
| methods[dctId] = CN.schemaParser.factory(dct); | |
| } | |
| } else { | |
| return methods[dctId]; | |
| } | |
| // Creates the renderedHtml() method and assigns to this piece of content | |
| methods[dctId].renderedHtml = function(template) { | |
| template = template || 'item'; | |
| if (CN.schemaParser.templates && CN.schemaParser.templates[template]) { | |
| return CN.schemaParser.templates[template](methods[dctId]); | |
| } else { | |
| return 'No renderedHtml template is available for the "' + template + '" template.'; | |
| } | |
| }; | |
| // Memoize for future use | |
| methods[dctId].renderedHtml = methods[dctId].renderedHtml.memoize(); | |
| return methods[dctId]; | |
| } | |
| }; | |
| }; | |
| return { | |
| getInstance : function() { | |
| if (!uniqueInstance) { | |
| uniqueInstance = constructor(); | |
| } | |
| return uniqueInstance; | |
| }, | |
| /** | |
| * Passes through templates if passed in by being created at the site | |
| * level before this file is loaded. Otherwise, the value will be | |
| * null and this will remain null until the implementation overrides | |
| * with its template object. | |
| * @property templates | |
| * @static | |
| */ | |
| templates : templates | |
| }; | |
| }( | |
| // Passing in templates object if it exists (in the case that | |
| // this file lazy loads after the site sets up templates) | |
| (CN.schemaParser && CN.schemaParser.templates) ? | |
| CN.schemaParser.templates : | |
| null | |
| ); | |
| /** | |
| * Generates methods to pass back to the user which will return DCT content. | |
| * This will loop once for each piece of content with an ID. | |
| * It looks at the top level elements in the DCT, and farms out to those | |
| * methods. | |
| * | |
| * @method factory | |
| * @static | |
| * @param {Object} dct A DCT in JSON format to parse (at top level of content, | |
| * such as article_v2, list, item, or video) | |
| * @return {Object} A set of methods for accessing the DCT data | |
| */ | |
| CN.schemaParser.factory = function(dct) { | |
| var methods = {}, | |
| i; | |
| for (i in dct) { | |
| if (CN.schemaParser.schemas.hasOwnProperty(i)) { | |
| methods = CN.schemaParser.schemas[i](dct, methods); | |
| } | |
| } | |
| return methods; | |
| }; | |
| /** | |
| * DCT nodes which are called directly or used by other node methods. | |
| * Each function must return the methods object after adding its own | |
| * methods into that object. | |
| * | |
| * @property schemas | |
| * @static | |
| */ | |
| CN.schemaParser.schemas = { | |
| /** | |
| * Provides a text path to a Teamsite file for internal editing. No longer used. | |
| * @deprecated | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| filePath : function(dct, methods) { | |
| methods.filePath = function() { | |
| return '<a class="editlink" target="_blank" href="http://' + CN.internal.getTeamsiteServer() + '/iw-cc/command/iw.group.ccpro.edit?vpath=' + dct.filePath.replace(/\/home/, '//' + CN.internal.getTeamsiteServer()).replace(/iwmnt-/, '') + '">Edit in TeamSite</a>'; | |
| }; | |
| return methods; | |
| }, | |
| /** | |
| * Provides text for metaData information | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| metaData : function(dct, methods) { | |
| methods.pageType = function() { | |
| return dct.metaData.pageType; | |
| }; | |
| methods.metaDataItems = function() { | |
| var results = [], | |
| mediaItems = dct.metaData.properties && dct.metaData.properties.property ? dct.metaData.properties.property : []; | |
| if (Object.prototype.toString.call(mediaItems) === '[object Array]') { | |
| for (var ind = 0; ind < mediaItems.length; ind++) { | |
| results[ind] = mediaItems[ind]; | |
| } | |
| } else { | |
| results[0] = mediaItems; | |
| } | |
| return results; | |
| }; | |
| return methods; | |
| }, | |
| /** | |
| * Delegates to other methods for unitMetaData information | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| unitMetaData : function(dct, methods) { | |
| if (dct.unitMetaData.rubric) { | |
| methods = this.rubric(dct.unitMetaData, methods); | |
| } | |
| if (dct.unitMetaData.byline) { | |
| methods = this.byline(dct.unitMetaData, methods); | |
| } | |
| if (dct.unitMetaData.displayDate) { | |
| methods = this.displayDate(dct.unitMetaData, methods); | |
| } | |
| return methods; | |
| }, | |
| /** | |
| * Provides html text for header information | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| header : function(dct, methods) { | |
| if (dct.header) { | |
| var ret = '', | |
| alt = '', | |
| img = ''; | |
| if (dct.header.graphic) { | |
| alt = dct.header.graphic.altText || ''; | |
| img = '<img src="' + dct.header.graphic.image + '" alt="' + alt + '" />'; | |
| if (dct.header.graphic.URL) { | |
| ret = '<a href="' + dct.header.graphic.URL + '">' + img + '</a>'; | |
| } else { | |
| ret = img; | |
| } | |
| } else { | |
| if (dct.header.html.URL) { | |
| ret += '<a href="' + dct.header.html.URL + '">' + dct.header.html.text + '</a>'; | |
| } else { | |
| ret += dct.header.html.text; | |
| } | |
| } | |
| methods.header = function() { return ret; }; | |
| } | |
| return methods; | |
| }, | |
| /** | |
| * Provides html text for subheader information | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| subHeaders : function(dct, methods) { | |
| methods.subHeaders = function() { | |
| var i, | |
| subheaders=[]; | |
| if(dct.subHeaders && jQuery.isArray(dct.subHeaders.subHeader)) { | |
| for(i=0;i<dct.subHeaders.subHeader.length;i++) { | |
| subheaders.push(dct.subHeaders.subHeader[i].html.text); | |
| } | |
| } else { | |
| subheaders.push((dct.subHeaders.subHeader.html) ? dct.subHeaders.subHeader.html.text : ''); | |
| } | |
| return subheaders; | |
| }; | |
| return methods; | |
| }, | |
| /** | |
| * The body can contain many types of things. If it's a photo, we | |
| * delegate to photo method. If it's a list, we delegate to the | |
| * embedded list method. Otherwise, provides html text. | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| body : function(dct, methods) { | |
| var body = ''; | |
| if (dct.body.lead || dct.body.introduction) { | |
| body += '<div class="lead-introduction">'; | |
| } | |
| body += dct.body.lead ? '<div class="lead">' + dct.body.lead + '</div> ' : ''; | |
| body += dct.body.introduction ? dct.body.introduction + ' ' : ''; | |
| if (dct.body.lead || dct.body.introduction) { | |
| body += '</div>'; | |
| } | |
| body += dct.body.text ? '<div class="text">' + dct.body.text + '</div>' : ''; | |
| methods.body = function() { return body; }; | |
| methods.bodyText = function() { return dct.body.text; }; | |
| methods.bodyLead = function() { return dct.body.lead; }; | |
| methods.bodyIntroduction = function() { return dct.body.introduction; }; | |
| if (dct.body.photo) { | |
| methods = this.photo(dct.body, methods); | |
| } | |
| if (dct.body.embeddedList) { | |
| methods = this.embeddedList(dct.body, methods); | |
| } | |
| if(dct.body.altMedia) { | |
| methods = this.altMedia(dct.body, methods); | |
| } | |
| return methods; | |
| }, | |
| /** | |
| * Provides text for footer information | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| footer : function(dct, methods) { | |
| methods.footerText = function() { return dct.footer.text || ''; }; | |
| methods.footerLegalCopy = function() { return dct.footer.legalCopy || ''; }; | |
| return methods; | |
| }, | |
| /** | |
| * Photos need to be available directly. We create as many methods | |
| * as we have image replicants, and delegate for annotations | |
| * if they exist. | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| photo : function(dct, methods) { | |
| methods.photo = {}; | |
| var i, | |
| il, | |
| images = dct.photo.images.image, | |
| thisImage, | |
| thisSource, | |
| that = this, | |
| templateToUse = CN.schemaParser.templates && CN.schemaParser.templates.annotations ? | |
| CN.schemaParser.templates.annotations : | |
| CN.schemaParser.defaultTemplates.annotations; | |
| if (Object.prototype.toString.call(images) === '[object Array]') { | |
| for (i = 0, il = images.length; i < il; i++) { | |
| (function() { // scope for i | |
| var image = images[i]; | |
| methods.photo[image.type] = function() { | |
| return image.source; | |
| }; | |
| methods.photo[image.type].annotations = function() { | |
| return templateToUse(image); | |
| }; | |
| })(); | |
| } | |
| } else { | |
| methods.photo[images.type] = function() { | |
| return images.source; | |
| }; | |
| methods.photo[images.type].annotations = function() { | |
| return templateToUse(images); | |
| }; | |
| } | |
| methods.photo.alt = function() { return dct.photo.altText; }; | |
| methods.photo.caption = function() { return dct.photo.caption; }; | |
| methods.photo.credit = function() { return dct.photo.credit; }; | |
| methods.photo.url = function() { return dct.photo.URL; }; | |
| return methods; | |
| }, | |
| /** | |
| * This creates a complete object for all mediaItem replicants in a given | |
| * DCT. For now, going to do one big method and possibly refactor later. | |
| * Differs from photo in that the method is mediaItems() rather than adding | |
| * methods for caption(), credit() etc. Those become simply properties on | |
| * the return object from mediaItems(). | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object containing mediaItems | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| mediaItems : function(dct, methods) { | |
| var that = this, | |
| templateToUse = CN.schemaParser.templates && CN.schemaParser.templates.annotations ? | |
| CN.schemaParser.templates.annotations : | |
| CN.schemaParser.defaultTemplates.annotations; | |
| // TODO: memoize some shizz | |
| /* | |
| Returns an array of mediaItem | |
| @param placement {String|null} The placement property to match | |
| @param type {String|null} The mediaItem type to match | |
| @param sequence {Number|String} Which mediaItem to use, or "all" | |
| */ | |
| methods.mediaItems = function(placement, type, sequence) { | |
| placement = placement || null; | |
| type = type || null; | |
| sequence = sequence || 0; | |
| var results = [], | |
| result = null, | |
| mediaItems = dct.mediaItems.mediaItem, | |
| i, il, | |
| j, jl, | |
| props, | |
| formats; | |
| if (Object.prototype.toString.call(mediaItems) === '[object Array]') { | |
| for (i = 0, il = mediaItems.length; i < il; i++) { | |
| results[i] = mediaItems[i]; | |
| } | |
| } else { | |
| results[0] = mediaItems; | |
| } | |
| // Filters results by placement | |
| if (placement !== null) { | |
| results = results.filter(function(res) { | |
| props = res.properties && res.properties.property ? | |
| CN.utils.mapPropertyArray(res.properties.property) : | |
| false; | |
| return props.placement && props.placement === placement ? | |
| true : | |
| false; | |
| }); | |
| } | |
| // Filters results by type | |
| if (type !== null) { | |
| results = results.filter(function(res) { | |
| return res.type === type ? true : false; | |
| }); | |
| } | |
| // If we want "all", set result = results, else filter to | |
| // one result matching the sequence provided | |
| // Either way, result is an array of 1+ or null | |
| result = (sequence === 'all') ? results : ([results[sequence]] || null); | |
| if (result) { | |
| for (i = 0, il = result.length; i < il; i++) { | |
| // Handle formats | |
| if (result[i].formats && result[i].formats.format) { | |
| formats = result[i].formats.format; | |
| if (Object.prototype.toString.call(formats) === '[object Array]') { | |
| for (j = 0, jl = formats.length; j < jl; j++) { | |
| (function() { // scope for i | |
| var format = formats[j]; | |
| result[i][format.name] = function() { | |
| return format.source; | |
| }; | |
| result[i][format.name].annotations = function() { | |
| return templateToUse(format); | |
| }; | |
| })(); | |
| } | |
| } else { | |
| result[i][formats.name] = function() { | |
| return formats.source; | |
| }; | |
| result[i][formats.name].annotations = function() { | |
| return templateToUse(formats); | |
| }; | |
| } | |
| } | |
| result[i].getProperties = function() { | |
| return result.properties && result.properties.property ? | |
| CN.utils.mapPropertyArray(result.properties.property) : | |
| false; | |
| }; | |
| } | |
| } | |
| return result; | |
| }; | |
| return methods; | |
| }, | |
| /** | |
| * Provides html text for rubric information | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json unitMetaData object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| rubric : function(dct, methods) { | |
| if (dct.rubric) { | |
| var ret = '', | |
| alt = '', | |
| img = ''; | |
| if (dct.rubric.graphic) { | |
| alt = dct.rubric.graphic.altText || ''; | |
| img = '<img src="' + dct.rubric.graphic.image + '" alt="' + alt + '" />'; | |
| if (dct.rubric.graphic.URL) { | |
| ret = '<a href="' + dct.rubric.graphic.URL + '">' + img + '</a>'; | |
| } else { | |
| ret = img; | |
| } | |
| } else { | |
| if (dct.rubric.html.URL) { | |
| ret += '<a href="' + dct.rubric.html.URL + '">' + dct.rubric.html.text + '</a>'; | |
| } else { | |
| ret += dct.rubric.html.text; | |
| } | |
| } | |
| methods.rubric = function() { return ret; }; | |
| } | |
| return methods; | |
| }, | |
| /** | |
| * Provides an object for contributor information, rather than | |
| * html text directly. This allows the template for contributors | |
| * to be overridden in the implementation code. | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| byline : function(dct, methods) { | |
| if (dct.byline && dct.byline.contributors) { | |
| var ret = CN.schemaParser.templates && CN.schemaParser.templates.contributors ? | |
| CN.schemaParser.templates.contributors(dct.byline.contributors.contributor) : | |
| CN.schemaParser.defaultTemplates.contributors(dct.byline.contributors.contributor); | |
| methods.contributors = function() { return ret; }; | |
| } | |
| return methods; | |
| }, | |
| /** | |
| * Provides a date string for html insertion. | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| displayDate : function(dct, methods) { | |
| if (dct.displayDate.date) { | |
| methods.displayDate = function() { | |
| var date = new Date(CN.date.isoToDate(CN.date.convertIwDateToIso(dct.displayDate.date))); | |
| return CN.date.format(date, dct.displayDate.format || 'MMMM yyyy'); | |
| }; | |
| } | |
| return methods; | |
| }, | |
| /** | |
| * Provides text for photo credit information. | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| photoCredits : function(dct, methods) { | |
| if (dct.photoCredits) { | |
| methods.photoCredits = function() { return dct.photoCredits; }; | |
| } | |
| return methods; | |
| }, | |
| /** | |
| * Provides text for embedded list information. | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| embeddedList : function(dct, methods) { | |
| if (dct.embeddedList) { | |
| var list = '<ul class="embedded-list">', | |
| listItem, | |
| i, | |
| il; | |
| if (Object.prototype.toString.call(dct.embeddedList.listItem) === '[object Array]') { | |
| for (i = 0, il = dct.embeddedList.listItem.length; i < il; i++) { | |
| (function() { // scope for i | |
| var newItem = '<li>' + dct.embeddedList.listItem[i] + '</li>'; | |
| list += newItem; | |
| })(); | |
| } | |
| } else { | |
| list += '<li>' + dct.embeddedList.listItem + '</li>'; | |
| } | |
| list += '</ul>'; | |
| methods.embeddedList = function() { return list; }; | |
| } | |
| return methods; | |
| }, | |
| /** | |
| * Provides video id for video slides in slideshow. | |
| * @memberOf CN.schemaParser.schemas | |
| * @param {Object} dct A json object | |
| * @param {Object} methods The methods for this schema parser | |
| * @return {Object} The modified methods for this schema parser | |
| */ | |
| altMedia : function(dct,methods){ | |
| methods.altMedia = {}; | |
| methods.altMedia['type'] = dct.altMedia.type; | |
| var itemProps = {}; | |
| if(dct.altMedia.properties && dct.altMedia.properties.property){ | |
| itemProps = CN.utils.mapPropertyArray(dct.altMedia.properties.property); | |
| if(itemProps.id){ | |
| methods.altMedia['videoID']= function(){ | |
| return itemProps.id; | |
| }; | |
| } | |
| if(itemProps.playerID) { | |
| methods.altMedia['playerID'] = function() { | |
| return itemProps.playerID; | |
| } | |
| } | |
| } | |
| return methods; | |
| } | |
| }; | |
| /** | |
| * Default HTML templates for content that can have custom HTML per site, | |
| * but that we want to provide a baseline template for. | |
| * | |
| * @property defaultTemplates | |
| * @static | |
| */ | |
| CN.schemaParser.defaultTemplates = { | |
| /** | |
| * Pass in a photo, get annotations. This is coupled to the | |
| * jquery.annotations.js plugin. We assume that the top/left data is | |
| * provided correctly by the DCT. Because it can't be accessed directly, | |
| * it's set as a template object so both photo and mediaItems can call it | |
| * and get HTML. | |
| * | |
| * @memberOf CN.schemaParser.defaultTemplates | |
| * @requires jquery.annotations.js | |
| * @param {Object} dct A json photo (or format) object | |
| * @return {String} Annotations HTML for DOM insertion | |
| */ | |
| annotations : function(dct) { | |
| var i, | |
| il, | |
| html = '', | |
| props; | |
| if (dct.annotations) { | |
| html += '<ul class="annotations">'; | |
| if (Object.prototype.toString.call(dct.annotations.annotation) === '[object Array]') { | |
| // if array | |
| for (i = 0, il = dct.annotations.annotation.length; i < il; i++) { | |
| props = CN.utils.mapPropertyArray(dct.annotations.annotation[i].properties.property); | |
| html += '<li class="annotation" data-left="'; | |
| html += props.left; | |
| html += '" data-top="'; | |
| html += props.top; | |
| html += '">'; | |
| html += '<a href="#" class="annotation-trigger">Note:</a>'; | |
| html += '<div class="annotation-content">'; | |
| html += dct.annotations.annotation[i].body.text; | |
| html += '</div>'; | |
| html += '</li>'; | |
| } | |
| } else { | |
| // if object | |
| props = CN.utils.mapPropertyArray(dct.annotations.annotation.properties.property); | |
| html += '<li class="annotation" data-left="'; | |
| html += props.left; | |
| html += '" data-top="'; | |
| html += props.top; | |
| html += '">'; | |
| html += '<a href="#" class="annotation-trigger">Note:</a>'; | |
| html += '<div class="annotation-content">'; | |
| html += dct.annotations.annotation.body.text; | |
| html += '</div>'; | |
| html += '</li>'; | |
| } | |
| html += '</ul>'; | |
| } | |
| return html; | |
| }, | |
| /** | |
| * Returns HTML for contributors as a default template, | |
| * can be overridden in the implementation code. | |
| * | |
| * @param {Object} dct A json object of contributors | |
| * @return {String} The contributors HTML for DOM insertion | |
| */ | |
| contributors : function(dct) { | |
| var i, | |
| il, | |
| html = ''; | |
| html += '<div class="contributors">'; | |
| if (Object.prototype.toString.call(dct) === '[object Array]') { | |
| for (i = 0, il = dct.length; i < il; i++) { | |
| (function() { // scope for i | |
| var contributor = dct[i]; | |
| html += '<p><span class="contributor">'; | |
| html += contributor.label ? '<span class="label">' + contributor.label + '</span> ' : ''; | |
| html += contributor.name ? '<span class="name">' + contributor.name + '</span>' : ''; | |
| html += '</span></p>'; | |
| })(); | |
| } | |
| } else { | |
| html += '<p><span class="contributor">'; | |
| html += dct.label ? '<span class="label">' + dct.label + '</span> ' : ''; | |
| html += dct.name ? '<span class="name">' + dct.name + '</span>' : ''; | |
| html += '</span></p>'; | |
| } | |
| html += '</div>'; | |
| return html; | |
| } | |
| }; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment