1033 lines
29 KiB
Dart
1033 lines
29 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
import 'package:meta/meta.dart';
|
|
import 'package:artemis/artemis.dart';
|
|
import 'package:json_annotation/json_annotation.dart';
|
|
import 'package:equatable/equatable.dart';
|
|
import 'package:gql/ast.dart';
|
|
import 'package:http/http.dart';
|
|
import 'package:imagini/helpers/upload_serializer.dart';
|
|
part 'imagini_graphql.graphql.g.dart';
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Login$Query$AuthResponse$Device with EquatableMixin {
|
|
Login$Query$AuthResponse$Device();
|
|
|
|
factory Login$Query$AuthResponse$Device.fromJson(Map<String, dynamic> json) =>
|
|
_$Login$Query$AuthResponse$DeviceFromJson(json);
|
|
|
|
String id;
|
|
|
|
@override
|
|
List<Object> get props => [id];
|
|
Map<String, dynamic> toJson() =>
|
|
_$Login$Query$AuthResponse$DeviceToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Login$Query$AuthResponse with EquatableMixin {
|
|
Login$Query$AuthResponse();
|
|
|
|
factory Login$Query$AuthResponse.fromJson(Map<String, dynamic> json) =>
|
|
_$Login$Query$AuthResponseFromJson(json);
|
|
|
|
@JsonKey(unknownEnumValue: AuthResult.artemisUnknown)
|
|
AuthResult result;
|
|
|
|
Login$Query$AuthResponse$Device device;
|
|
|
|
@override
|
|
List<Object> get props => [result, device];
|
|
Map<String, dynamic> toJson() => _$Login$Query$AuthResponseToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Login$Query with EquatableMixin {
|
|
Login$Query();
|
|
|
|
factory Login$Query.fromJson(Map<String, dynamic> json) =>
|
|
_$Login$QueryFromJson(json);
|
|
|
|
Login$Query$AuthResponse login;
|
|
|
|
@override
|
|
List<Object> get props => [login];
|
|
Map<String, dynamic> toJson() => _$Login$QueryToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class CreateMediaItem$Mutation$MediaItem with EquatableMixin {
|
|
CreateMediaItem$Mutation$MediaItem();
|
|
|
|
factory CreateMediaItem$Mutation$MediaItem.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$CreateMediaItem$Mutation$MediaItemFromJson(json);
|
|
|
|
String id;
|
|
|
|
DateTime createdAt;
|
|
|
|
DateTime updatedAt;
|
|
|
|
DateTime exifDate;
|
|
|
|
double latitude;
|
|
|
|
double longitude;
|
|
|
|
bool isVideo;
|
|
|
|
String fileName;
|
|
|
|
String origName;
|
|
|
|
String userID;
|
|
|
|
@override
|
|
List<Object> get props => [
|
|
id,
|
|
createdAt,
|
|
updatedAt,
|
|
exifDate,
|
|
latitude,
|
|
longitude,
|
|
isVideo,
|
|
fileName,
|
|
origName,
|
|
userID
|
|
];
|
|
Map<String, dynamic> toJson() =>
|
|
_$CreateMediaItem$Mutation$MediaItemToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class CreateMediaItem$Mutation with EquatableMixin {
|
|
CreateMediaItem$Mutation();
|
|
|
|
factory CreateMediaItem$Mutation.fromJson(Map<String, dynamic> json) =>
|
|
_$CreateMediaItem$MutationFromJson(json);
|
|
|
|
CreateMediaItem$Mutation$MediaItem createMediaItem;
|
|
|
|
@override
|
|
List<Object> get props => [createMediaItem];
|
|
Map<String, dynamic> toJson() => _$CreateMediaItem$MutationToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Me$Query$User with EquatableMixin {
|
|
Me$Query$User();
|
|
|
|
factory Me$Query$User.fromJson(Map<String, dynamic> json) =>
|
|
_$Me$Query$UserFromJson(json);
|
|
|
|
String id;
|
|
|
|
DateTime createdAt;
|
|
|
|
DateTime updatedAt;
|
|
|
|
String email;
|
|
|
|
String username;
|
|
|
|
String firstName;
|
|
|
|
String lastName;
|
|
|
|
@JsonKey(unknownEnumValue: Role.artemisUnknown)
|
|
Role role;
|
|
|
|
@JsonKey(unknownEnumValue: AuthType.artemisUnknown)
|
|
AuthType authType;
|
|
|
|
@override
|
|
List<Object> get props => [
|
|
id,
|
|
createdAt,
|
|
updatedAt,
|
|
email,
|
|
username,
|
|
firstName,
|
|
lastName,
|
|
role,
|
|
authType
|
|
];
|
|
Map<String, dynamic> toJson() => _$Me$Query$UserToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Me$Query with EquatableMixin {
|
|
Me$Query();
|
|
|
|
factory Me$Query.fromJson(Map<String, dynamic> json) =>
|
|
_$Me$QueryFromJson(json);
|
|
|
|
Me$Query$User me;
|
|
|
|
@override
|
|
List<Object> get props => [me];
|
|
Map<String, dynamic> toJson() => _$Me$QueryToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class MediaItems$Query$MediaItemResponse$MediaItem with EquatableMixin {
|
|
MediaItems$Query$MediaItemResponse$MediaItem();
|
|
|
|
factory MediaItems$Query$MediaItemResponse$MediaItem.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$MediaItems$Query$MediaItemResponse$MediaItemFromJson(json);
|
|
|
|
String id;
|
|
|
|
String fileName;
|
|
|
|
double latitude;
|
|
|
|
double longitude;
|
|
|
|
bool isVideo;
|
|
|
|
String origName;
|
|
|
|
DateTime createdAt;
|
|
|
|
@override
|
|
List<Object> get props =>
|
|
[id, fileName, latitude, longitude, isVideo, origName, createdAt];
|
|
Map<String, dynamic> toJson() =>
|
|
_$MediaItems$Query$MediaItemResponse$MediaItemToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class MediaItems$Query$MediaItemResponse$PageResponse with EquatableMixin {
|
|
MediaItems$Query$MediaItemResponse$PageResponse();
|
|
|
|
factory MediaItems$Query$MediaItemResponse$PageResponse.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$MediaItems$Query$MediaItemResponse$PageResponseFromJson(json);
|
|
|
|
int size;
|
|
|
|
int page;
|
|
|
|
int total;
|
|
|
|
@override
|
|
List<Object> get props => [size, page, total];
|
|
Map<String, dynamic> toJson() =>
|
|
_$MediaItems$Query$MediaItemResponse$PageResponseToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class MediaItems$Query$MediaItemResponse with EquatableMixin {
|
|
MediaItems$Query$MediaItemResponse();
|
|
|
|
factory MediaItems$Query$MediaItemResponse.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$MediaItems$Query$MediaItemResponseFromJson(json);
|
|
|
|
List<MediaItems$Query$MediaItemResponse$MediaItem> data;
|
|
|
|
MediaItems$Query$MediaItemResponse$PageResponse page;
|
|
|
|
@override
|
|
List<Object> get props => [data, page];
|
|
Map<String, dynamic> toJson() =>
|
|
_$MediaItems$Query$MediaItemResponseToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class MediaItems$Query with EquatableMixin {
|
|
MediaItems$Query();
|
|
|
|
factory MediaItems$Query.fromJson(Map<String, dynamic> json) =>
|
|
_$MediaItems$QueryFromJson(json);
|
|
|
|
MediaItems$Query$MediaItemResponse mediaItems;
|
|
|
|
@override
|
|
List<Object> get props => [mediaItems];
|
|
Map<String, dynamic> toJson() => _$MediaItems$QueryToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class TimeFilter with EquatableMixin {
|
|
TimeFilter(
|
|
{this.equalTo,
|
|
this.notEqualTo,
|
|
this.lessThan,
|
|
this.lessThanOrEqualTo,
|
|
this.greaterThan,
|
|
this.greaterThanOrEqualTo});
|
|
|
|
factory TimeFilter.fromJson(Map<String, dynamic> json) =>
|
|
_$TimeFilterFromJson(json);
|
|
|
|
DateTime equalTo;
|
|
|
|
DateTime notEqualTo;
|
|
|
|
DateTime lessThan;
|
|
|
|
DateTime lessThanOrEqualTo;
|
|
|
|
DateTime greaterThan;
|
|
|
|
DateTime greaterThanOrEqualTo;
|
|
|
|
@override
|
|
List<Object> get props => [
|
|
equalTo,
|
|
notEqualTo,
|
|
lessThan,
|
|
lessThanOrEqualTo,
|
|
greaterThan,
|
|
greaterThanOrEqualTo
|
|
];
|
|
Map<String, dynamic> toJson() => _$TimeFilterToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class FloatFilter with EquatableMixin {
|
|
FloatFilter(
|
|
{this.equalTo,
|
|
this.notEqualTo,
|
|
this.lessThan,
|
|
this.lessThanOrEqualTo,
|
|
this.greaterThan,
|
|
this.greaterThanOrEqualTo});
|
|
|
|
factory FloatFilter.fromJson(Map<String, dynamic> json) =>
|
|
_$FloatFilterFromJson(json);
|
|
|
|
double equalTo;
|
|
|
|
double notEqualTo;
|
|
|
|
double lessThan;
|
|
|
|
double lessThanOrEqualTo;
|
|
|
|
double greaterThan;
|
|
|
|
double greaterThanOrEqualTo;
|
|
|
|
@override
|
|
List<Object> get props => [
|
|
equalTo,
|
|
notEqualTo,
|
|
lessThan,
|
|
lessThanOrEqualTo,
|
|
greaterThan,
|
|
greaterThanOrEqualTo
|
|
];
|
|
Map<String, dynamic> toJson() => _$FloatFilterToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class BooleanFilter with EquatableMixin {
|
|
BooleanFilter({this.equalTo, this.notEqualTo});
|
|
|
|
factory BooleanFilter.fromJson(Map<String, dynamic> json) =>
|
|
_$BooleanFilterFromJson(json);
|
|
|
|
bool equalTo;
|
|
|
|
bool notEqualTo;
|
|
|
|
@override
|
|
List<Object> get props => [equalTo, notEqualTo];
|
|
Map<String, dynamic> toJson() => _$BooleanFilterToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class IDFilter with EquatableMixin {
|
|
IDFilter({this.equalTo, this.notEqualTo});
|
|
|
|
factory IDFilter.fromJson(Map<String, dynamic> json) =>
|
|
_$IDFilterFromJson(json);
|
|
|
|
String equalTo;
|
|
|
|
String notEqualTo;
|
|
|
|
@override
|
|
List<Object> get props => [equalTo, notEqualTo];
|
|
Map<String, dynamic> toJson() => _$IDFilterToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class StringFilter with EquatableMixin {
|
|
StringFilter(
|
|
{this.equalTo,
|
|
this.notEqualTo,
|
|
this.startsWith,
|
|
this.notStartsWith,
|
|
this.endsWith,
|
|
this.notEndsWith,
|
|
this.contains,
|
|
this.notContains});
|
|
|
|
factory StringFilter.fromJson(Map<String, dynamic> json) =>
|
|
_$StringFilterFromJson(json);
|
|
|
|
String equalTo;
|
|
|
|
String notEqualTo;
|
|
|
|
String startsWith;
|
|
|
|
String notStartsWith;
|
|
|
|
String endsWith;
|
|
|
|
String notEndsWith;
|
|
|
|
String contains;
|
|
|
|
String notContains;
|
|
|
|
@override
|
|
List<Object> get props => [
|
|
equalTo,
|
|
notEqualTo,
|
|
startsWith,
|
|
notStartsWith,
|
|
endsWith,
|
|
notEndsWith,
|
|
contains,
|
|
notContains
|
|
];
|
|
Map<String, dynamic> toJson() => _$StringFilterToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class MediaItemFilter with EquatableMixin {
|
|
MediaItemFilter(
|
|
{this.id,
|
|
this.createdAt,
|
|
this.updatedAt,
|
|
this.exifDate,
|
|
this.latitude,
|
|
this.longitude,
|
|
this.isVideo,
|
|
this.origName,
|
|
this.tags,
|
|
this.albums});
|
|
|
|
factory MediaItemFilter.fromJson(Map<String, dynamic> json) =>
|
|
_$MediaItemFilterFromJson(json);
|
|
|
|
IDFilter id;
|
|
|
|
TimeFilter createdAt;
|
|
|
|
TimeFilter updatedAt;
|
|
|
|
TimeFilter exifDate;
|
|
|
|
FloatFilter latitude;
|
|
|
|
FloatFilter longitude;
|
|
|
|
BooleanFilter isVideo;
|
|
|
|
StringFilter origName;
|
|
|
|
TagFilter tags;
|
|
|
|
AlbumFilter albums;
|
|
|
|
@override
|
|
List<Object> get props => [
|
|
id,
|
|
createdAt,
|
|
updatedAt,
|
|
exifDate,
|
|
latitude,
|
|
longitude,
|
|
isVideo,
|
|
origName,
|
|
tags,
|
|
albums
|
|
];
|
|
Map<String, dynamic> toJson() => _$MediaItemFilterToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class TagFilter with EquatableMixin {
|
|
TagFilter({this.id, this.createdAt, this.updatedAt, this.name});
|
|
|
|
factory TagFilter.fromJson(Map<String, dynamic> json) =>
|
|
_$TagFilterFromJson(json);
|
|
|
|
IDFilter id;
|
|
|
|
TimeFilter createdAt;
|
|
|
|
TimeFilter updatedAt;
|
|
|
|
StringFilter name;
|
|
|
|
@override
|
|
List<Object> get props => [id, createdAt, updatedAt, name];
|
|
Map<String, dynamic> toJson() => _$TagFilterToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class AlbumFilter with EquatableMixin {
|
|
AlbumFilter({this.id, this.createdAt, this.updatedAt, this.name});
|
|
|
|
factory AlbumFilter.fromJson(Map<String, dynamic> json) =>
|
|
_$AlbumFilterFromJson(json);
|
|
|
|
IDFilter id;
|
|
|
|
TimeFilter createdAt;
|
|
|
|
TimeFilter updatedAt;
|
|
|
|
StringFilter name;
|
|
|
|
@override
|
|
List<Object> get props => [id, createdAt, updatedAt, name];
|
|
Map<String, dynamic> toJson() => _$AlbumFilterToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Page with EquatableMixin {
|
|
Page({this.size, this.page});
|
|
|
|
factory Page.fromJson(Map<String, dynamic> json) => _$PageFromJson(json);
|
|
|
|
int size;
|
|
|
|
int page;
|
|
|
|
@override
|
|
List<Object> get props => [size, page];
|
|
Map<String, dynamic> toJson() => _$PageToJson(this);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Order with EquatableMixin {
|
|
Order({this.by, this.direction});
|
|
|
|
factory Order.fromJson(Map<String, dynamic> json) => _$OrderFromJson(json);
|
|
|
|
String by;
|
|
|
|
@JsonKey(unknownEnumValue: OrderDirection.artemisUnknown)
|
|
OrderDirection direction;
|
|
|
|
@override
|
|
List<Object> get props => [by, direction];
|
|
Map<String, dynamic> toJson() => _$OrderToJson(this);
|
|
}
|
|
|
|
enum AuthResult {
|
|
@JsonValue('Success')
|
|
success,
|
|
@JsonValue('Failure')
|
|
failure,
|
|
@JsonValue('ARTEMIS_UNKNOWN')
|
|
artemisUnknown,
|
|
}
|
|
enum Role {
|
|
@JsonValue('Admin')
|
|
admin,
|
|
@JsonValue('User')
|
|
user,
|
|
@JsonValue('ARTEMIS_UNKNOWN')
|
|
artemisUnknown,
|
|
}
|
|
enum AuthType {
|
|
@JsonValue('Local')
|
|
local,
|
|
@JsonValue('LDAP')
|
|
ldap,
|
|
@JsonValue('ARTEMIS_UNKNOWN')
|
|
artemisUnknown,
|
|
}
|
|
enum OrderDirection {
|
|
@JsonValue('ASC')
|
|
asc,
|
|
@JsonValue('DESC')
|
|
desc,
|
|
@JsonValue('ARTEMIS_UNKNOWN')
|
|
artemisUnknown,
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class LoginArguments extends JsonSerializable with EquatableMixin {
|
|
LoginArguments({@required this.user, @required this.password, this.deviceID});
|
|
|
|
@override
|
|
factory LoginArguments.fromJson(Map<String, dynamic> json) =>
|
|
_$LoginArgumentsFromJson(json);
|
|
|
|
final String user;
|
|
|
|
final String password;
|
|
|
|
final String deviceID;
|
|
|
|
@override
|
|
List<Object> get props => [user, password, deviceID];
|
|
@override
|
|
Map<String, dynamic> toJson() => _$LoginArgumentsToJson(this);
|
|
}
|
|
|
|
class LoginQuery extends GraphQLQuery<Login$Query, LoginArguments> {
|
|
LoginQuery({this.variables});
|
|
|
|
@override
|
|
final DocumentNode document = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.query,
|
|
name: NameNode(value: 'login'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'user')),
|
|
type: NamedTypeNode(
|
|
name: NameNode(value: 'String'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: []),
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'password')),
|
|
type: NamedTypeNode(
|
|
name: NameNode(value: 'String'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: []),
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'deviceID')),
|
|
type:
|
|
NamedTypeNode(name: NameNode(value: 'ID'), isNonNull: false),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'login'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'user'),
|
|
value: VariableNode(name: NameNode(value: 'user'))),
|
|
ArgumentNode(
|
|
name: NameNode(value: 'password'),
|
|
value: VariableNode(name: NameNode(value: 'password'))),
|
|
ArgumentNode(
|
|
name: NameNode(value: 'deviceID'),
|
|
value: VariableNode(name: NameNode(value: 'deviceID')))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'result'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'device'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'id'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
]))
|
|
]))
|
|
]))
|
|
]);
|
|
|
|
@override
|
|
final String operationName = 'login';
|
|
|
|
@override
|
|
final LoginArguments variables;
|
|
|
|
@override
|
|
List<Object> get props => [document, operationName, variables];
|
|
@override
|
|
Login$Query parse(Map<String, dynamic> json) => Login$Query.fromJson(json);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class CreateMediaItemArguments extends JsonSerializable with EquatableMixin {
|
|
CreateMediaItemArguments({@required this.file});
|
|
|
|
@override
|
|
factory CreateMediaItemArguments.fromJson(Map<String, dynamic> json) =>
|
|
_$CreateMediaItemArgumentsFromJson(json);
|
|
|
|
@JsonKey(
|
|
fromJson: fromGraphQLUploadToDartMultipartFile,
|
|
toJson: fromDartMultipartFileToGraphQLUpload)
|
|
final MultipartFile file;
|
|
|
|
@override
|
|
List<Object> get props => [file];
|
|
@override
|
|
Map<String, dynamic> toJson() => _$CreateMediaItemArgumentsToJson(this);
|
|
}
|
|
|
|
class CreateMediaItemMutation
|
|
extends GraphQLQuery<CreateMediaItem$Mutation, CreateMediaItemArguments> {
|
|
CreateMediaItemMutation({this.variables});
|
|
|
|
@override
|
|
final DocumentNode document = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.mutation,
|
|
name: NameNode(value: 'createMediaItem'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'file')),
|
|
type: NamedTypeNode(
|
|
name: NameNode(value: 'Upload'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'createMediaItem'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'input'),
|
|
value: ObjectValueNode(fields: [
|
|
ObjectFieldNode(
|
|
name: NameNode(value: 'file'),
|
|
value: VariableNode(name: NameNode(value: 'file')))
|
|
]))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'id'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'createdAt'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'updatedAt'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'exifDate'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'latitude'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'longitude'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'isVideo'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'fileName'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'origName'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'userID'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
]))
|
|
]))
|
|
]);
|
|
|
|
@override
|
|
final String operationName = 'createMediaItem';
|
|
|
|
@override
|
|
final CreateMediaItemArguments variables;
|
|
|
|
@override
|
|
List<Object> get props => [document, operationName, variables];
|
|
@override
|
|
CreateMediaItem$Mutation parse(Map<String, dynamic> json) =>
|
|
CreateMediaItem$Mutation.fromJson(json);
|
|
}
|
|
|
|
class MeQuery extends GraphQLQuery<Me$Query, JsonSerializable> {
|
|
MeQuery();
|
|
|
|
@override
|
|
final DocumentNode document = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.query,
|
|
name: NameNode(value: 'me'),
|
|
variableDefinitions: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'me'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'id'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'createdAt'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'updatedAt'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'email'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'username'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'firstName'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'lastName'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'role'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'authType'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
]))
|
|
]))
|
|
]);
|
|
|
|
@override
|
|
final String operationName = 'me';
|
|
|
|
@override
|
|
List<Object> get props => [document, operationName];
|
|
@override
|
|
Me$Query parse(Map<String, dynamic> json) => Me$Query.fromJson(json);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class MediaItemsArguments extends JsonSerializable with EquatableMixin {
|
|
MediaItemsArguments({this.order, this.page, this.filter});
|
|
|
|
@override
|
|
factory MediaItemsArguments.fromJson(Map<String, dynamic> json) =>
|
|
_$MediaItemsArgumentsFromJson(json);
|
|
|
|
final Order order;
|
|
|
|
final Page page;
|
|
|
|
final MediaItemFilter filter;
|
|
|
|
@override
|
|
List<Object> get props => [order, page, filter];
|
|
@override
|
|
Map<String, dynamic> toJson() => _$MediaItemsArgumentsToJson(this);
|
|
}
|
|
|
|
class MediaItemsQuery
|
|
extends GraphQLQuery<MediaItems$Query, MediaItemsArguments> {
|
|
MediaItemsQuery({this.variables});
|
|
|
|
@override
|
|
final DocumentNode document = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.query,
|
|
name: NameNode(value: 'mediaItems'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'order')),
|
|
type: NamedTypeNode(
|
|
name: NameNode(value: 'Order'), isNonNull: false),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: []),
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'page')),
|
|
type: NamedTypeNode(
|
|
name: NameNode(value: 'Page'), isNonNull: false),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: []),
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'filter')),
|
|
type: NamedTypeNode(
|
|
name: NameNode(value: 'MediaItemFilter'), isNonNull: false),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'mediaItems'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'filter'),
|
|
value: VariableNode(name: NameNode(value: 'filter'))),
|
|
ArgumentNode(
|
|
name: NameNode(value: 'page'),
|
|
value: VariableNode(name: NameNode(value: 'page'))),
|
|
ArgumentNode(
|
|
name: NameNode(value: 'order'),
|
|
value: VariableNode(name: NameNode(value: 'order')))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'data'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'id'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'fileName'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'latitude'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'longitude'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'isVideo'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'origName'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'createdAt'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: 'page'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'size'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'page'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'total'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
]))
|
|
]))
|
|
]))
|
|
]);
|
|
|
|
@override
|
|
final String operationName = 'mediaItems';
|
|
|
|
@override
|
|
final MediaItemsArguments variables;
|
|
|
|
@override
|
|
List<Object> get props => [document, operationName, variables];
|
|
@override
|
|
MediaItems$Query parse(Map<String, dynamic> json) =>
|
|
MediaItems$Query.fromJson(json);
|
|
}
|