498 lines
14 KiB
GraphQL
498 lines
14 KiB
GraphQL
directive @isAuthorized on FIELD_DEFINITION
|
|
directive @isAdmin on FIELD_DEFINITION
|
|
|
|
scalar Time
|
|
scalar Any
|
|
|
|
"Used to specify which order to sort items in"
|
|
enum OrderDirection {
|
|
"Sort accending A-Z"
|
|
ASC
|
|
"Sort decending Z-A"
|
|
DESC
|
|
}
|
|
|
|
"Used to specify pagination on a list of items"
|
|
input Pagination {
|
|
"How many items to maximally fetch"
|
|
limit: Int
|
|
"How many items to skip from the beginning of the query, specified by the `Ordering`"
|
|
offset: Int
|
|
}
|
|
|
|
"Used to specify how to sort items"
|
|
input Ordering {
|
|
"A column in the database to order by"
|
|
order_by: String
|
|
order_direction: OrderDirection
|
|
}
|
|
|
|
"Credentials used to identify and authenticate a share token"
|
|
input ShareTokenCredentials {
|
|
token: String!
|
|
password: String
|
|
}
|
|
|
|
type Query {
|
|
siteInfo: SiteInfo!
|
|
|
|
"List of registered users, must be admin to call"
|
|
user(order: Ordering, paginate: Pagination): [User!]! @isAdmin
|
|
"Information about the currently logged in user"
|
|
myUser: User! @isAuthorized
|
|
|
|
"User preferences for the logged in user"
|
|
myUserPreferences: UserPreferences! @isAuthorized
|
|
|
|
"List of albums owned by the logged in user."
|
|
myAlbums(
|
|
order: Ordering,
|
|
paginate: Pagination
|
|
"Return only albums from the root directory of the user"
|
|
onlyRoot: Boolean
|
|
"Return also albums with no media directly in them"
|
|
showEmpty: Boolean
|
|
"Show only albums having favorites"
|
|
onlyWithFavorites: Boolean
|
|
): [Album!]! @isAuthorized
|
|
"""
|
|
Get album by id, user must own the album or be admin
|
|
If valid tokenCredentials are provided, the album may be retrived without further authentication
|
|
"""
|
|
album(id: ID!, tokenCredentials: ShareTokenCredentials): Album!
|
|
|
|
"List of media owned by the logged in user"
|
|
myMedia(order: Ordering, paginate: Pagination): [Media!]! @isAuthorized
|
|
"""
|
|
Get media by id, user must own the media or be admin.
|
|
If valid tokenCredentials are provided, the media may be retrived without further authentication
|
|
"""
|
|
media(id: ID!, tokenCredentials: ShareTokenCredentials): Media!
|
|
|
|
"Get a list of media by their ids, user must own the media or be admin"
|
|
mediaList(ids: [ID!]!): [Media!]!
|
|
|
|
"""
|
|
Get a list of media, ordered first by day, then by album if multiple media was found for the same day.
|
|
"""
|
|
myTimeline(
|
|
paginate: Pagination,
|
|
onlyFavorites: Boolean,
|
|
"Only fetch media that is older than this date"
|
|
fromDate: Time
|
|
): [Media!]! @isAuthorized
|
|
|
|
"Get media owned by the logged in user, returned in GeoJson format"
|
|
myMediaGeoJson: Any! @isAuthorized
|
|
"Get the mapbox api token, returns null if mapbox is not enabled"
|
|
mapboxToken: String
|
|
|
|
"Fetch a share token containing an `Album` or `Media`"
|
|
shareToken(credentials: ShareTokenCredentials!): ShareToken!
|
|
"Check if the `ShareToken` credentials are valid"
|
|
shareTokenValidatePassword(credentials: ShareTokenCredentials!): Boolean!
|
|
|
|
"Perform a search query on the contents of the media library"
|
|
search(query: String!, limitMedia: Int, limitAlbums: Int): SearchResult!
|
|
|
|
"Get a list of `FaceGroup`s for the logged in user"
|
|
myFaceGroups(paginate: Pagination): [FaceGroup!]! @isAuthorized
|
|
"Get a particular `FaceGroup` specified by its ID"
|
|
faceGroup(id: ID!): FaceGroup! @isAuthorized
|
|
}
|
|
|
|
type Mutation {
|
|
"Authorizes a user and returns a token used to identify the new session"
|
|
authorizeUser(username: String!, password: String!): AuthorizeResult!
|
|
|
|
"Registers the initial user, can only be called if initialSetup from SiteInfo is true"
|
|
initialSetupWizard(
|
|
username: String!
|
|
password: String!
|
|
rootPath: String!
|
|
): AuthorizeResult
|
|
|
|
"Scan all users for new media"
|
|
scanAll: ScannerResult! @isAdmin
|
|
"Scan a single user for new media"
|
|
scanUser(userId: ID!): ScannerResult! @isAdmin
|
|
|
|
"Generate share token for album"
|
|
shareAlbum(albumId: ID!, expire: Time, password: String): ShareToken! @isAuthorized
|
|
"Generate share token for media"
|
|
shareMedia(mediaId: ID!, expire: Time, password: String): ShareToken! @isAuthorized
|
|
"Delete a share token by it's token value"
|
|
deleteShareToken(token: String!): ShareToken! @isAuthorized
|
|
"Set a password for a token, if null is passed for the password argument, the password will be cleared"
|
|
protectShareToken(token: String!, password: String): ShareToken! @isAuthorized
|
|
|
|
"Mark or unmark a media as being a favorite"
|
|
favoriteMedia(mediaId: ID!, favorite: Boolean!): Media! @isAuthorized
|
|
|
|
"Update a user, fields left as `null` will not be changed"
|
|
updateUser(
|
|
id: ID!
|
|
username: String
|
|
password: String
|
|
admin: Boolean
|
|
): User! @isAdmin
|
|
"Create a new user"
|
|
createUser(
|
|
username: String!
|
|
password: String
|
|
admin: Boolean!
|
|
): User! @isAdmin
|
|
"Delete an existing user"
|
|
deleteUser(id: ID!): User! @isAdmin
|
|
|
|
"Add a root path from where to look for media for the given user, specified by their user id."
|
|
userAddRootPath(id: ID!, rootPath: String!): Album @isAdmin
|
|
"""
|
|
Remove a root path from a user, specified by the id of the user and the top album representing the root path.
|
|
This album was returned when creating the path using `userAddRootPath`.
|
|
A list of root paths for a particular user can be retrived from the `User.rootAlbums` path.
|
|
"""
|
|
userRemoveRootAlbum(userId: ID!, albumId: ID!): Album @isAdmin
|
|
|
|
"""
|
|
Set how often, in seconds, the server should automatically scan for new media,
|
|
a value of 0 will disable periodic scans
|
|
"""
|
|
setPeriodicScanInterval(interval: Int!): Int! @isAdmin
|
|
|
|
"Set max number of concurrent scanner jobs running at once"
|
|
setScannerConcurrentWorkers(workers: Int!): Int! @isAdmin
|
|
|
|
"Set the filter to be used when generating thumbnails"
|
|
setThumbnailDownsampleMethod(method: ThumbnailFilter!): ThumbnailFilter! @isAdmin
|
|
|
|
"Change user preferences for the logged in user"
|
|
changeUserPreferences(language: String): UserPreferences! @isAuthorized
|
|
|
|
"Reset the assigned cover photo for an album"
|
|
resetAlbumCover(albumID: ID!): Album! @isAuthorized
|
|
"Assign a cover photo to an album"
|
|
setAlbumCover(coverID: ID!): Album! @isAuthorized
|
|
|
|
"Assign a label to a face group, set label to null to remove the current one"
|
|
setFaceGroupLabel(faceGroupID: ID!, label: String): FaceGroup! @isAuthorized
|
|
"Merge two face groups into a single one, all ImageFaces from source will be moved to destination"
|
|
combineFaceGroups(destinationFaceGroupID: ID!, sourceFaceGroupID: ID!): FaceGroup! @isAuthorized
|
|
"Move a list of ImageFaces to another face group"
|
|
moveImageFaces(imageFaceIDs: [ID!]!, destinationFaceGroupID: ID!): FaceGroup! @isAuthorized
|
|
"Check all unlabeled faces to see if they match a labeled FaceGroup, and move them if they match"
|
|
recognizeUnlabeledFaces: [ImageFace!]! @isAuthorized
|
|
"Move a list of ImageFaces to a new face group"
|
|
detachImageFaces(imageFaceIDs: [ID!]!): FaceGroup! @isAuthorized
|
|
}
|
|
|
|
type Subscription {
|
|
notification: Notification!
|
|
}
|
|
|
|
"Specified the type a particular notification is of"
|
|
enum NotificationType {
|
|
"A regular message with no special additions"
|
|
Message
|
|
"A notification with an attached progress indicator"
|
|
Progress
|
|
"Close a notification with a given key"
|
|
Close
|
|
}
|
|
|
|
type Notification {
|
|
"A key used to identify the notification, new notification updates with the same key, should replace the old notifications"
|
|
key: String!
|
|
type: NotificationType!
|
|
"The text for the title of the notification"
|
|
header: String!
|
|
"The text for the body of the notification"
|
|
content: String!
|
|
"A value between 0 and 1 when the notification type is `Progress`"
|
|
progress: Float
|
|
"Whether or not the message of the notification is positive, the UI might reflect this with a green color"
|
|
positive: Boolean!
|
|
"Whether or not the message of the notification is negative, the UI might reflect this with a red color"
|
|
negative: Boolean!
|
|
"Time in milliseconds before the notification should close"
|
|
timeout: Int
|
|
}
|
|
|
|
type AuthorizeResult {
|
|
success: Boolean!
|
|
"A textual status message describing the result, can be used to show an error message when `success` is false"
|
|
status: String!
|
|
"An access token used to authenticate new API requests as the newly authorized user. Is present when success is true"
|
|
token: String
|
|
}
|
|
|
|
type ScannerResult {
|
|
finished: Boolean!
|
|
success: Boolean!
|
|
progress: Float
|
|
message: String
|
|
}
|
|
|
|
"A token used to publicly access an album or media"
|
|
type ShareToken {
|
|
id: ID!
|
|
token: String!
|
|
"The user who created the token"
|
|
owner: User!
|
|
"Optional expire date"
|
|
expire: Time
|
|
"Whether or not a password is needed to access the share"
|
|
hasPassword: Boolean!
|
|
|
|
"The album this token shares"
|
|
album: Album
|
|
"The media this token shares"
|
|
media: Media
|
|
}
|
|
|
|
"Supported downsampling filters for thumbnail generation"
|
|
enum ThumbnailFilter {
|
|
NearestNeighbor,
|
|
Box,
|
|
Linear,
|
|
MitchellNetravali,
|
|
CatmullRom,
|
|
Lanczos,
|
|
}
|
|
|
|
"General information about the site"
|
|
type SiteInfo {
|
|
"Whether or not the initial setup wizard should be shown"
|
|
initialSetup: Boolean!
|
|
"Whether or not face detection is enabled and working"
|
|
faceDetectionEnabled: Boolean!
|
|
"How often automatic scans should be initiated in seconds"
|
|
periodicScanInterval: Int! @isAdmin
|
|
"How many max concurrent scanner jobs that should run at once"
|
|
concurrentWorkers: Int! @isAdmin
|
|
"The filter to use when generating thumbnails"
|
|
thumbnailMethod: ThumbnailFilter! @isAdmin
|
|
}
|
|
|
|
type User {
|
|
id: ID!
|
|
username: String!
|
|
"All albums owned by this user"
|
|
albums: [Album!]! @isAdmin
|
|
"Top level albums owned by this user"
|
|
rootAlbums: [Album!]! @isAdmin
|
|
"Whether or not the user has admin privileges"
|
|
admin: Boolean!
|
|
}
|
|
|
|
"Supported language translations of the user interface"
|
|
enum LanguageTranslation {
|
|
English,
|
|
French,
|
|
Italian,
|
|
Swedish,
|
|
Danish,
|
|
Spanish,
|
|
Polish,
|
|
Ukrainian,
|
|
German,
|
|
Russian,
|
|
TraditionalChinese,
|
|
SimplifiedChinese,
|
|
Portuguese,
|
|
Basque,
|
|
Turkish
|
|
}
|
|
|
|
"Preferences for regular users"
|
|
type UserPreferences {
|
|
id: ID!
|
|
language: LanguageTranslation
|
|
}
|
|
|
|
type Album {
|
|
id: ID!
|
|
title: String!
|
|
|
|
"The media inside this album"
|
|
media(
|
|
order: Ordering,
|
|
paginate: Pagination
|
|
"Return only the favorited media"
|
|
onlyFavorites: Boolean
|
|
): [Media!]!
|
|
|
|
"The albums contained in this album"
|
|
subAlbums(
|
|
order: Ordering,
|
|
paginate: Pagination
|
|
): [Album!]!
|
|
|
|
"The album which contains this album"
|
|
parentAlbum: Album
|
|
"The user who owns this album"
|
|
owner: User!
|
|
"The path on the filesystem of the server, where this album is located"
|
|
filePath: String!
|
|
"An image in this album used for previewing this album"
|
|
thumbnail: Media
|
|
"A breadcrumb list of all parent albums down to this one"
|
|
path: [Album!]!
|
|
|
|
"A list of share tokens pointing to this album, owned by the logged in user"
|
|
shares: [ShareToken!]!
|
|
}
|
|
|
|
type MediaURL {
|
|
"URL for previewing the image"
|
|
url: String!
|
|
"Width of the image in pixels"
|
|
width: Int!
|
|
"Height of the image in pixels"
|
|
height: Int!
|
|
"The file size of the resource in bytes"
|
|
fileSize: Int!
|
|
}
|
|
|
|
type MediaDownload {
|
|
"A description of the role of the media file"
|
|
title: String!
|
|
mediaUrl: MediaURL!
|
|
}
|
|
|
|
enum MediaType {
|
|
Photo
|
|
Video
|
|
}
|
|
|
|
type Media {
|
|
id: ID!
|
|
title: String!
|
|
"Local filepath for the media"
|
|
path: String!
|
|
"URL to display the media in a smaller resolution"
|
|
thumbnail: MediaURL
|
|
"URL to display the photo in full resolution, will be null for videos"
|
|
highRes: MediaURL
|
|
"URL to get the video in a web format that can be played in the browser, will be null for photos"
|
|
videoWeb: MediaURL
|
|
"The album that holds the media"
|
|
album: Album!
|
|
exif: MediaEXIF
|
|
videoMetadata: VideoMetadata
|
|
favorite: Boolean!
|
|
type: MediaType!
|
|
"The date the image was shot or the date it was imported as a fallback"
|
|
date: Time!
|
|
"A short string that can be used to generate a blured version of the media, to show while the original is loading"
|
|
blurhash: String
|
|
|
|
"A list of share tokens pointing to this media, owned byt the logged in user"
|
|
shares: [ShareToken!]!
|
|
"A list of different versions of files for this media that can be downloaded by the user"
|
|
downloads: [MediaDownload!]!
|
|
|
|
"A list of faces present on the image"
|
|
faces: [ImageFace!]!
|
|
}
|
|
|
|
"EXIF metadata from the camera"
|
|
type MediaEXIF {
|
|
id: ID!
|
|
media: Media!
|
|
"The description of the image"
|
|
description: String
|
|
"The model name of the camera"
|
|
camera: String
|
|
"The maker of the camera"
|
|
maker: String
|
|
"The name of the lens"
|
|
lens: String
|
|
dateShot: Time
|
|
"The exposure time of the image"
|
|
exposure: Float
|
|
"The aperature stops of the image"
|
|
aperture: Float
|
|
"The ISO setting of the image"
|
|
iso: Int
|
|
"The focal length of the lens, when the image was taken"
|
|
focalLength: Float
|
|
"A formatted description of the flash settings, when the image was taken"
|
|
flash: Int
|
|
"An index describing the mode for adjusting the exposure of the image"
|
|
exposureProgram: Int
|
|
"GPS coordinates of where the image was taken"
|
|
coordinates: Coordinates
|
|
}
|
|
|
|
type Coordinates {
|
|
"GPS latitude in degrees"
|
|
latitude: Float!
|
|
"GPS longitude in degrees"
|
|
longitude: Float!
|
|
}
|
|
|
|
"Metadata specific to video media"
|
|
type VideoMetadata {
|
|
id: ID!
|
|
media: Media!
|
|
width: Int!
|
|
height: Int!
|
|
duration: Float!
|
|
codec: String
|
|
framerate: Float
|
|
bitrate: String
|
|
colorProfile: String
|
|
audio: String
|
|
}
|
|
|
|
type SearchResult {
|
|
"The string that was searched for"
|
|
query: String!
|
|
"A list of albums that matched the query"
|
|
albums: [Album!]!
|
|
"A list of media that matched the query"
|
|
media: [Media!]!
|
|
}
|
|
|
|
"A group of media from the same album and the same day, that is grouped together in a timeline view"
|
|
type TimelineGroup {
|
|
"The full album containing the media in this timeline group"
|
|
album: Album!
|
|
"The media contained in this timeline group"
|
|
media: [Media!]!
|
|
"The total amount of media in this timeline group"
|
|
mediaTotal: Int!
|
|
"The day shared for all media in this timeline group"
|
|
date: Time!
|
|
}
|
|
|
|
"A collection of faces of a particular person"
|
|
type FaceGroup {
|
|
id: ID!
|
|
"The name of the person"
|
|
label: String
|
|
imageFaces(paginate: Pagination): [ImageFace!]!
|
|
"The total number of images in this collection"
|
|
imageFaceCount: Int!
|
|
}
|
|
|
|
"A single face on a particular image"
|
|
type ImageFace {
|
|
id: ID!
|
|
"A reference to the image the face appears on"
|
|
media: Media!
|
|
"A bounding box of where on the image the face is present"
|
|
rectangle: FaceRectangle!
|
|
"The `FaceGroup` that contains this `ImageFace`"
|
|
faceGroup: FaceGroup!
|
|
}
|
|
|
|
"A bounding box of where a face is present on an image. The values map from 0 to 1 as a fraction of the image width/height"
|
|
type FaceRectangle {
|
|
minX: Float!
|
|
maxX: Float!
|
|
minY: Float!
|
|
maxY: Float!
|
|
}
|