mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/MultimediaViewer
synced 2024-09-30 05:37:46 +00:00
406 lines
12 KiB
JavaScript
406 lines
12 KiB
JavaScript
/*
|
|
* This file is part of the MediaWiki extension MultimediaViewer.
|
|
*
|
|
* MultimediaViewer is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* MultimediaViewer is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with MultimediaViewer. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
( function ( mw, oo ) {
|
|
/**
|
|
* @class mw.mmv.model.Image
|
|
* Represents information about a single image
|
|
* @constructor
|
|
* @param {mw.Title} title
|
|
* @param {number} size Filesize in bytes of the original image
|
|
* @param {number} width Width of the original image
|
|
* @param {number} height Height of the original image
|
|
* @param {string} mimeType
|
|
* @param {string} url URL to the image itself (original version)
|
|
* @param {string} descriptionUrl URL to the image description page
|
|
* @param {string} repo The repository this image belongs to
|
|
* @param {string} lastUploader The last person to upload a version of this image.
|
|
* @param {string} lastUploadDateTime The time and date the last upload occurred
|
|
* @param {string} originalUploadDateTime The time and date the original upload occurred
|
|
* @param {string} description
|
|
* @param {string} source
|
|
* @param {string} author
|
|
* @param {string} license
|
|
* @param {number} latitude
|
|
* @param {number} longitude
|
|
*/
|
|
function Image(
|
|
title,
|
|
size,
|
|
width,
|
|
height,
|
|
mimeType,
|
|
url,
|
|
descriptionUrl,
|
|
repo,
|
|
lastUploader,
|
|
uploadDateTime,
|
|
creationDateTime,
|
|
description,
|
|
source,
|
|
author,
|
|
license,
|
|
latitude,
|
|
longitude
|
|
) {
|
|
/** @property {mw.Title} title The title of the image file */
|
|
this.title = title;
|
|
|
|
/** @property {number} size The filesize, in bytes, of the original image */
|
|
this.size = size;
|
|
|
|
/** @property {number} width The width, in pixels, of the original image */
|
|
this.width = width;
|
|
|
|
/** @property {number} height The height, in pixels, of the original image */
|
|
this.height = height;
|
|
|
|
/** @property {string} mimeType The MIME type of the original image */
|
|
this.mimeType = mimeType;
|
|
|
|
/** @property {string} url The URL to the original image */
|
|
this.url = url;
|
|
|
|
/** @property {string} descriptionUrl The URL to the description page for the image */
|
|
this.descriptionUrl = descriptionUrl;
|
|
|
|
/** @property {string} repo The name of the repository where this image is stored */
|
|
this.repo = repo;
|
|
|
|
/** @property {string} lastUploader The person who uploaded the last version of the file */
|
|
this.lastUploader = lastUploader;
|
|
|
|
/** @property {string} uploadDateTime The date and time of the last upload */
|
|
this.uploadDateTime = uploadDateTime;
|
|
|
|
/** @property {string} creationDateTime The date and time that the image was created */
|
|
this.creationDateTime = creationDateTime;
|
|
|
|
/** @property {string} description The description from the file page - unsafe HTML sometimes goes here */
|
|
this.description = description;
|
|
|
|
/** @property {string} source The source for the image (could be an organization, e.g.) - unsafe HTML sometimes goes here */
|
|
this.source = source;
|
|
|
|
/** @property {string} author The author of the image - unsafe HTML sometimes goes here */
|
|
this.author = author;
|
|
|
|
/** @property {string} license The license under which the image is distributed */
|
|
this.license = license;
|
|
|
|
/** @property {number} latitude The latitude of the place where the image was created */
|
|
this.latitude = latitude;
|
|
|
|
/** @property {number} longitude The longitude of the place where the image was created */
|
|
this.longitude = longitude;
|
|
|
|
/**
|
|
* @property {Object} thumbUrls
|
|
* An object indexed by image widths
|
|
* with URLs to appropriately sized thumbnails
|
|
*/
|
|
this.thumbUrls = {};
|
|
}
|
|
|
|
/**
|
|
* @method
|
|
* @static
|
|
* Constructs a new Image object out of an object containing
|
|
* imageinfo data from an API response.
|
|
* @param {mw.Title} title
|
|
* @param {Object} imageInfo
|
|
* @returns {mw.mmv.model.Image}
|
|
*/
|
|
Image.newFromImageInfo = function ( title, imageInfo ) {
|
|
var uploadDateTime, creationDateTime, imageData,
|
|
description, source, author, license,
|
|
latitude, longitude,
|
|
innerInfo = imageInfo.imageinfo[0],
|
|
extmeta = innerInfo.extmetadata;
|
|
|
|
if ( extmeta ) {
|
|
creationDateTime = extmeta.DateTimeOriginal;
|
|
uploadDateTime = extmeta.DateTime;
|
|
|
|
if ( uploadDateTime ) {
|
|
uploadDateTime = uploadDateTime.value.replace( /<.*?>/g, '' );
|
|
}
|
|
|
|
if ( creationDateTime ) {
|
|
creationDateTime = creationDateTime.value.replace( /<.*?>/g, '' );
|
|
}
|
|
|
|
description = extmeta.ImageDescription && extmeta.ImageDescription.value;
|
|
source = extmeta.Credit && extmeta.Credit.value;
|
|
author = extmeta.Artist && extmeta.Artist.value;
|
|
license = extmeta.License && extmeta.License.value;
|
|
|
|
latitude = extmeta.GPSLatitude && parseFloat( extmeta.GPSLatitude.value );
|
|
longitude = extmeta.GPSLongitude && parseFloat( extmeta.GPSLongitude.value );
|
|
}
|
|
|
|
imageData = new Image(
|
|
title,
|
|
innerInfo.size,
|
|
innerInfo.width,
|
|
innerInfo.height,
|
|
innerInfo.mime,
|
|
innerInfo.url,
|
|
innerInfo.descriptionurl,
|
|
imageInfo.imagerepository,
|
|
innerInfo.user,
|
|
uploadDateTime,
|
|
creationDateTime,
|
|
description,
|
|
source,
|
|
author,
|
|
license,
|
|
latitude,
|
|
longitude
|
|
);
|
|
|
|
if ( innerInfo.thumburl ) {
|
|
imageData.addThumbUrl(
|
|
innerInfo.thumbwidth,
|
|
innerInfo.thumburl
|
|
);
|
|
}
|
|
|
|
return imageData;
|
|
};
|
|
|
|
/**
|
|
* @method
|
|
* Add a thumb URL
|
|
* @param {number} width
|
|
* @param {string} url
|
|
*/
|
|
Image.prototype.addThumbUrl = function ( width, url ) {
|
|
this.thumbUrls[width] = url;
|
|
};
|
|
|
|
/**
|
|
* @method
|
|
* Get a thumb URL if we have it.
|
|
* @param {number} width
|
|
* @returns {string|undefined}
|
|
*/
|
|
Image.prototype.getThumbUrl = function ( width ) {
|
|
return this.thumbUrls[width];
|
|
};
|
|
|
|
/**
|
|
* @method
|
|
* Check whether the image is CC-licensed.
|
|
* @returns {boolean}
|
|
*/
|
|
Image.prototype.isCcLicensed = function () {
|
|
return this.license && this.license.substr( 0, 2 ) === 'cc';
|
|
};
|
|
|
|
/**
|
|
* @method
|
|
* Check whether the image has geolocation data.
|
|
* @returns {boolean}
|
|
*/
|
|
Image.prototype.hasCoords = function () {
|
|
return this.hasOwnProperty( 'latitude' ) && this.hasOwnProperty( 'longitude' ) &&
|
|
this.latitude !== undefined && this.latitude !== null &&
|
|
this.longitude !== undefined && this.longitude !== null;
|
|
};
|
|
|
|
/**
|
|
* @class mw.mmv.model.Repo
|
|
* Represents information about a single image repository
|
|
* @constructor
|
|
* @param {string} displayName
|
|
* @param {string} favIcon URL to the repo's favicon
|
|
* @param {boolean} isLocal
|
|
*/
|
|
function Repo(
|
|
displayName,
|
|
favIcon,
|
|
isLocal
|
|
) {
|
|
/** @property {string} displayName Human-readable name of the repository */
|
|
this.displayName = displayName;
|
|
|
|
/** @property {string} favIcon An icon that represents the repository */
|
|
this.favIcon = favIcon;
|
|
|
|
/** @property {boolean} isLocal Whether the repository is the local wiki */
|
|
this.isLocal = isLocal;
|
|
}
|
|
|
|
/**
|
|
* @method
|
|
* @static
|
|
* Creates a new object from repoInfo we found in an API response.
|
|
* @param {Object} repoInfo
|
|
* @returns {mw.mmv.model.Repo}
|
|
*/
|
|
Repo.newFromRepoInfo = function ( repoInfo ) {
|
|
if ( repoInfo.apiurl ) {
|
|
return new ForeignApiRepo(
|
|
repoInfo.displayname,
|
|
repoInfo.favicon,
|
|
false,
|
|
repoInfo.apiurl,
|
|
repoInfo.server,
|
|
repoInfo.articlepath
|
|
);
|
|
} else if ( repoInfo.descBaseUrl ) {
|
|
return new ForeignDbRepo(
|
|
repoInfo.displayname,
|
|
repoInfo.favicon,
|
|
false,
|
|
repoInfo.descBaseUrl
|
|
);
|
|
} else {
|
|
return new Repo( repoInfo.displayname, repoInfo.favicon, repoInfo.local );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @class mw.mmv.model.ForeignApiRepo
|
|
* Represents information about a foreign API repository
|
|
* @extends mw.mmv.model.Repo
|
|
* @constructor
|
|
* @inheritdoc
|
|
* @param {string} apiUrl URL to the wiki's api.php
|
|
* @param {string} server Hostname for the wiki
|
|
* @param {string} articlePath Path to articles on the wiki, relative to the hostname.
|
|
*/
|
|
function ForeignApiRepo(
|
|
displayName,
|
|
favIcon,
|
|
isLocal,
|
|
apiUrl,
|
|
server,
|
|
articlePath
|
|
) {
|
|
Repo.call( this, displayName, favIcon, isLocal );
|
|
|
|
/** @property {string} apiUrl URL to the wiki's api.php */
|
|
this.apiUrl = apiUrl;
|
|
|
|
/** @property {string} server Hostname for the wiki */
|
|
this.server = server;
|
|
|
|
/** @property {string} articlePath Path to articles on the wiki, relative to the hostname */
|
|
this.articlePath = articlePath;
|
|
|
|
/** @property {string} absoluteArticlePath Path to articles on the wiki, relative to nothing */
|
|
this.absoluteArticlePath = server + articlePath;
|
|
}
|
|
|
|
oo.inheritClass( ForeignApiRepo, Repo );
|
|
|
|
/**
|
|
* @class mw.mmv.model.ForeignDbRepo
|
|
* Represents information about a foreign, shared DB repository
|
|
* @extends mw.mmv.model.Repo
|
|
* @constructor
|
|
* @inheritdoc
|
|
*/
|
|
function ForeignDbRepo(
|
|
displayName,
|
|
favIcon,
|
|
isLocal,
|
|
descBaseUrl
|
|
) {
|
|
Repo.call( this, displayName, favIcon, isLocal );
|
|
|
|
/** @property {string} descBaseUrl Base URL for descriptions on the wiki - append a file's title to this to get the description page */
|
|
this.descBaseUrl = descBaseUrl;
|
|
}
|
|
|
|
oo.inheritClass( ForeignDbRepo, Repo );
|
|
|
|
/**
|
|
* @class mw.mmv.model.FileUsage
|
|
* Represents information about the wiki pages using a given file
|
|
* @constructor
|
|
* @param {mw.Title} file
|
|
* @param {mw.mmv.model.FileUsage.Scope} scope
|
|
* @param {{wiki: String|null, page: mw.Title}[]} pages
|
|
* A list of pages which use this file. Each page is an object with a 'page' field
|
|
* containing the wiki page (a Title object) and a 'wiki' field which is a domain name,
|
|
* or null for local files.
|
|
* @param {Number} [totalCount] total number of pages where the file is used (the list passed
|
|
* in pages parameter might be cut off at some limit)
|
|
* @param {boolean} [totalCountIsLowerBound = false] False means totalCount is accurate,
|
|
* true means it is a lower bound (the real count can be way greater).
|
|
*
|
|
*/
|
|
function FileUsage(
|
|
file,
|
|
scope,
|
|
pages,
|
|
totalCount,
|
|
totalCountIsLowerBound
|
|
) {
|
|
/** @property {mw.Title} mw.mmv.model.FileUsage.file */
|
|
this.file = file;
|
|
|
|
/** @property {mw.mmv.model.FileUsage.Scope} mw.mmv.model.FileUsage.scope */
|
|
this.scope = scope;
|
|
|
|
/** @property {{wiki: String|null, page: mw.Title}[]} mw.mmv.model.FileUsage.pages */
|
|
this.pages = pages;
|
|
|
|
/** @property {Number} mw.mmv.model.FileUsage.totalCount
|
|
*/
|
|
this.totalCount = totalCount || pages.length;
|
|
|
|
/**
|
|
* For files which are used on a huge amount of pages, getting an exact count might be
|
|
* impossible. In such a case this field tells us that the count is "fake". For example
|
|
* if totalCount is 100 and totalCountIsLowerBound is true, a message about usage count
|
|
* should be something like "this file is used on more than 100 pages". (This would happen
|
|
* when we query the api with a limit of 100; the real usage count could be in the millions
|
|
* for all we know.)
|
|
* @property {boolean} mw.mmv.model.FileUsage.totalCountIsLowerBound
|
|
*/
|
|
this.totalCountIsLowerBound = !!totalCountIsLowerBound;
|
|
}
|
|
|
|
/**
|
|
* @typedef {mw.mmv.model.FileUsage.Scope}
|
|
* @enum
|
|
* @type {String}
|
|
*/
|
|
FileUsage.Scope = {
|
|
/**
|
|
* Only pages from the local wiki (the one where the user is now)
|
|
*/
|
|
LOCAL: 'local',
|
|
|
|
/**
|
|
* All pages, including other wikis
|
|
*/
|
|
GLOBAL: 'global'
|
|
};
|
|
|
|
mw.mmv.model = {};
|
|
mw.mmv.model.Image = Image;
|
|
mw.mmv.model.Repo = Repo;
|
|
mw.mmv.model.ForeignApiRepo = ForeignApiRepo;
|
|
mw.mmv.model.ForeignDbRepo = ForeignDbRepo;
|
|
mw.mmv.model.FileUsage = FileUsage;
|
|
}( mediaWiki, OO ) );
|