3647 lines
100 KiB
Dart
3647 lines
100 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'point_record.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 GetPointRecordCollection on Isar {
|
|
IsarCollection<PointRecord> get pointRecords => this.collection();
|
|
}
|
|
|
|
const PointRecordSchema = CollectionSchema(
|
|
name: r'PointRecord',
|
|
id: 733086018020266618,
|
|
properties: {
|
|
r'arrowsPerEnd': PropertySchema(
|
|
id: 0,
|
|
name: r'arrowsPerEnd',
|
|
type: IsarType.long,
|
|
),
|
|
r'averageScore': PropertySchema(
|
|
id: 1,
|
|
name: r'averageScore',
|
|
type: IsarType.double,
|
|
),
|
|
r'bowName': PropertySchema(
|
|
id: 2,
|
|
name: r'bowName',
|
|
type: IsarType.string,
|
|
),
|
|
r'bowOptionId': PropertySchema(
|
|
id: 3,
|
|
name: r'bowOptionId',
|
|
type: IsarType.long,
|
|
),
|
|
r'completedAt': PropertySchema(
|
|
id: 4,
|
|
name: r'completedAt',
|
|
type: IsarType.dateTime,
|
|
),
|
|
r'createdAt': PropertySchema(
|
|
id: 5,
|
|
name: r'createdAt',
|
|
type: IsarType.dateTime,
|
|
),
|
|
r'distanceMeters': PropertySchema(
|
|
id: 6,
|
|
name: r'distanceMeters',
|
|
type: IsarType.long,
|
|
),
|
|
r'endCount': PropertySchema(
|
|
id: 7,
|
|
name: r'endCount',
|
|
type: IsarType.long,
|
|
),
|
|
r'hitPoints': PropertySchema(
|
|
id: 8,
|
|
name: r'hitPoints',
|
|
type: IsarType.objectList,
|
|
target: r'HitPoint',
|
|
),
|
|
r'isDraft': PropertySchema(
|
|
id: 9,
|
|
name: r'isDraft',
|
|
type: IsarType.bool,
|
|
),
|
|
r'note': PropertySchema(
|
|
id: 10,
|
|
name: r'note',
|
|
type: IsarType.string,
|
|
),
|
|
r'scores': PropertySchema(
|
|
id: 11,
|
|
name: r'scores',
|
|
type: IsarType.longList,
|
|
),
|
|
r'status': PropertySchema(
|
|
id: 12,
|
|
name: r'status',
|
|
type: IsarType.byte,
|
|
enumMap: _PointRecordstatusEnumValueMap,
|
|
),
|
|
r'targetName': PropertySchema(
|
|
id: 13,
|
|
name: r'targetName',
|
|
type: IsarType.string,
|
|
),
|
|
r'targetOptionId': PropertySchema(
|
|
id: 14,
|
|
name: r'targetOptionId',
|
|
type: IsarType.long,
|
|
),
|
|
r'title': PropertySchema(
|
|
id: 15,
|
|
name: r'title',
|
|
type: IsarType.string,
|
|
),
|
|
r'totalArrows': PropertySchema(
|
|
id: 16,
|
|
name: r'totalArrows',
|
|
type: IsarType.long,
|
|
),
|
|
r'totalScore': PropertySchema(
|
|
id: 17,
|
|
name: r'totalScore',
|
|
type: IsarType.long,
|
|
),
|
|
r'updatedAt': PropertySchema(
|
|
id: 18,
|
|
name: r'updatedAt',
|
|
type: IsarType.dateTime,
|
|
)
|
|
},
|
|
estimateSize: _pointRecordEstimateSize,
|
|
serialize: _pointRecordSerialize,
|
|
deserialize: _pointRecordDeserialize,
|
|
deserializeProp: _pointRecordDeserializeProp,
|
|
idName: r'id',
|
|
indexes: {
|
|
r'updatedAt': IndexSchema(
|
|
id: -6238191080293565125,
|
|
name: r'updatedAt',
|
|
unique: false,
|
|
replace: false,
|
|
properties: [
|
|
IndexPropertySchema(
|
|
name: r'updatedAt',
|
|
type: IndexType.value,
|
|
caseSensitive: false,
|
|
)
|
|
],
|
|
),
|
|
r'createdAt': IndexSchema(
|
|
id: -3433535483987302584,
|
|
name: r'createdAt',
|
|
unique: false,
|
|
replace: false,
|
|
properties: [
|
|
IndexPropertySchema(
|
|
name: r'createdAt',
|
|
type: IndexType.value,
|
|
caseSensitive: false,
|
|
)
|
|
],
|
|
),
|
|
r'completedAt': IndexSchema(
|
|
id: -3156591011457686752,
|
|
name: r'completedAt',
|
|
unique: false,
|
|
replace: false,
|
|
properties: [
|
|
IndexPropertySchema(
|
|
name: r'completedAt',
|
|
type: IndexType.value,
|
|
caseSensitive: false,
|
|
)
|
|
],
|
|
),
|
|
r'bowOptionId': IndexSchema(
|
|
id: 5551937090384643164,
|
|
name: r'bowOptionId',
|
|
unique: false,
|
|
replace: false,
|
|
properties: [
|
|
IndexPropertySchema(
|
|
name: r'bowOptionId',
|
|
type: IndexType.value,
|
|
caseSensitive: false,
|
|
)
|
|
],
|
|
),
|
|
r'targetOptionId': IndexSchema(
|
|
id: -8007721351844109533,
|
|
name: r'targetOptionId',
|
|
unique: false,
|
|
replace: false,
|
|
properties: [
|
|
IndexPropertySchema(
|
|
name: r'targetOptionId',
|
|
type: IndexType.value,
|
|
caseSensitive: false,
|
|
)
|
|
],
|
|
)
|
|
},
|
|
links: {},
|
|
embeddedSchemas: {r'HitPoint': HitPointSchema},
|
|
getId: _pointRecordGetId,
|
|
getLinks: _pointRecordGetLinks,
|
|
attach: _pointRecordAttach,
|
|
version: '3.1.0+1',
|
|
);
|
|
|
|
int _pointRecordEstimateSize(
|
|
PointRecord object,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
var bytesCount = offsets.last;
|
|
bytesCount += 3 + object.bowName.length * 3;
|
|
bytesCount += 3 + object.hitPoints.length * 3;
|
|
{
|
|
final offsets = allOffsets[HitPoint]!;
|
|
for (var i = 0; i < object.hitPoints.length; i++) {
|
|
final value = object.hitPoints[i];
|
|
bytesCount += HitPointSchema.estimateSize(value, offsets, allOffsets);
|
|
}
|
|
}
|
|
{
|
|
final value = object.note;
|
|
if (value != null) {
|
|
bytesCount += 3 + value.length * 3;
|
|
}
|
|
}
|
|
bytesCount += 3 + object.scores.length * 8;
|
|
bytesCount += 3 + object.targetName.length * 3;
|
|
bytesCount += 3 + object.title.length * 3;
|
|
return bytesCount;
|
|
}
|
|
|
|
void _pointRecordSerialize(
|
|
PointRecord object,
|
|
IsarWriter writer,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
writer.writeLong(offsets[0], object.arrowsPerEnd);
|
|
writer.writeDouble(offsets[1], object.averageScore);
|
|
writer.writeString(offsets[2], object.bowName);
|
|
writer.writeLong(offsets[3], object.bowOptionId);
|
|
writer.writeDateTime(offsets[4], object.completedAt);
|
|
writer.writeDateTime(offsets[5], object.createdAt);
|
|
writer.writeLong(offsets[6], object.distanceMeters);
|
|
writer.writeLong(offsets[7], object.endCount);
|
|
writer.writeObjectList<HitPoint>(
|
|
offsets[8],
|
|
allOffsets,
|
|
HitPointSchema.serialize,
|
|
object.hitPoints,
|
|
);
|
|
writer.writeBool(offsets[9], object.isDraft);
|
|
writer.writeString(offsets[10], object.note);
|
|
writer.writeLongList(offsets[11], object.scores);
|
|
writer.writeByte(offsets[12], object.status.index);
|
|
writer.writeString(offsets[13], object.targetName);
|
|
writer.writeLong(offsets[14], object.targetOptionId);
|
|
writer.writeString(offsets[15], object.title);
|
|
writer.writeLong(offsets[16], object.totalArrows);
|
|
writer.writeLong(offsets[17], object.totalScore);
|
|
writer.writeDateTime(offsets[18], object.updatedAt);
|
|
}
|
|
|
|
PointRecord _pointRecordDeserialize(
|
|
Id id,
|
|
IsarReader reader,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
final object = PointRecord();
|
|
object.arrowsPerEnd = reader.readLong(offsets[0]);
|
|
object.bowName = reader.readString(offsets[2]);
|
|
object.bowOptionId = reader.readLong(offsets[3]);
|
|
object.completedAt = reader.readDateTimeOrNull(offsets[4]);
|
|
object.createdAt = reader.readDateTime(offsets[5]);
|
|
object.distanceMeters = reader.readLong(offsets[6]);
|
|
object.endCount = reader.readLong(offsets[7]);
|
|
object.hitPoints = reader.readObjectList<HitPoint>(
|
|
offsets[8],
|
|
HitPointSchema.deserialize,
|
|
allOffsets,
|
|
HitPoint(),
|
|
) ??
|
|
[];
|
|
object.id = id;
|
|
object.note = reader.readStringOrNull(offsets[10]);
|
|
object.scores = reader.readLongList(offsets[11]) ?? [];
|
|
object.status =
|
|
_PointRecordstatusValueEnumMap[reader.readByteOrNull(offsets[12])] ??
|
|
PointRecordStatus.draft;
|
|
object.targetName = reader.readString(offsets[13]);
|
|
object.targetOptionId = reader.readLong(offsets[14]);
|
|
object.title = reader.readString(offsets[15]);
|
|
object.updatedAt = reader.readDateTime(offsets[18]);
|
|
return object;
|
|
}
|
|
|
|
P _pointRecordDeserializeProp<P>(
|
|
IsarReader reader,
|
|
int propertyId,
|
|
int offset,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
switch (propertyId) {
|
|
case 0:
|
|
return (reader.readLong(offset)) as P;
|
|
case 1:
|
|
return (reader.readDoubleOrNull(offset)) as P;
|
|
case 2:
|
|
return (reader.readString(offset)) as P;
|
|
case 3:
|
|
return (reader.readLong(offset)) as P;
|
|
case 4:
|
|
return (reader.readDateTimeOrNull(offset)) as P;
|
|
case 5:
|
|
return (reader.readDateTime(offset)) as P;
|
|
case 6:
|
|
return (reader.readLong(offset)) as P;
|
|
case 7:
|
|
return (reader.readLong(offset)) as P;
|
|
case 8:
|
|
return (reader.readObjectList<HitPoint>(
|
|
offset,
|
|
HitPointSchema.deserialize,
|
|
allOffsets,
|
|
HitPoint(),
|
|
) ??
|
|
[]) as P;
|
|
case 9:
|
|
return (reader.readBool(offset)) as P;
|
|
case 10:
|
|
return (reader.readStringOrNull(offset)) as P;
|
|
case 11:
|
|
return (reader.readLongList(offset) ?? []) as P;
|
|
case 12:
|
|
return (_PointRecordstatusValueEnumMap[reader.readByteOrNull(offset)] ??
|
|
PointRecordStatus.draft) as P;
|
|
case 13:
|
|
return (reader.readString(offset)) as P;
|
|
case 14:
|
|
return (reader.readLong(offset)) as P;
|
|
case 15:
|
|
return (reader.readString(offset)) as P;
|
|
case 16:
|
|
return (reader.readLong(offset)) as P;
|
|
case 17:
|
|
return (reader.readLong(offset)) as P;
|
|
case 18:
|
|
return (reader.readDateTime(offset)) as P;
|
|
default:
|
|
throw IsarError('Unknown property with id $propertyId');
|
|
}
|
|
}
|
|
|
|
const _PointRecordstatusEnumValueMap = {
|
|
'draft': 0,
|
|
'completed': 1,
|
|
};
|
|
const _PointRecordstatusValueEnumMap = {
|
|
0: PointRecordStatus.draft,
|
|
1: PointRecordStatus.completed,
|
|
};
|
|
|
|
Id _pointRecordGetId(PointRecord object) {
|
|
return object.id;
|
|
}
|
|
|
|
List<IsarLinkBase<dynamic>> _pointRecordGetLinks(PointRecord object) {
|
|
return [];
|
|
}
|
|
|
|
void _pointRecordAttach(
|
|
IsarCollection<dynamic> col, Id id, PointRecord object) {
|
|
object.id = id;
|
|
}
|
|
|
|
extension PointRecordQueryWhereSort
|
|
on QueryBuilder<PointRecord, PointRecord, QWhere> {
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(const IdWhereClause.any());
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
const IndexWhereClause.any(indexName: r'updatedAt'),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyCreatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
const IndexWhereClause.any(indexName: r'createdAt'),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyCompletedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
const IndexWhereClause.any(indexName: r'completedAt'),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyBowOptionId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
const IndexWhereClause.any(indexName: r'bowOptionId'),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyTargetOptionId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
const IndexWhereClause.any(indexName: r'targetOptionId'),
|
|
);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension PointRecordQueryWhere
|
|
on QueryBuilder<PointRecord, PointRecord, QWhereClause> {
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> idEqualTo(Id id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: id,
|
|
upper: id,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, 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<PointRecord, PointRecord, QAfterWhereClause> idGreaterThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> idLessThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, 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<PointRecord, PointRecord, QAfterWhereClause> updatedAtEqualTo(
|
|
DateTime updatedAt) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'updatedAt',
|
|
value: [updatedAt],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> createdAtEqualTo(
|
|
DateTime createdAt) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'createdAt',
|
|
value: [createdAt],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> createdAtNotEqualTo(
|
|
DateTime createdAt) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'createdAt',
|
|
lower: [],
|
|
upper: [createdAt],
|
|
includeUpper: false,
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'createdAt',
|
|
lower: [createdAt],
|
|
includeLower: false,
|
|
upper: [],
|
|
));
|
|
} else {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'createdAt',
|
|
lower: [createdAt],
|
|
includeLower: false,
|
|
upper: [],
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'createdAt',
|
|
lower: [],
|
|
upper: [createdAt],
|
|
includeUpper: false,
|
|
));
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
createdAtGreaterThan(
|
|
DateTime createdAt, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'createdAt',
|
|
lower: [createdAt],
|
|
includeLower: include,
|
|
upper: [],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> createdAtLessThan(
|
|
DateTime createdAt, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'createdAt',
|
|
lower: [],
|
|
upper: [createdAt],
|
|
includeUpper: include,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> createdAtBetween(
|
|
DateTime lowerCreatedAt,
|
|
DateTime upperCreatedAt, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'createdAt',
|
|
lower: [lowerCreatedAt],
|
|
includeLower: includeLower,
|
|
upper: [upperCreatedAt],
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
completedAtIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'completedAt',
|
|
value: [null],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
completedAtIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'completedAt',
|
|
lower: [null],
|
|
includeLower: false,
|
|
upper: [],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> completedAtEqualTo(
|
|
DateTime? completedAt) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'completedAt',
|
|
value: [completedAt],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
completedAtNotEqualTo(DateTime? completedAt) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'completedAt',
|
|
lower: [],
|
|
upper: [completedAt],
|
|
includeUpper: false,
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'completedAt',
|
|
lower: [completedAt],
|
|
includeLower: false,
|
|
upper: [],
|
|
));
|
|
} else {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'completedAt',
|
|
lower: [completedAt],
|
|
includeLower: false,
|
|
upper: [],
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'completedAt',
|
|
lower: [],
|
|
upper: [completedAt],
|
|
includeUpper: false,
|
|
));
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
completedAtGreaterThan(
|
|
DateTime? completedAt, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'completedAt',
|
|
lower: [completedAt],
|
|
includeLower: include,
|
|
upper: [],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> completedAtLessThan(
|
|
DateTime? completedAt, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'completedAt',
|
|
lower: [],
|
|
upper: [completedAt],
|
|
includeUpper: include,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> completedAtBetween(
|
|
DateTime? lowerCompletedAt,
|
|
DateTime? upperCompletedAt, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'completedAt',
|
|
lower: [lowerCompletedAt],
|
|
includeLower: includeLower,
|
|
upper: [upperCompletedAt],
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> bowOptionIdEqualTo(
|
|
int bowOptionId) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'bowOptionId',
|
|
value: [bowOptionId],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
bowOptionIdNotEqualTo(int bowOptionId) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'bowOptionId',
|
|
lower: [],
|
|
upper: [bowOptionId],
|
|
includeUpper: false,
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'bowOptionId',
|
|
lower: [bowOptionId],
|
|
includeLower: false,
|
|
upper: [],
|
|
));
|
|
} else {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'bowOptionId',
|
|
lower: [bowOptionId],
|
|
includeLower: false,
|
|
upper: [],
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'bowOptionId',
|
|
lower: [],
|
|
upper: [bowOptionId],
|
|
includeUpper: false,
|
|
));
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
bowOptionIdGreaterThan(
|
|
int bowOptionId, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'bowOptionId',
|
|
lower: [bowOptionId],
|
|
includeLower: include,
|
|
upper: [],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> bowOptionIdLessThan(
|
|
int bowOptionId, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'bowOptionId',
|
|
lower: [],
|
|
upper: [bowOptionId],
|
|
includeUpper: include,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> bowOptionIdBetween(
|
|
int lowerBowOptionId,
|
|
int upperBowOptionId, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'bowOptionId',
|
|
lower: [lowerBowOptionId],
|
|
includeLower: includeLower,
|
|
upper: [upperBowOptionId],
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
targetOptionIdEqualTo(int targetOptionId) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.equalTo(
|
|
indexName: r'targetOptionId',
|
|
value: [targetOptionId],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
targetOptionIdNotEqualTo(int targetOptionId) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'targetOptionId',
|
|
lower: [],
|
|
upper: [targetOptionId],
|
|
includeUpper: false,
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'targetOptionId',
|
|
lower: [targetOptionId],
|
|
includeLower: false,
|
|
upper: [],
|
|
));
|
|
} else {
|
|
return query
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'targetOptionId',
|
|
lower: [targetOptionId],
|
|
includeLower: false,
|
|
upper: [],
|
|
))
|
|
.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'targetOptionId',
|
|
lower: [],
|
|
upper: [targetOptionId],
|
|
includeUpper: false,
|
|
));
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
targetOptionIdGreaterThan(
|
|
int targetOptionId, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'targetOptionId',
|
|
lower: [targetOptionId],
|
|
includeLower: include,
|
|
upper: [],
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
targetOptionIdLessThan(
|
|
int targetOptionId, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'targetOptionId',
|
|
lower: [],
|
|
upper: [targetOptionId],
|
|
includeUpper: include,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
|
|
targetOptionIdBetween(
|
|
int lowerTargetOptionId,
|
|
int upperTargetOptionId, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IndexWhereClause.between(
|
|
indexName: r'targetOptionId',
|
|
lower: [lowerTargetOptionId],
|
|
includeLower: includeLower,
|
|
upper: [upperTargetOptionId],
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension PointRecordQueryFilter
|
|
on QueryBuilder<PointRecord, PointRecord, QFilterCondition> {
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
arrowsPerEndEqualTo(int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'arrowsPerEnd',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
arrowsPerEndGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'arrowsPerEnd',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
arrowsPerEndLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'arrowsPerEnd',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
arrowsPerEndBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'arrowsPerEnd',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
averageScoreIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'averageScore',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
averageScoreIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'averageScore',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
averageScoreEqualTo(
|
|
double? value, {
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'averageScore',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
averageScoreGreaterThan(
|
|
double? value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'averageScore',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
averageScoreLessThan(
|
|
double? value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'averageScore',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
averageScoreBetween(
|
|
double? lower,
|
|
double? upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'averageScore',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowNameEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'bowName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
bowNameGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'bowName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowNameLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'bowName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowNameBetween(
|
|
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'bowName',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
bowNameStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'bowName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowNameEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'bowName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowNameContains(
|
|
String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'bowName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowNameMatches(
|
|
String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'bowName',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
bowNameIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'bowName',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
bowNameIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'bowName',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
bowOptionIdEqualTo(int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'bowOptionId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
bowOptionIdGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'bowOptionId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
bowOptionIdLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'bowOptionId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
bowOptionIdBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'bowOptionId',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
completedAtIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'completedAt',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
completedAtIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'completedAt',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
completedAtEqualTo(DateTime? value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'completedAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
completedAtGreaterThan(
|
|
DateTime? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'completedAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
completedAtLessThan(
|
|
DateTime? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'completedAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
completedAtBetween(
|
|
DateTime? lower,
|
|
DateTime? upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'completedAt',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
createdAtEqualTo(DateTime value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'createdAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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<PointRecord, PointRecord, QAfterFilterCondition>
|
|
distanceMetersEqualTo(int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'distanceMeters',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
distanceMetersGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'distanceMeters',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
distanceMetersLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'distanceMeters',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
distanceMetersBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'distanceMeters',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> endCountEqualTo(
|
|
int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'endCount',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
endCountGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'endCount',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
endCountLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'endCount',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> endCountBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'endCount',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
hitPointsLengthEqualTo(int length) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'hitPoints',
|
|
length,
|
|
true,
|
|
length,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
hitPointsIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'hitPoints',
|
|
0,
|
|
true,
|
|
0,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
hitPointsIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'hitPoints',
|
|
0,
|
|
false,
|
|
999999,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
hitPointsLengthLessThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'hitPoints',
|
|
0,
|
|
true,
|
|
length,
|
|
include,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
hitPointsLengthGreaterThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'hitPoints',
|
|
length,
|
|
include,
|
|
999999,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
hitPointsLengthBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'hitPoints',
|
|
lower,
|
|
includeLower,
|
|
upper,
|
|
includeUpper,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> idEqualTo(
|
|
Id value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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<PointRecord, PointRecord, QAfterFilterCondition> isDraftEqualTo(
|
|
bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'isDraft',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'note',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
noteIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'note',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteEqualTo(
|
|
String? value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'note',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteGreaterThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'note',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteLessThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'note',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteBetween(
|
|
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'note',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'note',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'note',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteContains(
|
|
String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'note',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteMatches(
|
|
String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'note',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'note',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
noteIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'note',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresElementEqualTo(int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'scores',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresElementGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'scores',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresElementLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'scores',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresElementBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'scores',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresLengthEqualTo(int length) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'scores',
|
|
length,
|
|
true,
|
|
length,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'scores',
|
|
0,
|
|
true,
|
|
0,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'scores',
|
|
0,
|
|
false,
|
|
999999,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresLengthLessThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'scores',
|
|
0,
|
|
true,
|
|
length,
|
|
include,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresLengthGreaterThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'scores',
|
|
length,
|
|
include,
|
|
999999,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
scoresLengthBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'scores',
|
|
lower,
|
|
includeLower,
|
|
upper,
|
|
includeUpper,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> statusEqualTo(
|
|
PointRecordStatus value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'status',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
statusGreaterThan(
|
|
PointRecordStatus value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'status',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> statusLessThan(
|
|
PointRecordStatus value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'status',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> statusBetween(
|
|
PointRecordStatus lower,
|
|
PointRecordStatus upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'status',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'targetName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'targetName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'targetName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameBetween(
|
|
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'targetName',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'targetName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'targetName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameContains(String value, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'targetName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameMatches(String pattern, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'targetName',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'targetName',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetNameIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'targetName',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetOptionIdEqualTo(int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'targetOptionId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetOptionIdGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'targetOptionId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetOptionIdLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'targetOptionId',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
targetOptionIdBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'targetOptionId',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> titleEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'title',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
titleGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'title',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> titleLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'title',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> titleBetween(
|
|
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'title',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> titleStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'title',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> titleEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'title',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> titleContains(
|
|
String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'title',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> titleMatches(
|
|
String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'title',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> titleIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'title',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
titleIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'title',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
totalArrowsEqualTo(int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'totalArrows',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
totalArrowsGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'totalArrows',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
totalArrowsLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'totalArrows',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
totalArrowsBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'totalArrows',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
totalScoreEqualTo(int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'totalScore',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
totalScoreGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'totalScore',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
totalScoreLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'totalScore',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
totalScoreBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'totalScore',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
updatedAtEqualTo(DateTime value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'updatedAt',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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<PointRecord, PointRecord, 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 PointRecordQueryObject
|
|
on QueryBuilder<PointRecord, PointRecord, QFilterCondition> {
|
|
QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
|
|
hitPointsElement(FilterQuery<HitPoint> q) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.object(q, r'hitPoints');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension PointRecordQueryLinks
|
|
on QueryBuilder<PointRecord, PointRecord, QFilterCondition> {}
|
|
|
|
extension PointRecordQuerySortBy
|
|
on QueryBuilder<PointRecord, PointRecord, QSortBy> {
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByArrowsPerEnd() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'arrowsPerEnd', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
|
|
sortByArrowsPerEndDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'arrowsPerEnd', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByAverageScore() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'averageScore', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
|
|
sortByAverageScoreDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'averageScore', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByBowName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'bowName', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByBowNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'bowName', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByBowOptionId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'bowOptionId', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByBowOptionIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'bowOptionId', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByCompletedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'completedAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByCompletedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'completedAt', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByCreatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'createdAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByCreatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'createdAt', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByDistanceMeters() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'distanceMeters', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
|
|
sortByDistanceMetersDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'distanceMeters', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByEndCount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'endCount', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByEndCountDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'endCount', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByIsDraft() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isDraft', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByIsDraftDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isDraft', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByNote() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'note', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByNoteDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'note', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByStatus() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'status', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByStatusDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'status', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTargetName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'targetName', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTargetNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'targetName', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTargetOptionId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'targetOptionId', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
|
|
sortByTargetOptionIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'targetOptionId', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTitle() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'title', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTitleDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'title', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTotalArrows() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'totalArrows', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTotalArrowsDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'totalArrows', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTotalScore() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'totalScore', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTotalScoreDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'totalScore', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByUpdatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension PointRecordQuerySortThenBy
|
|
on QueryBuilder<PointRecord, PointRecord, QSortThenBy> {
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByArrowsPerEnd() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'arrowsPerEnd', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
|
|
thenByArrowsPerEndDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'arrowsPerEnd', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByAverageScore() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'averageScore', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
|
|
thenByAverageScoreDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'averageScore', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByBowName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'bowName', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByBowNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'bowName', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByBowOptionId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'bowOptionId', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByBowOptionIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'bowOptionId', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByCompletedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'completedAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByCompletedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'completedAt', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByCreatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'createdAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByCreatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'createdAt', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByDistanceMeters() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'distanceMeters', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
|
|
thenByDistanceMetersDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'distanceMeters', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByEndCount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'endCount', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByEndCountDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'endCount', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenById() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByIsDraft() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isDraft', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByIsDraftDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'isDraft', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByNote() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'note', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByNoteDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'note', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByStatus() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'status', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByStatusDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'status', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTargetName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'targetName', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTargetNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'targetName', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTargetOptionId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'targetOptionId', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
|
|
thenByTargetOptionIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'targetOptionId', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTitle() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'title', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTitleDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'title', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTotalArrows() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'totalArrows', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTotalArrowsDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'totalArrows', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTotalScore() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'totalScore', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTotalScoreDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'totalScore', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByUpdatedAtDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'updatedAt', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension PointRecordQueryWhereDistinct
|
|
on QueryBuilder<PointRecord, PointRecord, QDistinct> {
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByArrowsPerEnd() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'arrowsPerEnd');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByAverageScore() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'averageScore');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByBowName(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'bowName', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByBowOptionId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'bowOptionId');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByCompletedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'completedAt');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByCreatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'createdAt');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByDistanceMeters() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'distanceMeters');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByEndCount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'endCount');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByIsDraft() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'isDraft');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByNote(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'note', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByScores() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'scores');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByStatus() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'status');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByTargetName(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'targetName', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByTargetOptionId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'targetOptionId');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByTitle(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'title', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByTotalArrows() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'totalArrows');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByTotalScore() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'totalScore');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByUpdatedAt() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'updatedAt');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension PointRecordQueryProperty
|
|
on QueryBuilder<PointRecord, PointRecord, QQueryProperty> {
|
|
QueryBuilder<PointRecord, int, QQueryOperations> idProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'id');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, int, QQueryOperations> arrowsPerEndProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'arrowsPerEnd');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, double?, QQueryOperations> averageScoreProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'averageScore');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, String, QQueryOperations> bowNameProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'bowName');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, int, QQueryOperations> bowOptionIdProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'bowOptionId');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, DateTime?, QQueryOperations> completedAtProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'completedAt');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, DateTime, QQueryOperations> createdAtProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'createdAt');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, int, QQueryOperations> distanceMetersProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'distanceMeters');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, int, QQueryOperations> endCountProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'endCount');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, List<HitPoint>, QQueryOperations>
|
|
hitPointsProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'hitPoints');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, bool, QQueryOperations> isDraftProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'isDraft');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, String?, QQueryOperations> noteProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'note');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, List<int>, QQueryOperations> scoresProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'scores');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, PointRecordStatus, QQueryOperations>
|
|
statusProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'status');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, String, QQueryOperations> targetNameProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'targetName');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, int, QQueryOperations> targetOptionIdProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'targetOptionId');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, String, QQueryOperations> titleProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'title');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, int, QQueryOperations> totalArrowsProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'totalArrows');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, int, QQueryOperations> totalScoreProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'totalScore');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<PointRecord, DateTime, QQueryOperations> updatedAtProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'updatedAt');
|
|
});
|
|
}
|
|
}
|
|
|
|
// **************************************************************************
|
|
// IsarEmbeddedGenerator
|
|
// **************************************************************************
|
|
|
|
// 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
|
|
|
|
const HitPointSchema = Schema(
|
|
name: r'HitPoint',
|
|
id: -4202326135308389480,
|
|
properties: {
|
|
r'arrowIndex': PropertySchema(
|
|
id: 0,
|
|
name: r'arrowIndex',
|
|
type: IsarType.long,
|
|
),
|
|
r'endIndex': PropertySchema(
|
|
id: 1,
|
|
name: r'endIndex',
|
|
type: IsarType.long,
|
|
),
|
|
r'isMiss': PropertySchema(
|
|
id: 2,
|
|
name: r'isMiss',
|
|
type: IsarType.bool,
|
|
),
|
|
r'normalizedX': PropertySchema(
|
|
id: 3,
|
|
name: r'normalizedX',
|
|
type: IsarType.double,
|
|
),
|
|
r'normalizedY': PropertySchema(
|
|
id: 4,
|
|
name: r'normalizedY',
|
|
type: IsarType.double,
|
|
),
|
|
r'score': PropertySchema(
|
|
id: 5,
|
|
name: r'score',
|
|
type: IsarType.long,
|
|
)
|
|
},
|
|
estimateSize: _hitPointEstimateSize,
|
|
serialize: _hitPointSerialize,
|
|
deserialize: _hitPointDeserialize,
|
|
deserializeProp: _hitPointDeserializeProp,
|
|
);
|
|
|
|
int _hitPointEstimateSize(
|
|
HitPoint object,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
var bytesCount = offsets.last;
|
|
return bytesCount;
|
|
}
|
|
|
|
void _hitPointSerialize(
|
|
HitPoint object,
|
|
IsarWriter writer,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
writer.writeLong(offsets[0], object.arrowIndex);
|
|
writer.writeLong(offsets[1], object.endIndex);
|
|
writer.writeBool(offsets[2], object.isMiss);
|
|
writer.writeDouble(offsets[3], object.normalizedX);
|
|
writer.writeDouble(offsets[4], object.normalizedY);
|
|
writer.writeLong(offsets[5], object.score);
|
|
}
|
|
|
|
HitPoint _hitPointDeserialize(
|
|
Id id,
|
|
IsarReader reader,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
final object = HitPoint(
|
|
arrowIndex: reader.readLongOrNull(offsets[0]) ?? 0,
|
|
endIndex: reader.readLongOrNull(offsets[1]) ?? 0,
|
|
isMiss: reader.readBoolOrNull(offsets[2]) ?? false,
|
|
normalizedX: reader.readDoubleOrNull(offsets[3]) ?? 0,
|
|
normalizedY: reader.readDoubleOrNull(offsets[4]) ?? 0,
|
|
score: reader.readLongOrNull(offsets[5]),
|
|
);
|
|
return object;
|
|
}
|
|
|
|
P _hitPointDeserializeProp<P>(
|
|
IsarReader reader,
|
|
int propertyId,
|
|
int offset,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
switch (propertyId) {
|
|
case 0:
|
|
return (reader.readLongOrNull(offset) ?? 0) as P;
|
|
case 1:
|
|
return (reader.readLongOrNull(offset) ?? 0) as P;
|
|
case 2:
|
|
return (reader.readBoolOrNull(offset) ?? false) as P;
|
|
case 3:
|
|
return (reader.readDoubleOrNull(offset) ?? 0) as P;
|
|
case 4:
|
|
return (reader.readDoubleOrNull(offset) ?? 0) as P;
|
|
case 5:
|
|
return (reader.readLongOrNull(offset)) as P;
|
|
default:
|
|
throw IsarError('Unknown property with id $propertyId');
|
|
}
|
|
}
|
|
|
|
extension HitPointQueryFilter
|
|
on QueryBuilder<HitPoint, HitPoint, QFilterCondition> {
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> arrowIndexEqualTo(
|
|
int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'arrowIndex',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> arrowIndexGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'arrowIndex',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> arrowIndexLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'arrowIndex',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> arrowIndexBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'arrowIndex',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> endIndexEqualTo(
|
|
int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'endIndex',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> endIndexGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'endIndex',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> endIndexLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'endIndex',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> endIndexBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'endIndex',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> isMissEqualTo(
|
|
bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'isMiss',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> normalizedXEqualTo(
|
|
double value, {
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'normalizedX',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition>
|
|
normalizedXGreaterThan(
|
|
double value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'normalizedX',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> normalizedXLessThan(
|
|
double value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'normalizedX',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> normalizedXBetween(
|
|
double lower,
|
|
double upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'normalizedX',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> normalizedYEqualTo(
|
|
double value, {
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'normalizedY',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition>
|
|
normalizedYGreaterThan(
|
|
double value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'normalizedY',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> normalizedYLessThan(
|
|
double value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'normalizedY',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> normalizedYBetween(
|
|
double lower,
|
|
double upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'normalizedY',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'score',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'score',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreEqualTo(
|
|
int? value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'score',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreGreaterThan(
|
|
int? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'score',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreLessThan(
|
|
int? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'score',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreBetween(
|
|
int? lower,
|
|
int? upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'score',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension HitPointQueryObject
|
|
on QueryBuilder<HitPoint, HitPoint, QFilterCondition> {}
|