2163 lines
60 KiB
Dart
2163 lines
60 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'short_poll.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 GetShortPollCollection on Isar {
|
|
IsarCollection<ShortPoll> get shortPolls => this.collection();
|
|
}
|
|
|
|
const ShortPollSchema = CollectionSchema(
|
|
name: r'ShortPoll',
|
|
id: -3233511297786412096,
|
|
properties: {
|
|
r'commentsAllowed': PropertySchema(
|
|
id: 0,
|
|
name: r'commentsAllowed',
|
|
type: IsarType.bool,
|
|
),
|
|
r'imageHeight': PropertySchema(
|
|
id: 1,
|
|
name: r'imageHeight',
|
|
type: IsarType.long,
|
|
),
|
|
r'imageModified': PropertySchema(
|
|
id: 2,
|
|
name: r'imageModified',
|
|
type: IsarType.string,
|
|
),
|
|
r'imageWidth': PropertySchema(
|
|
id: 3,
|
|
name: r'imageWidth',
|
|
type: IsarType.long,
|
|
),
|
|
r'numberOfVotes': PropertySchema(
|
|
id: 4,
|
|
name: r'numberOfVotes',
|
|
type: IsarType.long,
|
|
),
|
|
r'pdfName': PropertySchema(
|
|
id: 5,
|
|
name: r'pdfName',
|
|
type: IsarType.string,
|
|
),
|
|
r'questions': PropertySchema(
|
|
id: 6,
|
|
name: r'questions',
|
|
type: IsarType.objectList,
|
|
target: r'ShortPollQuestion',
|
|
),
|
|
r'read': PropertySchema(
|
|
id: 7,
|
|
name: r'read',
|
|
type: IsarType.bool,
|
|
),
|
|
r'text': PropertySchema(
|
|
id: 8,
|
|
name: r'text',
|
|
type: IsarType.string,
|
|
),
|
|
r'title': PropertySchema(
|
|
id: 9,
|
|
name: r'title',
|
|
type: IsarType.string,
|
|
),
|
|
r'type': PropertySchema(
|
|
id: 10,
|
|
name: r'type',
|
|
type: IsarType.long,
|
|
),
|
|
r'url': PropertySchema(
|
|
id: 11,
|
|
name: r'url',
|
|
type: IsarType.string,
|
|
),
|
|
r'validFrom': PropertySchema(
|
|
id: 12,
|
|
name: r'validFrom',
|
|
type: IsarType.long,
|
|
),
|
|
r'validTo': PropertySchema(
|
|
id: 13,
|
|
name: r'validTo',
|
|
type: IsarType.long,
|
|
),
|
|
r'voted': PropertySchema(
|
|
id: 14,
|
|
name: r'voted',
|
|
type: IsarType.bool,
|
|
)
|
|
},
|
|
estimateSize: _shortPollEstimateSize,
|
|
serialize: _shortPollSerialize,
|
|
deserialize: _shortPollDeserialize,
|
|
deserializeProp: _shortPollDeserializeProp,
|
|
idName: r'id',
|
|
indexes: {},
|
|
links: {},
|
|
embeddedSchemas: {r'ShortPollQuestion': ShortPollQuestionSchema},
|
|
getId: _shortPollGetId,
|
|
getLinks: _shortPollGetLinks,
|
|
attach: _shortPollAttach,
|
|
version: '3.1.0+1',
|
|
);
|
|
|
|
int _shortPollEstimateSize(
|
|
ShortPoll object,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
var bytesCount = offsets.last;
|
|
{
|
|
final value = object.imageModified;
|
|
if (value != null) {
|
|
bytesCount += 3 + value.length * 3;
|
|
}
|
|
}
|
|
{
|
|
final value = object.pdfName;
|
|
if (value != null) {
|
|
bytesCount += 3 + value.length * 3;
|
|
}
|
|
}
|
|
bytesCount += 3 + object.questions.length * 3;
|
|
{
|
|
final offsets = allOffsets[ShortPollQuestion]!;
|
|
for (var i = 0; i < object.questions.length; i++) {
|
|
final value = object.questions[i];
|
|
bytesCount +=
|
|
ShortPollQuestionSchema.estimateSize(value, offsets, allOffsets);
|
|
}
|
|
}
|
|
bytesCount += 3 + object.text.length * 3;
|
|
bytesCount += 3 + object.title.length * 3;
|
|
{
|
|
final value = object.url;
|
|
if (value != null) {
|
|
bytesCount += 3 + value.length * 3;
|
|
}
|
|
}
|
|
return bytesCount;
|
|
}
|
|
|
|
void _shortPollSerialize(
|
|
ShortPoll object,
|
|
IsarWriter writer,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
writer.writeBool(offsets[0], object.commentsAllowed);
|
|
writer.writeLong(offsets[1], object.imageHeight);
|
|
writer.writeString(offsets[2], object.imageModified);
|
|
writer.writeLong(offsets[3], object.imageWidth);
|
|
writer.writeLong(offsets[4], object.numberOfVotes);
|
|
writer.writeString(offsets[5], object.pdfName);
|
|
writer.writeObjectList<ShortPollQuestion>(
|
|
offsets[6],
|
|
allOffsets,
|
|
ShortPollQuestionSchema.serialize,
|
|
object.questions,
|
|
);
|
|
writer.writeBool(offsets[7], object.read);
|
|
writer.writeString(offsets[8], object.text);
|
|
writer.writeString(offsets[9], object.title);
|
|
writer.writeLong(offsets[10], object.type);
|
|
writer.writeString(offsets[11], object.url);
|
|
writer.writeLong(offsets[12], object.validFrom);
|
|
writer.writeLong(offsets[13], object.validTo);
|
|
writer.writeBool(offsets[14], object.voted);
|
|
}
|
|
|
|
ShortPoll _shortPollDeserialize(
|
|
Id id,
|
|
IsarReader reader,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
final object = ShortPoll(
|
|
commentsAllowed: reader.readBoolOrNull(offsets[0]),
|
|
id: id,
|
|
imageHeight: reader.readLongOrNull(offsets[1]),
|
|
imageModified: reader.readStringOrNull(offsets[2]),
|
|
imageWidth: reader.readLongOrNull(offsets[3]),
|
|
numberOfVotes: reader.readLong(offsets[4]),
|
|
pdfName: reader.readStringOrNull(offsets[5]),
|
|
questions: reader.readObjectList<ShortPollQuestion>(
|
|
offsets[6],
|
|
ShortPollQuestionSchema.deserialize,
|
|
allOffsets,
|
|
ShortPollQuestion(),
|
|
) ??
|
|
[],
|
|
read: reader.readBool(offsets[7]),
|
|
text: reader.readString(offsets[8]),
|
|
title: reader.readString(offsets[9]),
|
|
type: reader.readLong(offsets[10]),
|
|
url: reader.readStringOrNull(offsets[11]),
|
|
validFrom: reader.readLong(offsets[12]),
|
|
validTo: reader.readLong(offsets[13]),
|
|
voted: reader.readBool(offsets[14]),
|
|
);
|
|
return object;
|
|
}
|
|
|
|
P _shortPollDeserializeProp<P>(
|
|
IsarReader reader,
|
|
int propertyId,
|
|
int offset,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
switch (propertyId) {
|
|
case 0:
|
|
return (reader.readBoolOrNull(offset)) as P;
|
|
case 1:
|
|
return (reader.readLongOrNull(offset)) as P;
|
|
case 2:
|
|
return (reader.readStringOrNull(offset)) as P;
|
|
case 3:
|
|
return (reader.readLongOrNull(offset)) as P;
|
|
case 4:
|
|
return (reader.readLong(offset)) as P;
|
|
case 5:
|
|
return (reader.readStringOrNull(offset)) as P;
|
|
case 6:
|
|
return (reader.readObjectList<ShortPollQuestion>(
|
|
offset,
|
|
ShortPollQuestionSchema.deserialize,
|
|
allOffsets,
|
|
ShortPollQuestion(),
|
|
) ??
|
|
[]) as P;
|
|
case 7:
|
|
return (reader.readBool(offset)) as P;
|
|
case 8:
|
|
return (reader.readString(offset)) as P;
|
|
case 9:
|
|
return (reader.readString(offset)) as P;
|
|
case 10:
|
|
return (reader.readLong(offset)) as P;
|
|
case 11:
|
|
return (reader.readStringOrNull(offset)) as P;
|
|
case 12:
|
|
return (reader.readLong(offset)) as P;
|
|
case 13:
|
|
return (reader.readLong(offset)) as P;
|
|
case 14:
|
|
return (reader.readBool(offset)) as P;
|
|
default:
|
|
throw IsarError('Unknown property with id $propertyId');
|
|
}
|
|
}
|
|
|
|
Id _shortPollGetId(ShortPoll object) {
|
|
return object.id;
|
|
}
|
|
|
|
List<IsarLinkBase<dynamic>> _shortPollGetLinks(ShortPoll object) {
|
|
return [];
|
|
}
|
|
|
|
void _shortPollAttach(IsarCollection<dynamic> col, Id id, ShortPoll object) {
|
|
object.id = id;
|
|
}
|
|
|
|
extension ShortPollQueryWhereSort
|
|
on QueryBuilder<ShortPoll, ShortPoll, QWhere> {
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterWhere> anyId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(const IdWhereClause.any());
|
|
});
|
|
}
|
|
}
|
|
|
|
extension ShortPollQueryWhere
|
|
on QueryBuilder<ShortPoll, ShortPoll, QWhereClause> {
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterWhereClause> idEqualTo(Id id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: id,
|
|
upper: id,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, QAfterWhereClause> idGreaterThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterWhereClause> idLessThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, 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,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension ShortPollQueryFilter
|
|
on QueryBuilder<ShortPoll, ShortPoll, QFilterCondition> {
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
commentsAllowedIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'commentsAllowed',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
commentsAllowedIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'commentsAllowed',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
commentsAllowedEqualTo(bool? value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'commentsAllowed',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> idEqualTo(
|
|
Id value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageHeightIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'imageHeight',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageHeightIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'imageHeight',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> imageHeightEqualTo(
|
|
int? value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'imageHeight',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageHeightGreaterThan(
|
|
int? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'imageHeight',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> imageHeightLessThan(
|
|
int? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'imageHeight',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> imageHeightBetween(
|
|
int? lower,
|
|
int? upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'imageHeight',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'imageModified',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'imageModified',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedEqualTo(
|
|
String? value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'imageModified',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedGreaterThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'imageModified',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedLessThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'imageModified',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedBetween(
|
|
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'imageModified',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'imageModified',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'imageModified',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedContains(String value, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'imageModified',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedMatches(String pattern, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'imageModified',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'imageModified',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageModifiedIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'imageModified',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> imageWidthIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'imageWidth',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageWidthIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'imageWidth',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> imageWidthEqualTo(
|
|
int? value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'imageWidth',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
imageWidthGreaterThan(
|
|
int? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'imageWidth',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> imageWidthLessThan(
|
|
int? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'imageWidth',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> imageWidthBetween(
|
|
int? lower,
|
|
int? upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'imageWidth',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
numberOfVotesEqualTo(int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'numberOfVotes',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
numberOfVotesGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'numberOfVotes',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
numberOfVotesLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'numberOfVotes',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
numberOfVotesBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'numberOfVotes',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'pdfName',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'pdfName',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameEqualTo(
|
|
String? value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'pdfName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameGreaterThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'pdfName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameLessThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'pdfName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameBetween(
|
|
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'pdfName',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'pdfName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'pdfName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameContains(
|
|
String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'pdfName',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameMatches(
|
|
String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'pdfName',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> pdfNameIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'pdfName',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
pdfNameIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'pdfName',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
questionsLengthEqualTo(int length) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'questions',
|
|
length,
|
|
true,
|
|
length,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> questionsIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'questions',
|
|
0,
|
|
true,
|
|
0,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
questionsIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'questions',
|
|
0,
|
|
false,
|
|
999999,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
questionsLengthLessThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'questions',
|
|
0,
|
|
true,
|
|
length,
|
|
include,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
questionsLengthGreaterThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'questions',
|
|
length,
|
|
include,
|
|
999999,
|
|
true,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
questionsLengthBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.listLength(
|
|
r'questions',
|
|
lower,
|
|
includeLower,
|
|
upper,
|
|
includeUpper,
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> readEqualTo(
|
|
bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'read',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textEqualTo(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'text',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'text',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'text',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textBetween(
|
|
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'text',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'text',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'text',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textContains(
|
|
String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'text',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textMatches(
|
|
String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'text',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'text',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> textIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'text',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, 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<ShortPoll, ShortPoll, QAfterFilterCondition> titleIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'title',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> titleIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'title',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> typeEqualTo(
|
|
int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'type',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> typeGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'type',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> typeLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'type',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> typeBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'type',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'url',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'url',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlEqualTo(
|
|
String? value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'url',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlGreaterThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'url',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlLessThan(
|
|
String? value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'url',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlBetween(
|
|
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'url',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlStartsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'url',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlEndsWith(
|
|
String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'url',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlContains(
|
|
String value,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'url',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlMatches(
|
|
String pattern,
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'url',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'url',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> urlIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'url',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> validFromEqualTo(
|
|
int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'validFrom',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition>
|
|
validFromGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'validFrom',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> validFromLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'validFrom',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> validFromBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'validFrom',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> validToEqualTo(
|
|
int value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'validTo',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> validToGreaterThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'validTo',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> validToLessThan(
|
|
int value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'validTo',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> validToBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'validTo',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> votedEqualTo(
|
|
bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'voted',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension ShortPollQueryObject
|
|
on QueryBuilder<ShortPoll, ShortPoll, QFilterCondition> {
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterFilterCondition> questionsElement(
|
|
FilterQuery<ShortPollQuestion> q) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.object(q, r'questions');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension ShortPollQueryLinks
|
|
on QueryBuilder<ShortPoll, ShortPoll, QFilterCondition> {}
|
|
|
|
extension ShortPollQuerySortBy on QueryBuilder<ShortPoll, ShortPoll, QSortBy> {
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByCommentsAllowed() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'commentsAllowed', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByCommentsAllowedDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'commentsAllowed', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByImageHeight() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageHeight', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByImageHeightDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageHeight', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByImageModified() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageModified', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByImageModifiedDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageModified', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByImageWidth() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageWidth', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByImageWidthDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageWidth', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByNumberOfVotes() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'numberOfVotes', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByNumberOfVotesDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'numberOfVotes', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByPdfName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'pdfName', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByPdfNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'pdfName', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByRead() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'read', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByReadDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'read', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByText() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'text', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByTextDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'text', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByTitle() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'title', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByTitleDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'title', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByType() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'type', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByTypeDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'type', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByUrl() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'url', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByUrlDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'url', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByValidFrom() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'validFrom', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByValidFromDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'validFrom', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByValidTo() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'validTo', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByValidToDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'validTo', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByVoted() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'voted', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> sortByVotedDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'voted', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension ShortPollQuerySortThenBy
|
|
on QueryBuilder<ShortPoll, ShortPoll, QSortThenBy> {
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByCommentsAllowed() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'commentsAllowed', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByCommentsAllowedDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'commentsAllowed', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenById() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByImageHeight() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageHeight', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByImageHeightDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageHeight', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByImageModified() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageModified', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByImageModifiedDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageModified', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByImageWidth() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageWidth', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByImageWidthDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'imageWidth', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByNumberOfVotes() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'numberOfVotes', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByNumberOfVotesDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'numberOfVotes', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByPdfName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'pdfName', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByPdfNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'pdfName', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByRead() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'read', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByReadDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'read', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByText() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'text', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByTextDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'text', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByTitle() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'title', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByTitleDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'title', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByType() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'type', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByTypeDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'type', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByUrl() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'url', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByUrlDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'url', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByValidFrom() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'validFrom', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByValidFromDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'validFrom', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByValidTo() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'validTo', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByValidToDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'validTo', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByVoted() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'voted', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QAfterSortBy> thenByVotedDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'voted', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension ShortPollQueryWhereDistinct
|
|
on QueryBuilder<ShortPoll, ShortPoll, QDistinct> {
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByCommentsAllowed() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'commentsAllowed');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByImageHeight() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'imageHeight');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByImageModified(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'imageModified',
|
|
caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByImageWidth() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'imageWidth');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByNumberOfVotes() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'numberOfVotes');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByPdfName(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'pdfName', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByRead() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'read');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByText(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'text', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByTitle(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'title', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByType() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'type');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByUrl(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'url', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByValidFrom() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'validFrom');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByValidTo() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'validTo');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, ShortPoll, QDistinct> distinctByVoted() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'voted');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension ShortPollQueryProperty
|
|
on QueryBuilder<ShortPoll, ShortPoll, QQueryProperty> {
|
|
QueryBuilder<ShortPoll, int, QQueryOperations> idProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'id');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, bool?, QQueryOperations> commentsAllowedProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'commentsAllowed');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, int?, QQueryOperations> imageHeightProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'imageHeight');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, String?, QQueryOperations> imageModifiedProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'imageModified');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, int?, QQueryOperations> imageWidthProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'imageWidth');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, int, QQueryOperations> numberOfVotesProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'numberOfVotes');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, String?, QQueryOperations> pdfNameProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'pdfName');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, List<ShortPollQuestion>, QQueryOperations>
|
|
questionsProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'questions');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, bool, QQueryOperations> readProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'read');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, String, QQueryOperations> textProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'text');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, String, QQueryOperations> titleProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'title');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, int, QQueryOperations> typeProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'type');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, String?, QQueryOperations> urlProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'url');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, int, QQueryOperations> validFromProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'validFrom');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, int, QQueryOperations> validToProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'validTo');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<ShortPoll, bool, QQueryOperations> votedProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'voted');
|
|
});
|
|
}
|
|
}
|