1753 lines
50 KiB
Dart
1753 lines
50 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'user_profile.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 GetUserProfileCollection on Isar {
|
|
IsarCollection<UserProfile> get userProfiles => this.collection();
|
|
}
|
|
|
|
const UserProfileSchema = CollectionSchema(
|
|
name: r'UserProfile',
|
|
id: 4738427352541298891,
|
|
properties: {
|
|
r'avatarAssetPath': PropertySchema(
|
|
id: 0,
|
|
name: r'avatarAssetPath',
|
|
type: IsarType.string,
|
|
),
|
|
r'avatarLocalPath': PropertySchema(
|
|
id: 1,
|
|
name: r'avatarLocalPath',
|
|
type: IsarType.string,
|
|
),
|
|
r'avatarSource': PropertySchema(
|
|
id: 2,
|
|
name: r'avatarSource',
|
|
type: IsarType.byte,
|
|
enumMap: _UserProfileavatarSourceEnumValueMap,
|
|
),
|
|
r'createdAt': PropertySchema(
|
|
id: 3,
|
|
name: r'createdAt',
|
|
type: IsarType.dateTime,
|
|
),
|
|
r'displayAvatarPath': PropertySchema(
|
|
id: 4,
|
|
name: r'displayAvatarPath',
|
|
type: IsarType.string,
|
|
),
|
|
r'nickname': PropertySchema(
|
|
id: 5,
|
|
name: r'nickname',
|
|
type: IsarType.string,
|
|
),
|
|
r'profileKey': PropertySchema(
|
|
id: 6,
|
|
name: r'profileKey',
|
|
type: IsarType.string,
|
|
),
|
|
r'updatedAt': PropertySchema(
|
|
id: 7,
|
|
name: r'updatedAt',
|
|
type: IsarType.dateTime,
|
|
)
|
|
},
|
|
estimateSize: _userProfileEstimateSize,
|
|
serialize: _userProfileSerialize,
|
|
deserialize: _userProfileDeserialize,
|
|
deserializeProp: _userProfileDeserializeProp,
|
|
idName: r'id',
|
|
indexes: {
|
|
r'profileKey': IndexSchema(
|
|
id: 5036140583920489520,
|
|
name: r'profileKey',
|
|
unique: true,
|
|
replace: true,
|
|
properties: [
|
|
IndexPropertySchema(
|
|
name: r'profileKey',
|
|
type: IndexType.hash,
|
|
caseSensitive: true,
|
|
)
|
|
],
|
|
),
|
|
r'updatedAt': IndexSchema(
|
|
id: -6238191080293565125,
|
|
name: r'updatedAt',
|
|
unique: false,
|
|
replace: false,
|
|
properties: [
|
|
IndexPropertySchema(
|
|
name: r'updatedAt',
|
|
type: IndexType.value,
|
|
caseSensitive: false,
|
|
)
|
|
],
|
|
)
|
|
},
|
|
links: {},
|
|
embeddedSchemas: {},
|
|
getId: _userProfileGetId,
|
|
getLinks: _userProfileGetLinks,
|
|
attach: _userProfileAttach,
|
|
version: '3.1.0+1',
|
|
);
|
|
|
|
int _userProfileEstimateSize(
|
|
UserProfile object,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
var bytesCount = offsets.last;
|
|
bytesCount += 3 + object.avatarAssetPath.length * 3;
|
|
{
|
|
final value = object.avatarLocalPath;
|
|
if (value != null) {
|
|
bytesCount += 3 + value.length * 3;
|
|
}
|
|
}
|
|
bytesCount += 3 + object.displayAvatarPath.length * 3;
|
|
bytesCount += 3 + object.nickname.length * 3;
|
|
bytesCount += 3 + object.profileKey.length * 3;
|
|
return bytesCount;
|
|
}
|
|
|
|
void _userProfileSerialize(
|
|
UserProfile object,
|
|
IsarWriter writer,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
writer.writeString(offsets[0], object.avatarAssetPath);
|
|
writer.writeString(offsets[1], object.avatarLocalPath);
|
|
writer.writeByte(offsets[2], object.avatarSource.index);
|
|
writer.writeDateTime(offsets[3], object.createdAt);
|
|
writer.writeString(offsets[4], object.displayAvatarPath);
|
|
writer.writeString(offsets[5], object.nickname);
|
|
writer.writeString(offsets[6], object.profileKey);
|
|
writer.writeDateTime(offsets[7], object.updatedAt);
|
|
}
|
|
|
|
UserProfile _userProfileDeserialize(
|
|
Id id,
|
|
IsarReader reader,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
final object = UserProfile();
|
|
object.avatarAssetPath = reader.readString(offsets[0]);
|
|
object.avatarLocalPath = reader.readStringOrNull(offsets[1]);
|
|
object.avatarSource =
|
|
_UserProfileavatarSourceValueEnumMap[reader.readByteOrNull(offsets[2])] ??
|
|
AvatarSource.asset;
|
|
object.createdAt = reader.readDateTime(offsets[3]);
|
|
object.id = id;
|
|
object.nickname = reader.readString(offsets[5]);
|
|
object.profileKey = reader.readString(offsets[6]);
|
|
object.updatedAt = reader.readDateTime(offsets[7]);
|
|
return object;
|
|
}
|
|
|
|
P _userProfileDeserializeProp<P>(
|
|
IsarReader reader,
|
|
int propertyId,
|
|
int offset,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
switch (propertyId) {
|
|
case 0:
|
|
return (reader.readString(offset)) as P;
|
|
case 1:
|
|
return (reader.readStringOrNull(offset)) as P;
|
|
case 2:
|
|
return (_UserProfileavatarSourceValueEnumMap[
|
|
reader.readByteOrNull(offset)] ??
|
|
AvatarSource.asset) as P;
|
|
case 3:
|
|
return (reader.readDateTime(offset)) as P;
|
|
case 4:
|
|
return (reader.readString(offset)) as P;
|
|
case 5:
|
|
return (reader.readString(offset)) as P;
|
|
case 6:
|
|
return (reader.readString(offset)) as P;
|
|
case 7:
|
|
return (reader.readDateTime(offset)) as P;
|
|
default:
|
|
throw IsarError('Unknown property with id $propertyId');
|
|
}
|
|
}
|
|
|
|
const _UserProfileavatarSourceEnumValueMap = {
|
|
'asset': 0,
|
|
'localFile': 1,
|
|
};
|
|
const _UserProfileavatarSourceValueEnumMap = {
|
|
0: AvatarSource.asset,
|
|
1: AvatarSource.localFile,
|
|
};
|
|
|
|
Id _userProfileGetId(UserProfile object) {
|
|
return object.id;
|
|
}
|
|
|
|
List<IsarLinkBase<dynamic>> _userProfileGetLinks(UserProfile object) {
|
|
return [];
|
|
}
|
|
|
|
void _userProfileAttach(
|
|
IsarCollection<dynamic> col, Id id, UserProfile object) {
|
|
object.id = id;
|
|
}
|
|
|
|
extension UserProfileByIndex on IsarCollection<UserProfile> {
|
|
Future<UserProfile?> getByProfileKey(String profileKey) {
|
|
return getByIndex(r'profileKey', [profileKey]);
|
|
}
|
|
|
|
UserProfile? getByProfileKeySync(String profileKey) {
|
|
return getByIndexSync(r'profileKey', [profileKey]);
|
|
}
|
|
|
|
Future<bool> deleteByProfileKey(String profileKey) {
|
|
return deleteByIndex(r'profileKey', [profileKey]);
|
|
}
|
|
|
|
bool deleteByProfileKeySync(String profileKey) {
|
|
return deleteByIndexSync(r'profileKey', [profileKey]);
|
|
}
|
|
|
|
Future<List<UserProfile?>> getAllByProfileKey(List<String> profileKeyValues) {
|
|
final values = profileKeyValues.map((e) => [e]).toList();
|
|
return getAllByIndex(r'profileKey', values);
|
|
}
|
|
|
|
List<UserProfile?> getAllByProfileKeySync(List<String> profileKeyValues) {
|
|
final values = profileKeyValues.map((e) => [e]).toList();
|
|
return getAllByIndexSync(r'profileKey', values);
|
|
}
|
|
|
|
Future<int> deleteAllByProfileKey(List<String> profileKeyValues) {
|
|
final values = profileKeyValues.map((e) => [e]).toList();
|
|
return deleteAllByIndex(r'profileKey', values);
|
|
}
|
|
|
|
int deleteAllByProfileKeySync(List<String> profileKeyValues) {
|
|
final values = profileKeyValues.map((e) => [e]).toList();
|
|
return deleteAllByIndexSync(r'profileKey', values);
|
|
}
|
|
|
|
Future<Id> putByProfileKey(UserProfile object) {
|
|
return putByIndex(r'profileKey', object);
|
|
}
|
|
|
|
Id putByProfileKeySync(UserProfile object, {bool saveLinks = true}) {
|
|
return putByIndexSync(r'profileKey', object, saveLinks: saveLinks);
|
|
}
|
|
|
|
Future<List<Id>> putAllByProfileKey(List<UserProfile> objects) {
|
|
return putAllByIndex(r'profileKey', objects);
|
|
}
|
|
|
|
List<Id> putAllByProfileKeySync(List<UserProfile> objects,
|
|
{bool saveLinks = true}) {
|
|
return putAllByIndexSync(r'profileKey', objects, saveLinks: saveLinks);
|
|
}
|
|
}
|
|
|
|
extension UserProfileQueryWhereSort
|
|
on QueryBuilder<UserProfile, UserProfile, QWhere> {
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhere> anyId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(const IdWhereClause.any());
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhere> anyUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
const IndexWhereClause.any(indexName: r'updatedAt'),
|
|
);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserProfileQueryWhere
|
|
on QueryBuilder<UserProfile, UserProfile, QWhereClause> {
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> idEqualTo(Id id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: id,
|
|
upper: id,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> idNotEqualTo(
|
|
Id id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: false),
|
|
)
|
|
.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: false),
|
|
);
|
|
} else {
|
|
return query
|
|
.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: false),
|
|
)
|
|
.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: false),
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> idGreaterThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> idLessThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> idBetween(
|
|
Id lowerId,
|
|
Id upperId, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: lowerId,
|
|
includeLower: includeLower,
|
|
upper: upperId,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> profileKeyEqualTo(
|
|
String profileKey) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'profileKey',
|
|
value: [profileKey],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause>
|
|
profileKeyNotEqualTo(String profileKey) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'profileKey',
|
|
lower: [],
|
|
upper: [profileKey],
|
|
includeUpper: false,
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'profileKey',
|
|
lower: [profileKey],
|
|
includeLower: false,
|
|
upper: [],
|
|
));
|
|
} else {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'profileKey',
|
|
lower: [profileKey],
|
|
includeLower: false,
|
|
upper: [],
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'profileKey',
|
|
lower: [],
|
|
upper: [profileKey],
|
|
includeUpper: false,
|
|
));
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> updatedAtEqualTo(
|
|
DateTime updatedAt) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'updatedAt',
|
|
value: [updatedAt],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> updatedAtNotEqualTo(
|
|
DateTime updatedAt) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'updatedAt',
|
|
lower: [],
|
|
upper: [updatedAt],
|
|
includeUpper: false,
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'updatedAt',
|
|
lower: [updatedAt],
|
|
includeLower: false,
|
|
upper: [],
|
|
));
|
|
} else {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'updatedAt',
|
|
lower: [updatedAt],
|
|
includeLower: false,
|
|
upper: [],
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'updatedAt',
|
|
lower: [],
|
|
upper: [updatedAt],
|
|
includeUpper: false,
|
|
));
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause>
|
|
updatedAtGreaterThan(
|
|
DateTime updatedAt, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'updatedAt',
|
|
lower: [updatedAt],
|
|
includeLower: include,
|
|
upper: [],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> updatedAtLessThan(
|
|
DateTime updatedAt, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'updatedAt',
|
|
lower: [],
|
|
upper: [updatedAt],
|
|
includeUpper: include,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterWhereClause> updatedAtBetween(
|
|
DateTime lowerUpdatedAt,
|
|
DateTime upperUpdatedAt, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'updatedAt',
|
|
lower: [lowerUpdatedAt],
|
|
includeLower: includeLower,
|
|
upper: [upperUpdatedAt],
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserProfileQueryFilter
|
|
on QueryBuilder<UserProfile, UserProfile, QFilterCondition> {
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'avatarAssetPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'avatarAssetPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'avatarAssetPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathBetween(
|
|
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'avatarAssetPath',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'avatarAssetPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'avatarAssetPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathContains(String value, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'avatarAssetPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathMatches(String pattern, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'avatarAssetPath',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'avatarAssetPath',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarAssetPathIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'avatarAssetPath',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'avatarLocalPath',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'avatarLocalPath',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathEqualTo(
|
|
String? value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'avatarLocalPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathGreaterThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'avatarLocalPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathLessThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'avatarLocalPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathBetween(
|
|
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'avatarLocalPath',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'avatarLocalPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'avatarLocalPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathContains(String value, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'avatarLocalPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathMatches(String pattern, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'avatarLocalPath',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'avatarLocalPath',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarLocalPathIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'avatarLocalPath',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarSourceEqualTo(AvatarSource value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'avatarSource',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarSourceGreaterThan(
|
|
AvatarSource value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'avatarSource',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarSourceLessThan(
|
|
AvatarSource value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'avatarSource',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
avatarSourceBetween(
|
|
AvatarSource lower,
|
|
AvatarSource upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'avatarSource',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
createdAtEqualTo(DateTime value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'createdAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
createdAtGreaterThan(
|
|
DateTime value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'createdAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
createdAtLessThan(
|
|
DateTime value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'createdAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
createdAtBetween(
|
|
DateTime lower,
|
|
DateTime upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'createdAt',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'displayAvatarPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'displayAvatarPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'displayAvatarPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathBetween(
|
|
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'displayAvatarPath',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'displayAvatarPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'displayAvatarPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathContains(String value, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'displayAvatarPath',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathMatches(String pattern, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'displayAvatarPath',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'displayAvatarPath',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
displayAvatarPathIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'displayAvatarPath',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition> idEqualTo(
|
|
Id value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition> idGreaterThan(
|
|
Id value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition> idLessThan(
|
|
Id value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition> idBetween(
|
|
Id lower,
|
|
Id upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'id',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition> nicknameEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'nickname',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
nicknameGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'nickname',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
nicknameLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'nickname',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition> nicknameBetween(
|
|
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'nickname',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
nicknameStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'nickname',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
nicknameEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'nickname',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
nicknameContains(String value, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'nickname',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition> nicknameMatches(
|
|
String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'nickname',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
nicknameIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'nickname',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
nicknameIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'nickname',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'profileKey',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'profileKey',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'profileKey',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyBetween(
|
|
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'profileKey',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'profileKey',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'profileKey',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyContains(String value, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'profileKey',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyMatches(String pattern, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'profileKey',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'profileKey',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
profileKeyIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'profileKey',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterFilterCondition>
|
|
updatedAtEqualTo(DateTime value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'updatedAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, 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<UserProfile, UserProfile, 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<UserProfile, UserProfile, 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 UserProfileQueryObject
|
|
on QueryBuilder<UserProfile, UserProfile, QFilterCondition> {}
|
|
|
|
extension UserProfileQueryLinks
|
|
on QueryBuilder<UserProfile, UserProfile, QFilterCondition> {}
|
|
|
|
extension UserProfileQuerySortBy
|
|
on QueryBuilder<UserProfile, UserProfile, QSortBy> {
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByAvatarAssetPath() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarAssetPath', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
sortByAvatarAssetPathDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarAssetPath', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByAvatarLocalPath() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarLocalPath', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
sortByAvatarLocalPathDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarLocalPath', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByAvatarSource() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarSource', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
sortByAvatarSourceDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarSource', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByCreatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'createdAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByCreatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'createdAt', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
sortByDisplayAvatarPath() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'displayAvatarPath', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
sortByDisplayAvatarPathDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'displayAvatarPath', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByNickname() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'nickname', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByNicknameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'nickname', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByProfileKey() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'profileKey', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByProfileKeyDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'profileKey', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> sortByUpdatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserProfileQuerySortThenBy
|
|
on QueryBuilder<UserProfile, UserProfile, QSortThenBy> {
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByAvatarAssetPath() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarAssetPath', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
thenByAvatarAssetPathDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarAssetPath', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByAvatarLocalPath() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarLocalPath', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
thenByAvatarLocalPathDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarLocalPath', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByAvatarSource() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarSource', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
thenByAvatarSourceDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'avatarSource', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByCreatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'createdAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByCreatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'createdAt', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
thenByDisplayAvatarPath() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'displayAvatarPath', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy>
|
|
thenByDisplayAvatarPathDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'displayAvatarPath', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenById() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByNickname() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'nickname', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByNicknameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'nickname', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByProfileKey() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'profileKey', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByProfileKeyDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'profileKey', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QAfterSortBy> thenByUpdatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserProfileQueryWhereDistinct
|
|
on QueryBuilder<UserProfile, UserProfile, QDistinct> {
|
|
QueryBuilder<UserProfile, UserProfile, QDistinct> distinctByAvatarAssetPath(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'avatarAssetPath',
|
|
caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QDistinct> distinctByAvatarLocalPath(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'avatarLocalPath',
|
|
caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QDistinct> distinctByAvatarSource() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'avatarSource');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QDistinct> distinctByCreatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'createdAt');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QDistinct> distinctByDisplayAvatarPath(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'displayAvatarPath',
|
|
caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QDistinct> distinctByNickname(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'nickname', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QDistinct> distinctByProfileKey(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'profileKey', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, UserProfile, QDistinct> distinctByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'updatedAt');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension UserProfileQueryProperty
|
|
on QueryBuilder<UserProfile, UserProfile, QQueryProperty> {
|
|
QueryBuilder<UserProfile, int, QQueryOperations> idProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'id');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, String, QQueryOperations>
|
|
avatarAssetPathProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'avatarAssetPath');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, String?, QQueryOperations>
|
|
avatarLocalPathProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'avatarLocalPath');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, AvatarSource, QQueryOperations>
|
|
avatarSourceProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'avatarSource');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, DateTime, QQueryOperations> createdAtProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'createdAt');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, String, QQueryOperations>
|
|
displayAvatarPathProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'displayAvatarPath');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, String, QQueryOperations> nicknameProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'nickname');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, String, QQueryOperations> profileKeyProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'profileKey');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<UserProfile, DateTime, QQueryOperations> updatedAtProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'updatedAt');
|
|
});
|
|
}
|
|
}
|