class SubmissionLogDocument(DocumentBase):
"""
The processed submission log document. It will contain metadata about the submission. (Eg: source,
submitted_on etc.)
along with the parsed key value pairs of the sms that came in
"""
submitted_on = TZAwareDateTimeField()
source = TextField()
destination = TextField()
channel = TextField()
values = DictField()
status = BooleanField()
voided = BooleanField()
error_message = TextField()
form_code = TextField()
data_record_id = TextField()
test = BooleanField()
def __init__(self, source=None, channel=None, destination=None, values=None, id=None, status=None,
error_message=None, form_code=None, data_record_id=None, voided=None, test=None):
DocumentBase.__init__(self, id, 'SubmissionLog')
self.source = source
self.submitted_on = utcnow()
self.channel = channel
self.destination = destination
self.form_code = form_code
self.values = values
self.status = status
self.error_message = error_message
self.data_record_id = data_record_id
self.voided = voided
self.test = test
class RingsSchema(Document):
_id = TextField()
added = DateTimeField(default=datetime.now)
license = TextField()
public = BooleanField(default=False)
rings = ListField(
DictField(
Mapping.build(RingName=TextField(),
RingLabel=TextField(),
RingDescription=TextField(),
RingVersion=TextField(),
RingURI=TextField(),
RingBuild=TextField(),
RingParent=TextField())))
fields = ListField(
DictField(
Mapping.build(
FieldId=TextField(),
FieldName=TextField(),
FieldLabel=TextField(),
FieldSemantic=TextField(),
FieldType=TextField(),
FieldSource=TextField(),
FieldWidget=TextField(),
FieldOrder=IntegerField(),
FieldCardinality=TextField(),
FieldMultilingual=BooleanField(),
FieldRequired=BooleanField(),
FieldDefault=TextField(),
FieldHint=TextField(),
FieldLayer=IntegerField(),
)))
class FormModelDocument(DocumentBase):
metadata = DictField()
name = TextField()
# type = TextField()
label = TextField()
form_code = TextField()
is_registration_model = BooleanField(default=False)
json_fields = ListField(DictField())
validators = ListField(DictField())
snapshots = DictField()
xform = TextField()
is_media_type_fields_present = BooleanField(default=False)
def __init__(self, id=None):
DocumentBase.__init__(self, id=id, document_type='FormModel')
self.metadata[attributes.ACTIVE_LANGUAGES] = []
@property
def active_languages(self):
return self.metadata[attributes.ACTIVE_LANGUAGES]
@active_languages.setter
def active_languages(self, language):
self.metadata[attributes.ACTIVE_LANGUAGES] = language
def set_label(self, label):
self.label = label
class SurveyResponseDocument(DocumentBase):
"""
The processed submission log document. It will contain metadata about the submission. (Eg: source,
submitted_on etc.)
along with the parsed key value pairs of the sms that came in
"""
submitted_on = TZAwareDateTimeField()
owner_uid = TextField()
destination = TextField()
created_by = TextField()
modified_by = TextField()
channel = TextField()
values = DictField()
status = BooleanField()
error_message = TextField()
form_model_id = TextField()
form_model_revision = TextField()
data_record_id = TextField()
event_time = TZAwareDateTimeField()
data_record_history = ListField(TextField())
def __init__(self,
channel=None,
destination=None,
values=None,
id=None,
status=None,
error_message=None,
form_model_id=None,
form_model_revision=None,
data_record_id=None,
event_time=None,
modified_by_id=None,
owner_uid=None):
DocumentBase.__init__(self, id, 'SurveyResponse')
self.submitted_on = utcnow()
self.channel = channel
self.destination = destination
self.created_by = self.modified_by = modified_by_id
self.form_model_id = form_model_id
self.form_model_revision = form_model_revision
self.values = values
self.status = status
self.error_message = error_message
self.data_record_id = data_record_id
self.event_time = event_time if event_time is not None else self.created
self.data_record_history = []
self.owner_uid = owner_uid
@property
def is_anonymous_submission(self):
return self.get('is_anonymous_submission', False)
@is_anonymous_submission.setter
def is_anonymous_submission(self, value):
if value:
self['is_anonymous_submission'] = True
else:
del self['is_anonymous_submission']
class TweetData(Document):
_id = TextField()
original_text = TextField()
text = TextField()
no_spell_text = TextField()
label = IntegerField()
tfid_features = TextField()
features = TextField()
geo_code = TextField()
is_read = BooleanField()
has_processed = BooleanField()
coordinates = TextField()
columns = DictField()
lga_code = IntegerField()
tag_food = BooleanField()
tag_politic = BooleanField()
class UsageData(Document):
"""
Document that represents the stored data.
"""
url = TextField()
ua_browser = TextField()
ua_language = TextField()
ua_platform = TextField()
ua_version = TextField()
blueprint = TextField()
view_args = TextField()
status = IntegerField()
remote_addr = TextField()
authorization = BooleanField()
ip_info = TextField()
path = TextField()
speed = FloatField()
datetime = DateTimeField(default=datetime.now)
username = TextField()
track_var = TextField()
by_date = ViewField(
'start-end', '''function(doc, req) {
if (!doc._conflicts) {
emit(doc.datetime, doc);
}
}''')
class DocumentBase(Document):
created = TZAwareDateTimeField()
modified = TZAwareDateTimeField()
document_type = TextField()
void = BooleanField()
def __init__(self, id=None, document_type=None, **values):
if id is None:
id = uuid1().hex
Document.__init__(self, id=id, **values)
self.created = utcnow()
self.document_type = document_type
self.void = False
def post_update(self, dbm, pre_save_object):
if hasattr(self.__class__, 'registered_functions'):
for callback in self.__class__.registered_functions:
try:
callback(self, dbm,
pre_save_object) if pre_save_object else callback(
self, dbm)
except Exception as e:
logging.error(e.message)
raise
@classmethod
def register_post_update(cls, func):
if not hasattr(cls, 'registered_functions'):
cls.registered_functions = []
cls.registered_functions.append(func)
class DB_Structure(Document):
_id = TextField()
url = TextField()
ref = TextField()
Discovered = DateTimeField()
LastAccessed = DateTimeField()
title = TextField()
is_alive = BooleanField()
raw_code = TextField()
class RequestRide(Document):
doc_type = TextField(default='request_ride')
postedby = TextField()
origin = TextField()
destination = TextField()
acceptedby = TextField()
accepted = BooleanField(default="False")
def save(self):
db = DataBase.db()
self.store(db)
class DocumentBase(Document):
created = TZAwareDateTimeField()
modified = TZAwareDateTimeField()
document_type = TextField()
void = BooleanField()
def __init__(self, id=None, document_type=None, **values):
if id is None:
id = uuid1().hex
Document.__init__(self, id=id, **values)
self.created = utcnow()
self.document_type = document_type
self.void = False
class ProjectDocument(FormModelDocument):
goals = TextField()
devices = ListField(TextField())
sender_group = TextField()
reminder_and_deadline = DictField()
data_senders = ListField(TextField())
is_outgoing_sms_replies_enabled = BooleanField()
is_poll = BooleanField()
active = TextField()
end_date = TZAwareDateTimeField()
def __init__(self, id=None):
super(ProjectDocument, self).__init__(id)
@property
def is_open_survey(self):
return self.get('is_open_survey', False)
@is_open_survey.setter
def is_open_survey(self, value):
if value:
self['is_open_survey'] = True
elif self.is_open_survey:
del self['is_open_survey']
class MediaDocument(DocumentBase):
name = TextField()
size = FloatField()
questionnaire_id = TextField()
is_preview = BooleanField()
def __init__(self,
id=None,
attachment_name=None,
attachment_size=None,
questionnaire_id=None,
is_preview=False):
DocumentBase.__init__(self, id=id, document_type='MediaDetails')
self.name = attachment_name
self.size = attachment_size
self.questionnaire_id = questionnaire_id
self.is_preview = is_preview
class User(Document):
name = TextField()
password = TextField()
exclusions = ListField(TextField())
dataInstances = ListField(
DictField(
Mapping.build(task_name=TextField(),
start_time=DateTimeField(),
end_time=DateTimeField(),
suggested_time=IntegerField(),
pre_energy=IntegerField(),
user_feedback=IntegerField(),
auto_rating=BooleanField())))
breakInstances = ListField(
DictField(
Mapping.build(break_start_time=DateTimeField(),
break_end_time=DateTimeField())))
usernameView = ViewField(
'users', '''\
function(doc) {
emit(doc.name, doc);
}''')
def get_favorites(self):
favs = []
for inst in self.dataInstances:
if inst.task_name not in favs and inst.task_name not in self.exclusions:
favs.append(inst.task_name)
return favs
@property
def is_active(self):
return True
@property
def is_authenticated(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.name)
class ReportConfigDocumentBase(DocumentBase):
name = TextField()
description = TextField()
type = TextField()
template_url = TextField()
total_in_label = BooleanField()
remove_options = ListField(TextField())
def __init__(self):
DocumentBase.__init__(self, document_type='ReportConfig')
@classmethod
def document(cls, data):
if 'type' in data and data['type'] == 'ExternalConfig':
return ExternalReportConfigDocument.wrap(data)
elif 'type' in data and data['type'] == 'EntityConfig':
return EntityReportConfigDocument.wrap(data)
else:
return ReportConfigDocument.wrap(data)
class Per_Conf(Document):
id = TextField()
build_id = TextField()
count = IntegerField()
hash_key = TextField()
os_label = TextField()
test_runner = TextField()
handlers = ListField(TextField(), name='handler')
schedule_time = DateTimeField()
shedule = ListField(TextField(), name='day')
to_run = BooleanField()
slot = TextField()
filename = TextField()
project = TextField()
platform = TextField()
test_group = ListField(TextField(), name='group')
schedule_type = TextField()
test_env = TextField()
type = TextField()
class URL(Document):
target = TextField()
public = BooleanField()
added = DateTimeField(default=datetime.utcnow())
shorty_id = TextField(default=None)
db = None
@classmethod
def load(cls, id):
return super(URL, cls).load(URL.db, id)
@classmethod
def query(cls, code):
return URL.db.query(code)
def store(self):
if getattr(self._data, "id", None) is None:
new_id = self.shorty_id if self.shorty_id else None
while 1:
id = new_id if new_id else get_random_uid()
try:
docid = URL.db.resource.put(content=self._data,
path="/%s/" % str(id))["id"]
except Exception:
continue
if docid:
break
self._data = URL.db.get(docid)
else:
super(URL, self).store(URL.db)
return self
@property
def short_url(self):
return url_for("link", uid=self.id, _external=True)
def __repr__(self):
return "<URL %r>" % self.id
class User(Document):
username = TextField()
password = TextField()
password_check = TextField(default='')
groups = ListField(TextField)
active = BooleanField()
@classmethod
def authenticate(cls, db, username, password):
"""Use view ``auth/user_by_name`` to check authentification.
Return a :class:`~repoze.what.plugins.couchdbkit.documents.User` object on success.
"""
results = cls.view(db, 'auth/user_by_name', key=username)
for user in results.rows:
if user and user.active and encrypt_value(
password) == user.password:
return user
break
def encrypt_password(self):
"""Encrypt password whith sha1 if not already done"""
if self.password and self.password != self.password_check:
self.password = encrypt_value(self.password)
self.password_check = self.password
class VoltLogFiles(Document):
date = TextField()
processed = BooleanField()
class Container(Document):
name = TextField()
container_type = TextField()
size = DictField(Mapping.build(
amount = DecimalField(),
unit = TextField()
))
contents = ListField(DictField(Mapping.build(
amount = DecimalField(),
unit = TextField(),
content = TextField(),
updated_datetime = DateTimeField(default=datetime.now),
temperature = DictField(Mapping.build(
degrees = DecimalField(),
unit = TextField()
)),
content_type = TextField()
)))
full = BooleanField(default=False)
def total_filled(self):
"""Return the amount of filled content. However, there is no weight to volume conversion.
E.g. weight is free in volume-organized container
volume is free in weight-organized containers
"""
total_amount = 0
target_unit = self.size.unit
for content in self.contents:
if content.unit in VOLUME_UNITS and target_unit in WEIGHT_UNITS:
continue
converted_amount = convert_amount( (content.amount, content.unit), target_unit)
total_amount += converted_amount
return (total_amount, target_unit)
def heat_contents(self, temp_tuple):
"""Set all the contents of the container to be a temperature of temp_tuple
temp_tuple is (amount, units), e.g. (70, 'C')
"""
if temp_tuple[1].upper() not in TEMP_UNITS:
raise ContainerError("Unable to use the specified temperature unit %s" % (temp_tuple[1]))
else:
for content in self.contents:
content.temperature = dict( degrees = temp_tuple[0],
unit = temp_tuple[1].upper()
)
def set_size(self, size_tuple):
if not ((size_tuple[1].lower() in WEIGHT_UNITS) or (size_tuple[1].lower() in VOLUME_UNITS)):
raise ContainerError("Unable to use the specified unit: %s" % (size_tuple[1]))
self.size = {'amount': size_tuple[0],
'unit': size_tuple[1].lower() }
def determine_content_type(self, content):
if "wort" in content.lower():
return ContentType.Wort
elif "hops" in content.lower():
return ContentType.Hops
elif "yeast" in content.lower():
return ContentType.Yeast
elif "malt" in content.lower():
return ContentType.Malt
elif "water" in content.lower():
return ContentType.Water
elif "beer" in content.lower():
return ContentType.Beer
def add_content(self, content, amount, temp = (23, "C"), content_type=None, updated_datetime=None):
"""
:param amount - may be dictionary: {"amount": amount, "unit": unit}, or tuple (amount, unit)
"""
if not updated_datetime:
updated_datetime=datetime.now()
LOGGER.info("Attempting to add content %s (amount %s, temp %s)", content, amount, temp)
amount_dict = {}
temp_dict = {}
if not content_type:
content_type = self.determine_content_type(content)
if "unit" not in amount:
amount_dict = {"amount": amount[0],
"unit": amount[1]}
else:
amount_dict = amount
if amount_dict["unit"] != self.size.unit and amount_dict["unit"] in VOLUME_UNITS:
raise ContainerError("Only able to add volume content measured in '{0}'".format(self.size.unit))
#Assume room temperature
if "unit" not in temp:
temp_dict = {"degrees": 23,
"unit": "C"}
else:
temp_dict = temp
if not amount_dict:
raise ContainerError("Amount must be provided as (amount, unit) or as dictinoary ")
# adding_amount is the value to add to the container
adding_amount = amount_dict["amount"]
if amount_dict["unit"] != self.size.unit:
try:
adding_amount = convert_amount(amount_dict, self.size.unit)
except ContainerError as e:
LOGGER.info("Unable to convert to unit %s. Not adding any volume. %s", self.size.unit, e)
adding_amount = 0
filled = self.total_filled()
if float(filled[0]) + float(adding_amount) > self.size.amount:
adding_amount = self.size.amount - filled[0]
self.contents.append(
dict( amount = adding_amount,
unit = self.size.unit,
content = content,
temperature = temp_dict,
content_type = content_type,
updated_datetime = updated_datetime,
)
)
raise ContainerError("Error filling container: trying to add too much, only %s %s added (%s %s not added)" % (adding_amount, self.size.unit, amount_dict["amount"] - adding_amount, self.size.unit))
LOGGER.info("Adding full content %s %s %s" % (content, amount_dict["amount"], amount_dict["unit"]))
self.contents.append(
dict( amount = amount_dict["amount"],
unit = amount_dict["unit"],
content = content,
temperature = temp_dict,
content_type = content_type,
updated_datetime = updated_datetime,
))
if self.total_filled()[0] >= self.size.amount:
self.full = True
def remove_all(self):
"""Remove all contents, and return a list
"""
removed = []
for content in self.contents:
removed.extend(self.remove_content(content.content, (content.amount, content.unit)))
return removed
def add_all(self, content_list):
"""content_list is a list of tuples ('content',(amount, unit), (degrees, unit))
add the specified content to the list
"""
LOGGER.info("Adding contents to container: %s", content_list)
if not content_list:
LOGGER.info("No contents to add")
return
for content in content_list:
LOGGER.info("Attempting to add content %s", content)
#for (content, amount_tuple, temperature_tuple) in content_list:
try:
self.add_content(content[0], content[1], content[2])
LOGGER.info("Added content: %s", content)
except IndexError:
LOGGER.error("Unable to add content %s", content)
def remove_content(self, content, amount_tuple):
"""Remove the specified amount of content
:return a list of tuples of the removed contents (content, amount, temperature)
"""
if content not in [ c.content for c in self.contents ]:
raise ContainerError("Unable to remove the specify contents %s. The container is not currently filled with any")
same_content = [ c for c in self.contents if c.content.lower() == content ]
reducing_amount = amount_tuple[0]
reducing_unit = amount_tuple[1]
all_removed = []
for current_content in self.contents:
if current_content.content.lower() == content.lower():
reducing_amount = convert_amount( (reducing_amount, reducing_unit), current_content.unit)
LOGGER.info("Converted amount to remove: %s %s", reducing_amount, current_content.unit)
if reducing_amount > current_content.amount:
LOGGER.info("Amount reduce %s %s more than current contained content %s %s", reducing_amount, current_content.unit, current_content.amount, current_content.unit)
reducing_amount = current_content.amount
content_tuple = (content,
(reducing_amount, current_content.unit),
(current_content.temperature.degrees, current_content.temperature.unit))
LOGGER.info("Removed content Appending content, amount, temperature %s to removed list %s", content_tuple, all_removed)
# Reduce the total amount of content to be removed
reducing_amount -= current_content.amount
all_removed.append(content_tuple)
current_content.amount = 0
else:
# Remove everything specified
LOGGER.info("Removing full specified amount %s %s", reducing_amount, current_content.unit)
current_content.amount -= reducing_amount
content_tuple = (content,
{"amount": reducing_amount,
"unit": current_content.unit},
{"degrees": current_content.temperature.degrees,
"unit": current_content.temperature.unit})
LOGGER.info("Updated content amount after reduction: %s %s", current_content.amount, current_content.unit)
#LOGGER.info("Removed list: appending content, amount, temperature %s to removed list %s", content_tuple, all_removed)
LOGGER.info("Removed list addition: %s", content_tuple)
all_removed.append(content_tuple)
LOGGER.info("List of all removed contents: %s", all_removed)
# Remove the empty contents
self.contents = [ c for c in self.contents if c.amount ]
if self.total_filled()[0] < self.size.amount:
self.full = False
LOGGER.info("All removed content: %s", all_removed)
return all_removed
class HomeState(Document):
home_id = TextField()
type = TextField(default="home_state")
name = TextField()
time = DateTimeField()
periodic_update = BooleanField()
devices = ListField(DictField())
# Model 1
def feature_vector(self):
feature_vector = []
# Ensure all times are in UTC when creating feature vectors
utctime = datetime.utcfromtimestamp(self.time.timestamp())
# Append with day of week
feature_vector.append(utctime.weekday())
# Append with hour and minute number in 10 minutes interval
feature_vector.append(utctime.hour)
feature_vector.append(int(utctime.minute / 10))
# Loop over all devices sorted by ID - this will ensure the same order of features for every feature vector
for device in sorted(self.devices, key=lambda d: d['device_id']):
device_feature_vector = self.feature_vector_device(device)
if device_feature_vector != None:
feature_vector.extend(device_feature_vector)
return feature_vector
# Model 2
def feature_vector_for_output_device(self, output_device):
feature_vector = []
# Ensure all times are in UTC when creating feature vectors
utctime = datetime.utcfromtimestamp(self.time.timestamp())
# Append with day of week
feature_vector.append(utctime.weekday())
# Append with hour and minute number in 15 minutes interval
feature_vector.append(utctime.hour)
feature_vector.append(utctime.minute / 15)
# Loop over all devices sorted by ID - this will ensure the same order of features for every feature vector
for device in sorted(self.devices, key=lambda d: d['device_id']):
if output_device['device_id'] != device['device_id']:
device_feature_vector = self.feature_vector_device(device)
if device_feature_vector != None:
feature_vector.extend(device_feature_vector)
return feature_vector
# Model 3
def feature_vector_for_output_device_in_same_location(self, output_device):
feature_vector = []
# Ensure all times are in UTC when creating feature vectors
utctime = datetime.utcfromtimestamp(self.time.timestamp())
# Append with day of week
feature_vector.append(utctime.weekday())
# Append with hour and minute number in 15 minutes interval
feature_vector.append(utctime.hour)
feature_vector.append(utctime.minute / 15)
# Loop over all devices sorted by ID - this will ensure the same order of features for every feature vector
for device in sorted(self.devices, key=lambda d: d['device_id']):
print(device)
if output_device['device_id'] != device[
'device_id'] and output_device['location'] == device[
'location']:
device_feature_vector = self.feature_vector_device(device)
if device_feature_vector != None:
feature_vector.extend(device_feature_vector)
return feature_vector
def output_vector(self):
output_vector = []
# Loop over all devices sorted by ID - this will ensure the same order of features for every output vector
for device in sorted(self.devices, key=lambda d: d['device_id']):
device_output_vector = self.output_vector_device(device)
if device_output_vector != None:
output_vector.extend(device_output_vector)
return output_vector
def output_devices(self):
return [
device for device in self.devices
if device['type'] in ('BinaryPowerSwitchDevice', 'DimmerDevice')
]
def output_vector_device(self, device):
if device['type'] == 'DimmerDevice':
return [device['state']]
elif device['type'] == 'BinaryPowerSwitchDevice':
return [1 if device['state'] > 1 else 0]
else: # Other devices does not generate a feature vector
return None
def output_vector_for_device_id(self, device_id):
# Find output device based on id
device = next(device for device in self.devices
if device['device_id'] == device_id)
if device['type'] == 'DimmerDevice':
return device['state']
elif device['type'] == 'BinaryPowerSwitchDevice':
return 1 if device['state'] > 1 else 0
else: # Other devices does not generate a feature vector
return None
def feature_vector_device(self, device):
if device['type'] == 'BinarySensorDevice':
return [1 if device['state'] > 1 else 0]
elif device['type'] == 'MultiSensorDevice':
return [1 if device['state'] > 1 else 0, device['lux'] / 2]
elif device['type'] == 'BinaryPowerSwitchDevice':
return [device['power_state']]
else: # Other devices does not generate a feature vector
return None
class User(Document):
doc_type = TextField(default='user')
name = TextField()
username = TextField()
email = TextField()
password = TextField()
dob = DateTimeField(default=None)
phone = IntegerField()
gender = BooleanField()
created = DateTimeField(default=datetime.now)
@classmethod
def get_user(cls, id):
db = DataBase.db()
user = db.get(id, None)
# print user
if user is None:
return None
return cls.wrap(user)
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return self.email
@classmethod
def all(cls):
db = DataBase.db()
return cls.view(db, '_design/user/_view/all-users')
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def save(self):
db = DataBase.db()
db[self.email] = self._data
def update(self, name=None, phone=None, email=None, password=None):
db = DataBase.db()
if name and name != '':
self.name = name
if phone and phone != '':
self.phone = phone
if email and email != '':
self.email = email
if password and password != '':
self.set_password(password)
self.store(db)
class MyRingUser(Document):
_id = TextField()
#firstname = TextField() DEPRECATED! Use "name" for firstname if needed
name = TextField()
lastname = TextField()
email = TextField()
billingemail = TextField()
is_org = BooleanField()
location = TextField()
url = TextField()
profilepic = TextField()
about = TextField()
#people = DictField()
onlogin = TextField()
people = ListField(
DictField(
Mapping.build(handle=TextField(),
addedby=TextField(),
added=DateTimeField(default=datetime.now))))
teams = ListField(
DictField(
Mapping.build(
teamname=TextField(),
members=ListField(
DictField(
Mapping.build(
handle=TextField(),
addedby=TextField(),
added=DateTimeField(default=datetime.now)))),
rings=ListField(
DictField(
Mapping.build(
handle=TextField(),
ringname=TextField(),
addedby=TextField(),
added=DateTimeField(default=datetime.now)))),
roles=ListField(
DictField(
Mapping.build(
role=TextField(),
addedby=TextField(),
added=DateTimeField(default=datetime.now)))),
addedby=TextField(),
added=DateTimeField(default=datetime.now))))
salt = TextField()
passhash = TextField()
guid = TextField()
added = DateTimeField(default=datetime.now)
branchof = TextField()
rings = ListField(
DictField(
Mapping.build(ringname=TextField(),
version=TextField(),
count=IntegerField(),
added=DateTimeField(default=datetime.now),
roles=ListField(
DictField(
Mapping.build(role=TextField(),
users=ListField(
Mapping.build())))))))
collections = ListField(
DictField(
Mapping.build(collectionname=TextField(),
collectiondescription=TextField(),
version=TextField(),
added=DateTimeField(default=datetime.now),
rings=ListField(
DictField(
Mapping.build(handle=TextField(),
ringname=TextField(),
version=TextField(),
layer=IntegerField()))),
roles=ListField(
DictField(
Mapping.build(role=TextField(),
users=ListField(
Mapping.build())))))))
badges = ListField(
DictField(
Mapping.build(badgename=TextField(),
badgedescription=TextField(),
added=DateTimeField(default=datetime.now))))
campaigns = ListField(
DictField(
Mapping.build(campaignname=TextField(),
campaigndescription=TextField(),
added=DateTimeField(default=datetime.now))))
is_active = BooleanField(default=True)
is_authenticated = BooleanField(default=False)
new_password_key = TextField()
new_password_requested = DateTimeField()
new_email = TextField()
new_email_key = TextField()
last_login = DateTimeField()
last_ip = TextField()
modified = DateTimeField(default=datetime.now)
