class Timetable(MongoModel):
robot_id = fields.CharField(primary_key=True)
solver_name = fields.CharField()
ztp = fields.DateTimeField()
stn = fields.DictField()
dispatchable_graph = fields.DictField(default=dict())
stn_tasks = fields.DictField(blank=True)
objects = TimetableManager()
class Meta:
archive_collection = 'timetable_archive'
ignore_unknown_fields = True
def save(self):
try:
super().save(cascade=True)
except ServerSelectionTimeoutError:
logging.warning('Could not save models to MongoDB')
@classmethod
def from_payload(cls, payload):
document = Document.from_payload(payload)
document['_id'] = document.pop('robot_id')
document["ztp"] = dateutil.parser.parse(document.pop("ztp"))
timetable = Timetable.from_document(document)
return timetable
def to_dict(self):
dict_repr = self.to_son().to_dict()
dict_repr.pop('_cls')
dict_repr["robot_id"] = str(dict_repr.pop('_id'))
dict_repr["ztp"] = self.ztp.isoformat()
return dict_repr
class Response(BaseMongoModel):
id = fields.ObjectIdField(primary_key=True)
form = fields.ReferenceField(Form, on_delete=fields.ReferenceField.CASCADE)
user = fields.ReferenceField(User,
on_delete=fields.ReferenceField.CASCADE,
blank=True)
# paymentInfo = fields.EmbeddedDocumentField(PaymentInfo)
paymentInfo = fields.DictField()
payment_status_detail = fields.EmbeddedDocumentListField(
PaymentStatusDetailItem, blank=True, default=list)
paid = fields.BooleanField(default=False)
amount_paid = fields.CharField(default="0")
payment_trail = fields.EmbeddedDocumentListField(PaymentTrailItem,
blank=True,
default=list)
update_trail = fields.EmbeddedDocumentListField(UpdateTrailItem,
blank=True,
default=list)
email_trail = fields.EmbeddedDocumentListField(EmailTrailItem,
blank=True,
default=list)
value = fields.DictField()
date_created = fields.DateTimeField(required=True)
date_modified = fields.DateTimeField(required=True)
pending_update = fields.DictField(blank=True)
admin_info = fields.DictField()
modify_link = fields.CharField(blank=True)
predicate = fields.DictField()
counter = fields.IntegerField(blank=True)
class Offers(MongoModel):
'''
if offer_type == rewardpoint:
offer_data = {"reward_name":"spend 100 and get coke free","reward_points":100,"reward_Info":"coke"}
'''
agentId = fields.ObjectIdField(required=True)
name = fields.CharField(required=True)
offer_type = fields.CharField(required=True)
offer_data = fields.DictField(blank=True)
promotion_data = fields.DictField(blank=True)
scheduled_at = fields.DateTimeField(blank=True)
valid_from = fields.DateTimeField(required=True)
valid_to = fields.DateTimeField(required=True)
class Meta:
indexes = [
pymongo.IndexModel([('agentId', pymongo.ALL)],
name="OffersagentIdIndexField"),
pymongo.IndexModel([('valid_from', pymongo.ALL)],
name="OffersvalidFromIndexField"),
pymongo.IndexModel([('valid_to', pymongo.ALL)],
name="OffersvalidToIndexField")
] # indexes
# asd= rest.objects.raw({'location': {'$near': SON([('$geometry', SON([('type', 'Point'), ('coordinates', [-122.406417,37.785834])])), ('$maxDistance', 500)])}})
# asd = rest.objects.raw({"location":{"$near": {"$geometry": {"type":"Point","coordinates":[-122.406417,37.785834]},"$maxDistance":500}}})
# for i in asd:
# print i._data
class Judgment(MongoModel):
class Meta:
final = True
id = fields.CharField(primary_key=True)
collection = fields.CharField()
job = fields.CharField()
unit = fields.CharField()
worker = fields.CharField()
platform = fields.CharField()
content = fields.DictField()
annotations = fields.DictField()
started = fields.DateTimeField()
submitted = fields.DateTimeField()
duration = fields.CharField()
now = datetime.datetime.utcnow()
created = fields.DateTimeField(default=now)
updated = fields.DateTimeField(default=now)
features = fields.DictField()
#content = fields.CharField()
def setAgreement(self, agreement):
if 'features' not in self:
self.features = {}
self.features['agreement'] = agreement
self.save()
class ImageDB(MongoModel):
user_email = fields.EmailField(primary_key=True)
uploaded_images = fields.ListField(field=fields.DictField())
image_formats = fields.ListField(field=fields.DictField())
upload_times = fields.ListField(field=fields.DateTimeField())
image_size = fields.ListField(field=fields.DictField())
processed_info = fields.ListField(field=fields.DictField())
user_metrics = fields.DictField()
class UpdateTrailItem(EmbeddedMongoModel):
old = fields.DictField()
new = fields.DictField()
date = fields.DateTimeField(required=True)
update_type = fields.CharField()
path = fields.CharField()
user = fields.ReferenceField(User, blank=True)
old_value = fields.CharField(blank=True)
new_value = fields.CharField(blank=True)
response_base_path = fields.CharField(blank=True)
class User(MongoModel):
"""
User class is a MongoModel. Used to store information about
Users that are using the app.
"""
email = fields.CharField(primary_key=True)
# the structure of this will be key (upload id): most recent_id
uploads = fields.DictField()
current_image = fields.CharField()
process_count = fields.DictField()
class Survey(MongoModel):
group_id = ValidatedReferenceField(Group, on_delete=ReferenceField.CASCADE)
description = fields.CharField(required=True)
survey_options = fields.DictField(required=True)
survey_result = fields.DictField(default=None)
class Meta:
write_concern = WriteConcern(w=1)
connection_alias = "reviewer"
final = True
class WorkflowResults(EmbeddedMongoModel):
parent = fields.CharField(blank=True)
status = fields.CharField(required=True, choices=["started", "finished"])
step_instance = fields.ReferenceField("Step_instance",
mongo_name="_step_instance",
blank=True)
start_date = fields.DateTimeField(required=True)
finish_date = fields.DateTimeField()
all = fields.DictField()
sample = fields.DictField()
batch_name = fields.CharField()
index = fields.IntegerField()
class Form(BaseMongoModel):
name = fields.CharField(required=True)
id = fields.ObjectIdField(primary_key=True)
schema = fields.DictField(required=True)
uiSchema = fields.DictField(required=True)
formOptions = fields.EmbeddedDocumentField(FormOptions, required=True)
couponCodes_used = fields.DictField(required=False)
cff_permissions = fields.DictField(required=True)
center = fields.CharField()
date_modified = fields.DateTimeField(required=True)
date_created = fields.DateTimeField(required=True)
formType = fields.CharField()
version = fields.IntegerField()
class MDBOuterFold(EmbeddedMongoModel):
class Meta:
final = True
connection_alias = 'photon_core'
fold_nr = fields.IntegerField(blank=True)
best_config = fields.EmbeddedDocumentField(MDBConfig, blank=True)
tested_config_list = fields.EmbeddedDocumentListField(MDBConfig, default=[], blank=True)
number_samples_test = fields.IntegerField(blank=True)
class_distribution_test = fields.DictField(blank=True, default={})
class_distribution_validation = fields.DictField(blank=True, default={})
number_samples_validation = fields.IntegerField(blank=True)
dummy_results = fields.EmbeddedDocumentField(MDBInnerFold, blank=True)
class MDBHyperpipeInfo(EmbeddedMongoModel):
class Meta:
final = True
connection_alias = "photon_core"
data = fields.DictField(blank=True)
cross_validation = fields.DictField(blank=True)
optimization = fields.DictField(blank=True)
flowchart = fields.CharField(blank=True)
metrics = fields.ListField(blank=True)
best_config_metric = fields.CharField(blank=True)
maximize_best_config_metric = fields.BooleanField(blank=True)
estimation_type = fields.CharField(blank=True)
eval_final_performance = fields.BooleanField(blank=True)
class Event(MongoModel):
category = fields.DictField(blank=True) # {id, name}
name = fields.CharField(blank=False)
start_date = fields.DateTimeField()
finish_date = fields.DateTimeField()
location = fields.DictField(blank=True) # { longitude, latitude }
source_type = fields.IntegerField(choices=SOURCES)
result_score = fields.DictField(
blank=True) # { usefulness, pleasure, fatigue }
user = fields.ReferenceField(User, on_delete=fields.ReferenceField.CASCADE)
color = fields.CharField(blank=True)
@property
def id(self):
return self._id
class RunningRace(EmbeddedMongoModel):
name = fields.CharField(verbose_name='Race Name', required=True)
distance_name = fields.CharField(verbose_name='Distance Description',
choices=('1 mile', '5k', '10k', '15k',
'half marathon', 'marathon'),
required=True)
distance_m = fields.FloatField(verbose_name='Distance [m]', required=True)
chip_time_s = fields.FloatField(verbose_name='Chip Time [s]',
mongo_name='ct_s',
required=True)
gun_time_s = fields.FloatField(verbose_name='Gun Time [s]',
mongo_name='gt_s',
required=True)
splits_s = fields.DictField()
overall_place = fields.IntegerField(verbose_name='Overall Place',
required=True)
overall_field_size = fields.IntegerField(
verbose_name='Size of Overall Field', required=True)
detailed_place = fields.DictField()
# photos = fields.ListField(fields.ImageField(), default=[])
supporting_files = fields.ListField(fields.FileField(), default=[])
@property
def distance(self):
return self.distance_m * ureg.meter
@property
def chip_time(self):
return self.chip_time_s * ureg.second
@property
def gun_time(self):
return self.gun_time_s * ureg.second
@property
def splits(self):
return {
split_name: split_time_s * uref.second
for split_name, split_time_s in self.splits_s.items()
}
@property
def overall_place_percent(self):
return round(100 * self.overall_place / float(self.overall_field_size),
1)
class TaskAttempts(MongoModel):
username = fields.CharField()
task_id = fields.CharField()
params_for_passback = fields.DictField()
training_count = fields.IntegerField()
training_scores = fields.OrderedDictField(blank=True)
is_passed_back = fields.OrderedDictField(blank=True)
class Tweets(MongoModel):
tweets_list = fields.ListField(fields.DictField())
objects = DefaultManager()
class Meta:
collection_name = 'Tweets'
final = True
class PersonSpecialization(MongoModel):
person_id = ValidatedReferenceField(Person,
on_delete=ReferenceField.CASCADE)
department_id = ValidatedReferenceField(Department,
on_delete=ReferenceField.CASCADE)
specialization_id = ValidatedReferenceField(
Specialization, on_delete=ReferenceField.CASCADE)
level = fields.FloatField(default=None, blank=True)
details = fields.DictField()
is_active = fields.BooleanField(required=True, default=True)
def save(self, cascade=None, full_clean=True, force_insert=False):
super().save(cascade, full_clean, force_insert)
update_person_subrating(PersonSpecialization, self.person_id)
class Meta:
write_concern = WriteConcern(w=1)
connection_alias = "reviewer"
final = True
indexes = [
IndexModel([("person_id", pymongo.DESCENDING),
("department_id", pymongo.DESCENDING),
("specialization_id", pymongo.DESCENDING)],
unique=True),
IndexModel("department_id"),
IndexModel("specialization_id")
]
class HealthContext(EmbeddedMongoModel):
status = fields.CharField()
isPhysicallyHurt = fields.BooleanField(default=False)
diseases = fields.ListField(fields.CharField())
aggressions = fields.ListField(fields.CharField())
injuries = fields.ListField(fields.CharField())
disorders = fields.DictField()
class MongoQueryIndexDocument(IterAssitant):
"""
process files from patentsview
"""
# summary is the same for the same query task
# all values should be str in summary of MongoQueryIndexDocument
summary = fields.DictField(default=None, required=True, blank=False)
# iter_index should in [boundary_lower, boundary_upper)
start_index = fields.IntegerField(default=0, required=True, blank=False)
boundary_lower = fields.IntegerField(default=0, required=True, blank=False)
boundary_upper = fields.IntegerField(default=0, required=True, blank=False)
max_num = fields.IntegerField(default=0, required=True, blank=False)
error_indices = fields.ListField(default=[], blank=True)
class Meta:
# https://pymodm.readthedocs.io/en/stable/api/index.html#metadata-attributes
collection_name = 'mongo_query_iter_index'
indexes = IterAssitant.Meta.indexes
ignore_unknown_fields = True
final=True
def clean(self):
# Custom validation that requires looking at several fields.
for v in self.summary.values():
if not isinstance(v, str):
raise pymodm.errors.ValidationError(
'Value in MongoQueryIndexDocument.summary should be str '
'instead of {}!'.format(type(v))
)
class Graph(MongoModel):
distances_matrix = fields.ListField(fields.ListField(fields.IntegerField()))
boundary = fields.DictField()
@cached_property
def nodes(self):
return GraphNode.objects.raw({'graph': self.pk})
def get_nearest_node(self, latitude, longitude, max_distance=3000, min_distance=0):
"""
:param latitude:
:param longitude:
:param max_distance:
:param min_distance:
:return:
"""
return GraphNode.objects.raw(
{
'graph': self.pk,
'point': {
'$near': {
'$geometry': {
'type': 'Point',
'coordinates': [latitude, longitude],
},
'$minDistance': min_distance,
'$maxDistance': max_distance,
}
}
}
).first()
class User(MongoModel):
name = fields.CharField(required=True, blank=False)
username = fields.CharField(
validators=[db_regex_validator(r'^[a-z0-9]+$')])
password_hash = fields.CharField()
target_score = fields.DictField(
blank=True) # { usefulness, pleasure, fatigue }
def _get_password_hash(self, password: str) -> str:
m = hashlib.sha256()
m.update(password.encode('utf-8'))
return m.digest().hex()
def set_password(self, password: str):
self.password_hash = self._get_password_hash(password)
def check_password(self, password: str) -> bool:
return safe_str_cmp(self.password_hash,
self._get_password_hash(password))
@property
def id(self):
return self._id
class Meta:
indexes = [
IndexModel([('username', ASCENDING)], unique=True, sparse=True)
]
class StrategyPosition(MongoModel):
""" 策略仓位信息 """
identifier = fields.IntegerField(primary_key=True)
# 策略的 ID
strategy_id = fields.IntegerField()
# 策略仓位信息
strategy_info = fields.DictField(default=None)
# 更新时间
update_date = fields.DateTimeField()
class Meta:
connection_alias = DB_POSITION
collection_name = CN_STRATEGY_POS
@classmethod
def position_with(cls, strategy_id):
"""获取仓位信息、无则创建 """
try:
obj = cls.objects.raw({'strategy_id': strategy_id}).first()
obj.update_date = datetime.now()
return obj
except Exception as e:
print(e)
position = cls(identifier=Sequence.fetch_next_id(CN_STRATEGY_POS),
strategy_id=strategy_id)
position.update_date = datetime.now()
position.save()
return position
class Forecast(MongoModel):
lat = fields.FloatField(required=True)
lng = fields.FloatField(required=True)
data = fields.DictField(required=True)
class Meta:
write_concern = WriteConcern(j=True)
connection_alias = 'recommend-ahp'
class Directions(MongoModel):
mode = fields.CharField(choices=('WALKING', 'DRIVING', 'BICYCLING', 'TRANSIT'), required=True)
priority = fields.FloatField(required=True)
data = fields.DictField(required=True)
class Meta:
write_concern = WriteConcern(j=True)
connection_alias = 'recommend-ahp'
class PaymentTrailItem(EmbeddedMongoModel):
value = fields.DictField()
date = fields.DateTimeField(required=True)
date_created = fields.DateTimeField()
date_modified = fields.DateTimeField()
method = fields.CharField(required=True)
status = fields.CharField()
id = fields.CharField()
class Dataset(MongoModel):
name = fields.CharField(required=True)
data_format = fields.CharField(required=True)
user_filename = fields.CharField(required=True)
upload_time = fields.DateTimeField(required=True)
analysis = fields.EmbeddedDocumentField(DatasetAnalysis, required=True)
queries = fields.DictField(blank=True)
class NetworkObject(MongoModel):
name = fields.CharField(max_length=MAX_LENGTH_CHAR)
properties = fields.DictField()
variables = fields.ListField(fields.ReferenceField(Variable))
connection_points = fields.ListField(fields.ReferenceField(Variable))
children = fields.ListField(fields.ObjectIdField())
interfaces = fields.ListField(
fields.ReferenceField(NetworkInterfaceObject))
class Config(MongoModel):
component_name = fields.CharField(primary_key=True)
config_params = fields.DictField()
@classmethod
def create_new(cls, component_name, config_params):
config = cls(component_name, config_params)
config.save()
class Record(MongoModel):
seq_id = fields.CharField(required=True)
description = fields.CharField(required=True)
sequence = fields.CharField(required=True)
discarded = fields.BooleanField(required=False)
analysis = fields.EmbeddedDocumentField(RecordAnalysis)
queries = fields.DictField(blank=True)
class Settings(MongoModel):
username = fields.CharField(primary_key=True, required=True)
last_modified = fields.DateTimeField(required=True)
data = fields.DictField(required=True, validators=[validate_settings])
class Meta:
write_concern = WriteConcern(j=True)
connection_alias = 'recommend-ahp'
