mirror of
https://github.com/immich-app/immich.git
synced 2025-10-27 00:44:34 -04:00
1686 lines
47 KiB
Dart
Generated
1686 lines
47 KiB
Dart
Generated
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'user.dart';
|
|
|
|
// **************************************************************************
|
|
// IsarCollectionGenerator
|
|
// **************************************************************************
|
|
|
|
// coverage:ignore-file
|
|
// ignore_for_file: duplicate_ignore, non_constant_identifier_names, constant_identifier_names, invalid_use_of_protected_member, unnecessary_cast, prefer_const_constructors, lines_longer_than_80_chars, require_trailing_commas, inference_failure_on_function_invocation, unnecessary_parenthesis, unnecessary_raw_strings, unnecessary_null_checks, join_return_with_assignment, prefer_final_locals, avoid_js_rounded_ints, avoid_positional_boolean_parameters, always_specify_types
|
|
|
|
extension GetUserCollection on Isar {
|
|
IsarCollection<User> get users => this.collection();
|
|
}
|
|
|
|
const UserSchema = CollectionSchema(
|
|
name: r'User',
|
|
id: -7838171048429979076,
|
|
properties: {
|
|
r'avatarColor': PropertySchema(
|
|
id: 0,
|
|
name: r'avatarColor',
|
|
type: IsarType.byte,
|
|
enumMap: _UseravatarColorEnumValueMap,
|
|
),
|
|
r'email': PropertySchema(
|
|
id: 1,
|
|
name: r'email',
|
|
type: IsarType.string,
|
|
),
|
|
r'id': PropertySchema(
|
|
id: 2,
|
|
name: r'id',
|
|
type: IsarType.string,
|
|
),
|
|
r'inTimeline': PropertySchema(
|
|
id: 3,
|
|
name: r'inTimeline',
|
|
type: IsarType.bool,
|
|
),
|
|
r'isAdmin': PropertySchema(
|
|
id: 4,
|
|
name: r'isAdmin',
|
|
type: IsarType.bool,
|
|
),
|
|
r'isPartnerSharedBy': PropertySchema(
|
|
id: 5,
|
|
name: r'isPartnerSharedBy',
|
|
type: IsarType.bool,
|
|
),
|
|
r'isPartnerSharedWith': PropertySchema(
|
|
id: 6,
|
|
name: r'isPartnerSharedWith',
|
|
type: IsarType.bool,
|
|
),
|
|
r'memoryEnabled': PropertySchema(
|
|
id: 7,
|
|
name: r'memoryEnabled',
|
|
type: IsarType.bool,
|
|
),
|
|
r'name': PropertySchema(
|
|
id: 8,
|
|
name: r'name',
|
|
type: IsarType.string,
|
|
),
|
|
r'profileImagePath': PropertySchema(
|
|
id: 9,
|
|
name: r'profileImagePath',
|
|
type: IsarType.string,
|
|
),
|
|
r'updatedAt': PropertySchema(
|
|
id: 10,
|
|
name: r'updatedAt',
|
|
type: IsarType.dateTime,
|
|
)
|
|
},
|
|
estimateSize: _userEstimateSize,
|
|
serialize: _userSerialize,
|
|
deserialize: _userDeserialize,
|
|
deserializeProp: _userDeserializeProp,
|
|
idName: r'isarId',
|
|
indexes: {
|
|
r'id': IndexSchema(
|
|
id: -3268401673993471357,
|
|
name: r'id',
|
|
unique: true,
|
|
replace: false,
|
|
properties: [
|
|
IndexPropertySchema(
|
|
name: r'id',
|
|
type: IndexType.hash,
|
|
caseSensitive: true,
|
|
)
|
|
],
|
|
)
|
|
},
|
|
links: {
|
|
r'albums': LinkSchema(
|
|
id: -8764917375410137318,
|
|
name: r'albums',
|
|
target: r'Album',
|
|
single: false,
|
|
linkName: r'owner',
|
|
),
|
|
r'sharedAlbums': LinkSchema(
|
|
id: -7037628715076287024,
|
|
name: r'sharedAlbums',
|
|
target: r'Album',
|
|
single: false,
|
|
linkName: r'sharedUsers',
|
|
)
|
|
},
|
|
embeddedSchemas: {},
|
|
getId: _userGetId,
|
|
getLinks: _userGetLinks,
|
|
attach: _userAttach,
|
|
version: '3.1.0+1',
|
|
);
|
|
|
|
int _userEstimateSize(
|
|
User object,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
var bytesCount = offsets.last;
|
|
bytesCount += 3 + object.email.length * 3;
|
|
bytesCount += 3 + object.id.length * 3;
|
|
bytesCount += 3 + object.name.length * 3;
|
|
bytesCount += 3 + object.profileImagePath.length * 3;
|
|
return bytesCount;
|
|
}
|
|
|
|
void _userSerialize(
|
|
User object,
|
|
IsarWriter writer,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
writer.writeByte(offsets[0], object.avatarColor.index);
|
|
writer.writeString(offsets[1], object.email);
|
|
writer.writeString(offsets[2], object.id);
|
|
writer.writeBool(offsets[3], object.inTimeline);
|
|
writer.writeBool(offsets[4], object.isAdmin);
|
|
writer.writeBool(offsets[5], object.isPartnerSharedBy);
|
|
writer.writeBool(offsets[6], object.isPartnerSharedWith);
|
|
writer.writeBool(offsets[7], object.memoryEnabled);
|
|
writer.writeString(offsets[8], object.name);
|
|
writer.writeString(offsets[9], object.profileImagePath);
|
|
writer.writeDateTime(offsets[10], object.updatedAt);
|
|
}
|
|
|
|
User _userDeserialize(
|
|
Id id,
|
|
IsarReader reader,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
final object = User(
|
|
avatarColor:
|
|
_UseravatarColorValueEnumMap[reader.readByteOrNull(offsets[0])] ??
|
|
AvatarColorEnum.primary,
|
|
email: reader.readString(offsets[1]),
|
|
id: reader.readString(offsets[2]),
|
|
inTimeline: reader.readBoolOrNull(offsets[3]) ?? false,
|
|
isAdmin: reader.readBool(offsets[4]),
|
|
isPartnerSharedBy: reader.readBoolOrNull(offsets[5]) ?? false,
|
|
isPartnerSharedWith: reader.readBoolOrNull(offsets[6]) ?? false,
|
|
memoryEnabled: reader.readBoolOrNull(offsets[7]) ?? true,
|
|
name: reader.readString(offsets[8]),
|
|
profileImagePath: reader.readStringOrNull(offsets[9]) ?? '',
|
|
updatedAt: reader.readDateTime(offsets[10]),
|
|
);
|
|
return object;
|
|
}
|
|
|
|
P _userDeserializeProp<P>(
|
|
IsarReader reader,
|
|
int propertyId,
|
|
int offset,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
switch (propertyId) {
|
|
case 0:
|
|
return (_UseravatarColorValueEnumMap[reader.readByteOrNull(offset)] ??
|
|
AvatarColorEnum.primary) as P;
|
|
case 1:
|
|
return (reader.readString(offset)) as P;
|
|
case 2:
|
|
return (reader.readString(offset)) as P;
|
|
case 3:
|
|
return (reader.readBoolOrNull(offset) ?? false) as P;
|
|
case 4:
|
|
return (reader.readBool(offset)) as P;
|
|
case 5:
|
|
return (reader.readBoolOrNull(offset) ?? false) as P;
|
|
case 6:
|
|
return (reader.readBoolOrNull(offset) ?? false) as P;
|
|
case 7:
|
|
return (reader.readBoolOrNull(offset) ?? true) as P;
|
|
case 8:
|
|
return (reader.readString(offset)) as P;
|
|
case 9:
|
|
return (reader.readStringOrNull(offset) ?? '') as P;
|
|
case 10:
|
|
return (reader.readDateTime(offset)) as P;
|
|
default:
|
|
throw IsarError('Unknown property with id $propertyId');
|
|
}
|
|
}
|
|
|
|
const _UseravatarColorEnumValueMap = {
|
|
'primary': 0,
|
|
'pink': 1,
|
|
'red': 2,
|
|
'yellow': 3,
|
|
'blue': 4,
|
|
'green': 5,
|
|
'purple': 6,
|
|
'orange': 7,
|
|
'gray': 8,
|
|
'amber': 9,
|
|
};
|
|
const _UseravatarColorValueEnumMap = {
|
|
0: AvatarColorEnum.primary,
|
|
1: AvatarColorEnum.pink,
|
|
2: AvatarColorEnum.red,
|
|
3: AvatarColorEnum.yellow,
|
|
4: AvatarColorEnum.blue,
|
|
5: AvatarColorEnum.green,
|
|
6: AvatarColorEnum.purple,
|
|
7: AvatarColorEnum.orange,
|
|
8: AvatarColorEnum.gray,
|
|
9: AvatarColorEnum.amber,
|
|
};
|
|
|
|
Id _userGetId(User object) {
|
|
return object.isarId;
|
|
}
|
|
|
|
List<IsarLinkBase<dynamic>> _userGetLinks(User object) {
|
|
return [object.albums, object.sharedAlbums];
|
|
}
|
|
|
|
void _userAttach(IsarCollection<dynamic> col, Id id, User object) {
|
|
object.albums.attach(col, col.isar.collection<Album>(), r'albums', id);
|
|
object.sharedAlbums
|
|
.attach(col, col.isar.collection<Album>(), r'sharedAlbums', id);
|
|
}
|
|
|
|
extension UserByIndex on IsarCollection<User> {
|
|
Future<User?> getById(String id) {
|
|
return getByIndex(r'id', [id]);
|
|
}
|
|
|
|
User? getByIdSync(String id) {
|
|
return getByIndexSync(r'id', [id]);
|
|
}
|
|
|
|
Future<bool> deleteById(String id) {
|
|
return deleteByIndex(r'id', [id]);
|
|
}
|
|
|
|
bool deleteByIdSync(String id) {
|
|
return deleteByIndexSync(r'id', [id]);
|
|
}
|
|
|
|
Future<List<User?>> getAllById(List<String> idValues) {
|
|
final values = idValues.map((e) => [e]).toList();
|
|
return getAllByIndex(r'id', values);
|
|
}
|
|
|
|
List<User?> getAllByIdSync(List<String> idValues) {
|
|
final values = idValues.map((e) => [e]).toList();
|
|
return getAllByIndexSync(r'id', values);
|
|
}
|
|
|
|
Future<int> deleteAllById(List<String> idValues) {
|
|
final values = idValues.map((e) => [e]).toList();
|
|
return deleteAllByIndex(r'id', values);
|
|
}
|
|
|
|
int deleteAllByIdSync(List<String> idValues) {
|
|
final values = idValues.map((e) => [e]).toList();
|
|
return deleteAllByIndexSync(r'id', values);
|
|
}
|
|
|
|
Future<Id> putById(User object) {
|
|
return putByIndex(r'id', object);
|
|
}
|
|
|
|
Id putByIdSync(User object, {bool saveLinks = true}) {
|
|
return putByIndexSync(r'id', object, saveLinks: saveLinks);
|
|
}
|
|
|
|
Future<List<Id>> putAllById(List<User> objects) {
|
|
return putAllByIndex(r'id', objects);
|
|
}
|
|
|
|
List<Id> putAllByIdSync(List<User> objects, {bool saveLinks = true}) {
|
|
return putAllByIndexSync(r'id', objects, saveLinks: saveLinks);
|
|
}
|
|
}
|
|
|
|
extension UserQueryWhereSort on QueryBuilder<User, User, QWhere> {
|
|
QueryBuilder<User, User, QAfterWhere> anyIsarId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(const IdWhereClause.any());
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserQueryWhere on QueryBuilder<User, User, QWhereClause> {
|
|
QueryBuilder<User, User, QAfterWhereClause> isarIdEqualTo(Id isarId) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: isarId,
|
|
upper: isarId,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterWhereClause> isarIdNotEqualTo(Id isarId) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(
|
|
IdWhereClause.lessThan(upper: isarId, includeUpper: false),
|
|
)
|
|
.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: isarId, includeLower: false),
|
|
);
|
|
} else {
|
|
return query
|
|
.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: isarId, includeLower: false),
|
|
)
|
|
.addWhereClause(
|
|
IdWhereClause.lessThan(upper: isarId, includeUpper: false),
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterWhereClause> isarIdGreaterThan(Id isarId,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: isarId, includeLower: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterWhereClause> isarIdLessThan(Id isarId,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.lessThan(upper: isarId, includeUpper: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterWhereClause> isarIdBetween(
|
|
Id lowerIsarId,
|
|
Id upperIsarId, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: lowerIsarId,
|
|
includeLower: includeLower,
|
|
upper: upperIsarId,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterWhereClause> idEqualTo(String id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'id',
|
|
value: [id],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterWhereClause> idNotEqualTo(String id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'id',
|
|
lower: [],
|
|
upper: [id],
|
|
includeUpper: false,
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'id',
|
|
lower: [id],
|
|
includeLower: false,
|
|
upper: [],
|
|
));
|
|
} else {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'id',
|
|
lower: [id],
|
|
includeLower: false,
|
|
upper: [],
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'id',
|
|
lower: [],
|
|
upper: [id],
|
|
includeUpper: false,
|
|
));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserQueryFilter on QueryBuilder<User, User, QFilterCondition> {
|
|
QueryBuilder<User, User, QAfterFilterCondition> avatarColorEqualTo(
|
|
AvatarColorEnum value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'avatarColor',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> avatarColorGreaterThan(
|
|
AvatarColorEnum value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'avatarColor',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> avatarColorLessThan(
|
|
AvatarColorEnum value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'avatarColor',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> avatarColorBetween(
|
|
AvatarColorEnum lower,
|
|
AvatarColorEnum upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'avatarColor',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'email',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'email',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'email',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailBetween(
|
|
String lower,
|
|
String upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'email',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'email',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'email',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailContains(String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'email',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailMatches(String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'email',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'email',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> emailIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'email',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'id',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'id',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'id',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idBetween(
|
|
String lower,
|
|
String upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'id',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'id',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'id',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idContains(String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'id',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idMatches(String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'id',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'id',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> idIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'id',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> inTimelineEqualTo(
|
|
bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'inTimeline',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> isAdminEqualTo(bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'isAdmin',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> isPartnerSharedByEqualTo(
|
|
bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'isPartnerSharedBy',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> isPartnerSharedWithEqualTo(
|
|
bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'isPartnerSharedWith',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> isarIdEqualTo(Id value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'isarId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> isarIdGreaterThan(
|
|
Id value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'isarId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> isarIdLessThan(
|
|
Id value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'isarId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> isarIdBetween(
|
|
Id lower,
|
|
Id upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'isarId',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> memoryEnabledEqualTo(
|
|
bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'memoryEnabled',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameBetween(
|
|
String lower,
|
|
String upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'name',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameContains(String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameMatches(String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'name',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'name',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> nameIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'name',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'profileImagePath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'profileImagePath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'profileImagePath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathBetween(
|
|
String lower,
|
|
String upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'profileImagePath',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'profileImagePath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'profileImagePath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathContains(
|
|
String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'profileImagePath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathMatches(
|
|
String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'profileImagePath',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'profileImagePath',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> profileImagePathIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'profileImagePath',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> updatedAtEqualTo(
|
|
DateTime value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'updatedAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> updatedAtGreaterThan(
|
|
DateTime value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'updatedAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> updatedAtLessThan(
|
|
DateTime value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'updatedAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> updatedAtBetween(
|
|
DateTime lower,
|
|
DateTime upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'updatedAt',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserQueryObject on QueryBuilder<User, User, QFilterCondition> {}
|
|
|
|
extension UserQueryLinks on QueryBuilder<User, User, QFilterCondition> {
|
|
QueryBuilder<User, User, QAfterFilterCondition> albums(FilterQuery<Album> q) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.link(q, r'albums');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> albumsLengthEqualTo(
|
|
int length) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'albums', length, true, length, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> albumsIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'albums', 0, true, 0, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> albumsIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'albums', 0, false, 999999, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> albumsLengthLessThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'albums', 0, true, length, include);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> albumsLengthGreaterThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'albums', length, include, 999999, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> albumsLengthBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(
|
|
r'albums', lower, includeLower, upper, includeUpper);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> sharedAlbums(
|
|
FilterQuery<Album> q) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.link(q, r'sharedAlbums');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> sharedAlbumsLengthEqualTo(
|
|
int length) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'sharedAlbums', length, true, length, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> sharedAlbumsIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'sharedAlbums', 0, true, 0, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> sharedAlbumsIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'sharedAlbums', 0, false, 999999, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> sharedAlbumsLengthLessThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'sharedAlbums', 0, true, length, include);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> sharedAlbumsLengthGreaterThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'sharedAlbums', length, include, 999999, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterFilterCondition> sharedAlbumsLengthBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(
|
|
r'sharedAlbums', lower, includeLower, upper, includeUpper);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserQuerySortBy on QueryBuilder<User, User, QSortBy> {
|
|
QueryBuilder<User, User, QAfterSortBy> sortByAvatarColor() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarColor', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByAvatarColorDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarColor', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByEmail() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'email', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByEmailDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'email', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortById() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByInTimeline() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'inTimeline', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByInTimelineDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'inTimeline', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByIsAdmin() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isAdmin', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByIsAdminDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isAdmin', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByIsPartnerSharedBy() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isPartnerSharedBy', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByIsPartnerSharedByDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isPartnerSharedBy', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByIsPartnerSharedWith() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isPartnerSharedWith', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByIsPartnerSharedWithDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isPartnerSharedWith', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByMemoryEnabled() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'memoryEnabled', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByMemoryEnabledDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'memoryEnabled', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByProfileImagePath() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'profileImagePath', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByProfileImagePathDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'profileImagePath', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> sortByUpdatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserQuerySortThenBy on QueryBuilder<User, User, QSortThenBy> {
|
|
QueryBuilder<User, User, QAfterSortBy> thenByAvatarColor() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarColor', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByAvatarColorDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarColor', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByEmail() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'email', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByEmailDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'email', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenById() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByInTimeline() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'inTimeline', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByInTimelineDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'inTimeline', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIsAdmin() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isAdmin', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIsAdminDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isAdmin', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIsPartnerSharedBy() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isPartnerSharedBy', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIsPartnerSharedByDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isPartnerSharedBy', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIsPartnerSharedWith() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isPartnerSharedWith', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIsPartnerSharedWithDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isPartnerSharedWith', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIsarId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isarId', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByIsarIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isarId', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByMemoryEnabled() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'memoryEnabled', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByMemoryEnabledDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'memoryEnabled', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByProfileImagePath() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'profileImagePath', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByProfileImagePathDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'profileImagePath', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QAfterSortBy> thenByUpdatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserQueryWhereDistinct on QueryBuilder<User, User, QDistinct> {
|
|
QueryBuilder<User, User, QDistinct> distinctByAvatarColor() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'avatarColor');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByEmail(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'email', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctById(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'id', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByInTimeline() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'inTimeline');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByIsAdmin() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'isAdmin');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByIsPartnerSharedBy() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'isPartnerSharedBy');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByIsPartnerSharedWith() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'isPartnerSharedWith');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByMemoryEnabled() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'memoryEnabled');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByName(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByProfileImagePath(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'profileImagePath',
|
|
caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, User, QDistinct> distinctByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'updatedAt');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserQueryProperty on QueryBuilder<User, User, QQueryProperty> {
|
|
QueryBuilder<User, int, QQueryOperations> isarIdProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'isarId');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, AvatarColorEnum, QQueryOperations> avatarColorProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'avatarColor');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, String, QQueryOperations> emailProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'email');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, String, QQueryOperations> idProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'id');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, bool, QQueryOperations> inTimelineProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'inTimeline');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, bool, QQueryOperations> isAdminProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'isAdmin');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, bool, QQueryOperations> isPartnerSharedByProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'isPartnerSharedBy');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, bool, QQueryOperations> isPartnerSharedWithProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'isPartnerSharedWith');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, bool, QQueryOperations> memoryEnabledProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'memoryEnabled');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, String, QQueryOperations> nameProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'name');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, String, QQueryOperations> profileImagePathProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'profileImagePath');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<User, DateTime, QQueryOperations> updatedAtProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'updatedAt');
|
|
});
|
|
}
|
|
}
|