class ResponseZone(Model):
id = UUIDType(required=True)
name = StringType(required=True, min_length=3)
region_id = UUIDType(required=True)
vm_cluster = StringType(required=True)
vm_datastore = StringType(required=True)
vm_folder = StringType()
core_provision_percent = IntType(required=True)
ram_provision_percent = IntType(required=True)
schedulable = BooleanType(required=True)
state = EnumType(ZoneState, required=True)
current_task_id = UUIDType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, zone: Zone):
zone_model = cls()
zone_model.id = zone.id
zone_model.name = zone.name
zone_model.region_id = zone.region_id
zone_model.vm_cluster = zone.vm_cluster
zone_model.vm_datastore = zone.vm_datastore
zone_model.vm_folder = zone.vm_folder
zone_model.core_provision_percent = zone.core_provision_percent
zone_model.ram_provision_percent = zone.ram_provision_percent
zone_model.schedulable = zone.schedulable
zone_model.state = zone.state
zone_model.current_task_id = zone.current_task_id
zone_model.created_at = zone.created_at
zone_model.updated_at = zone.updated_at
return zone_model
class ResponseVolume(Model):
name = KubeName(required=True, min_length=3)
zone_name = UUIDType(required=True)
size = IntType(required=True)
attached_to = UUIDType()
state = EnumType(ResourceState, required=True)
task = EnumType(VolumeTask)
error_message = StringType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, volume: Volume):
model = cls()
model.name = volume.name
model.zone_name = volume.zone_name
model.size = volume.size
model.state = volume.state
model.attached_to = volume.attached_to_name
model.task = volume.task
model.error_message = volume.error_message
model.created_at = volume.created_at
model.updated_at = volume.updated_at
return model
class NewPublicKey(Model):
"""Input structure for a new public key."""
resource_id = UUIDType(required=True)
resource_type = StringType(required=True)
key_id = UUIDType()
expire_date = DateTimeType(serialized_format=helpers.RFC3339Milli,
tzd=u'utc')
label = StringType(required=True)
fingerprint = StringType()
key = StringType()
type = StringType()
# JWT parameters
kty = StringType() # rsa / ec
use = StringType() # sig / enc
alg = StringType() # algorithm
# Elliptic curve public key parameters (rfc7518 6.2.1)
crv = StringType()
x = LongType()
y = LongType()
class Options:
serialize_when_none = False
class NewMessage(Model):
"""New message parameter."""
attachments = ListType(ModelType(Attachment), default=lambda: [])
date = DateTimeType(serialized_format=helpers.RFC3339Milli, tzd=u'utc')
discussion_id = StringType() # = participants uris' hash
external_references = ModelType(ExternalReferences)
importance_level = IntType()
is_answered = BooleanType()
is_draft = BooleanType()
is_unread = BooleanType()
is_received = BooleanType()
message_id = UUIDType()
parent_id = UUIDType()
participants = ListType(ModelType(Participant), default=lambda: [])
privacy_features = DictType(StringType(), default=lambda: {})
pi = ModelType(PIParameter)
raw_msg_id = UUIDType()
subject = StringType()
tags = ListType(StringType(), default=lambda: [])
protocol = StringType(choices=MESSAGE_PROTOCOLS, required=False)
user_identities = ListType(UUIDType(), default=lambda: [])
@property
def external_msg_id(self):
return self.external_references.message_id if self.external_references \
else None
class Options:
serialize_when_none = False
@property
def hash_participants(self):
ids_hash = hash_participants_uri(self.participants)
return ids_hash['hash']
class ProposalExtension(WorksProposal):
"""Summary
"""
original_house: Type['smpa.models.work.WorkExtensionOriginalHouse'] = \
ModelType('smpa.models.work.WorkExtensionOriginalHouse')
incidental_buildings: Type['smpa.models.work.WorkExtensionIncidentalBuildings'] = \
ModelType('smpa.models.work.WorkExtensionIncidentalBuildings')
boundaries: Type['smpa.models.work.WorkExtensionBoundaries'] = \
ModelType('smpa.models.work.WorkExtensionBoundaries')
means_of_access: Type['smpa.models.work.WorkExtensionMeansOfAccess'] = \
ModelType('smpa.models.work.WorkExtensionMeansOfAccess')
parking: Type['smpa.models.work.WorkExtensionParking'] = \
ModelType('smpa.models.work.WorkExtensionParking')
trees: Type['smpa.models.work.WorkTrees'] = \
ModelType('smpa.models.work.WorkTrees')
materials: Type['smpa.models.material.MaterialExtension'] = \
ModelType('smpa.models.material.MaterialExtension')
additional_floor_area = FloatType()
additional_floor_area_units_id = RelType(
UUIDType(),
to_field='additional_floor_area_units',
service='AreaUnitService')
additional_floor_area_units = ModelType('smpa.models.unit.AreaUnit')
new_single_bedrooms = IntType()
new_double_bedrooms = IntType()
owner_id = RelType(UUIDType(), to_field='owner', service='UserService')
owner: Type['smpa.models.user.User'] = ModelType('smpa.models.user.User')
class User(SbbModel):
__tablename__ = 'user'
name = StringType(required=True)
complete_name = StringType()
email = EmailType(required=True)
salt = UUIDType(required=True, default=uuid.uuid4)
password = StringType(required=True, default=initial_password)
created_ts = IntType(required=True, default=time.time)
private_token = UUIDType(required=True, default=uuid.uuid4)
auth_token = UUIDType()
@property
def __key__(self):
return self.name
@property
def __namespace__(self):
return None
def check_password(self, clear_password):
return self.make_password(clear_password) == self.password
def make_password(self, clear_password):
if six.PY2:
return hashlib.sha256(clear_password + str(self.salt)).hexdigest()
if six.PY3:
return hashlib.sha256(
bytes(clear_password, 'utf-8') +
bytes(str(self.salt), 'utf-8')).hexdigest()
class ResponseImage(Model):
id = UUIDType(required=True)
name = StringType(required=True, min_length=3)
file_name = StringType(required=True)
locked = BooleanType(required=True)
visibility = EnumType(ImageVisibility, required=True)
region_id = UUIDType(required=True)
state = EnumType(ImageState, required=True)
current_task_id = UUIDType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, image: Image):
image_model = cls()
image_model.id = image.id
image_model.name = image.name
image_model.file_name = image.file_name
image_model.visibility = image.visibility
image_model.locked = image.locked
image_model.region_id = image.region_id
image_model.state = image.state
image_model.current_task_id = image.current_task_id
image_model.created_at = image.created_at
image_model.updated_at = image.updated_at
return image_model
class ResponseRegion(Model):
id = UUIDType(required=True)
name = StringType(required=True, min_length=3)
datacenter = StringType(required=True, )
image_datastore = StringType(required=True)
image_folder = StringType()
schedulable = BooleanType(required=True)
state = EnumType(RegionState, required=True)
current_task_id = UUIDType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, region: Region):
region_model = cls()
region_model.id = region.id
region_model.name = region.name
region_model.datacenter = region.datacenter
region_model.image_datastore = region.image_datastore
region_model.image_folder = region.image_folder
region_model.schedulable = region.schedulable
region_model.state = region.state
region_model.current_task_id = region.current_task_id
region_model.created_at = region.created_at
region_model.updated_at = region.updated_at
return region_model
class NewMessage(Model):
"""New message parameter."""
attachments = ListType(ModelType(Attachment), default=lambda: [])
date = DateTimeType(serialized_format=helpers.RFC3339Milli, tzd=u'utc')
discussion_id = UUIDType()
external_references = ModelType(ExternalReferences)
identities = ListType(ModelType(Identity), default=lambda: [])
importance_level = IntType()
is_answered = BooleanType()
is_draft = BooleanType()
is_unread = BooleanType()
is_received = BooleanType()
message_id = UUIDType()
parent_id = UUIDType()
participants = ListType(ModelType(Participant), default=lambda: [])
privacy_features = DictType(StringType(), default=lambda: {})
pi = ModelType(PIParameter)
raw_msg_id = UUIDType()
subject = StringType()
tags = ListType(StringType(), default=lambda: [])
type = StringType(choices=MESSAGE_TYPES)
class Options:
serialize_when_none = False
class DataReport(BaseModel):
_id = UUIDType(required=True)
workflow_id = UUIDType(required=True)
datasource_id = UUIDType(required=True)
MONGO_COLLECTION = 'datareports'
class Manifest(Model):
""" The manifest description. """
job_mode = StringType(
required=True, choices=["batch", "online", "instant_delivery"])
job_api_key = UUIDType(default=uuid.uuid4)
job_id = UUIDType(default=uuid.uuid4)
job_total_tasks = IntType()
requester_restricted_answer_set = DictType(DictType(StringType))
requester_description = StringType()
requester_max_repeats = IntType()
requester_min_repeats = IntType()
requester_question = DictType(StringType)
requester_question_example = URLType()
unsafe_content = BooleanType(default=False)
task_bid_price = DecimalType(required=True)
oracle_stake = DecimalType(required=True)
expiration_date = IntType()
requester_accuracy_target = FloatType(default=.1)
manifest_smart_bounty_addr = StringType()
minimum_trust_server = FloatType(default=.1)
minimum_trust_client = FloatType(default=.1)
recording_oracle_addr = StringType(required=True)
reputation_oracle_addr = StringType(required=True)
reputation_agent_addr = StringType(required=True)
requester_pgp_public_key = StringType()
# Future TODO: replace with KV lookup on recording_oracle_addr
# NOTE: URLType fails without TLD (examples: http://localhost/,
# http://exchange/, etc), so using StringType instead.
ro_uri = StringType()
repo_uri = StringType()
batch_result_delivery_webhook = URLType()
online_result_delivery_webhook = URLType()
instant_result_delivery_webhook = URLType()
request_type = StringType(
required=True,
choices=[
"image_label_binary", "image_label_multiple_choice_one_option",
"image_label_multiple_choice_multiple_options", "text_free_entry",
"text_multiple_choice_one_option",
"text_multiple_choice_multiple_options"
])
# if taskdata is directly provided
taskdata = ListType(ModelType(TaskData)) # ListType(DictType(StringType))
# if taskdata is separately stored
taskdata_uri = URLType()
def validate_taskdata_uri(self, data, value):
if data.get('taskdata') and len(
data.get('taskdata')) > 0 and data.get('taskdata_uri'):
raise ValidationError(
u'Specify only one of taskdata {} or taskdata_uri {}'.format(
data.get('taskdata'), data.get('taskdata_uri')))
return value
validate_taskdata = validate_taskdata_uri
class User(BaseModel, metaclass=ORMMeta):
"""Super simple user model to facilitate auth. All profile information
should live on other models.
Passwords are stored bcrypt hashed via passlib
"""
_uniques: list = [
'email',
]
class Options:
roles = {'default': blacklist('password', 'verification_token')}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.role_id is not None:
self.role = Role._service.first(id=self.role_id)
if self.profile_id is not None:
self.profile = UserProfile._service.first(id=self.profile_id)
email: str = StringType(max_length=200, required=True)
password: str = StringType(max_length=100)
profile_id = RelType(UUIDType(),
to_field='profile',
service='UserProfileService')
role_id = RelType(UUIDType(), to_field='role', service='RoleService')
role: Type[Role] = ModelType(Role)
profile: Type[UserProfile] = ModelType(UserProfile)
verified_at: datetime = DateTimeType()
verification_token: str = UUIDType()
reset_token: str = UUIDType()
reset_token_expires: datetime = DateTimeType()
@property
def verified(self):
"""Checks if the user's account is verified or not
Returns:
bool: Whether or not the user's account is verified
"""
if self.verified_at is None:
return False
else:
return True
@property
def is_admin(self):
self.export()
if self.role is None:
return False
if 'Admin' in self.role.name:
return True
return False
def __str__(self):
return f'<User: {self.email}>'
class FloatingIP(BaseModel):
floatingipid = UUIDType(serialized_name='floatingIpId')
fixedipaddress = IPv4Type(serialized_name='fixedIPAddress', default='')
floatingipaddress = IPv4Type(serialized_name='floatingIpAddress',
default='')
floatingnetworkid = UUIDType(serialized_name='floatingNetworkId')
portid = UUIDType(serialized_name='portId')
routerid = UUIDType(serialized_name='routerId')
class RequestCreateInstance(Model):
name = StringType(required=True, min_length=3)
image_id = UUIDType(required=True)
service_account_id = UUIDType()
network_id = UUIDType(required=True)
region_id = UUIDType(required=True)
zone_id = UUIDType()
keypair_ids = ListType(UUIDType, default=list)
tags = DictType(StringType)
class ResponseVerifyToken(Model):
user_id = UUIDType()
username = StringType()
driver = StringType()
service_account_id = UUIDType()
service_account_name = StringType()
project_id = UUIDType()
global_roles = ListType(StringType(), default=list)
project_roles = ListType(StringType(), default=list)
class TaskConnectionEntity(BaseEntity):
id = UUIDType(
default=lambda: uuid.uuid4(),
required=True,
)
from_task_id = UUIDType(required=True)
pipeline_id = UUIDType(required=True)
to_task_id = UUIDType(required=True)
class PublicKey(NewPublicKey):
"""Existing public key."""
user_id = UUIDType()
contact_id = UUIDType()
date_insert = DateTimeType(required=True)
date_update = DateTimeType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
class Media(Model):
id = UUIDType(print_name='_id')
owner = UUIDType()
title = StringType(max_length=40)
class Options:
roles = {
'meow': blacklist('owner'),
'woof': whitelist('id'),
}
class Message(NewMessage):
"""Existing message parameter."""
user_id = UUIDType()
message_id = UUIDType(required=True)
date_insert = DateTimeType(required=True)
text = StringType()
class Options:
roles = {'default': blacklist('user_id')}
class Email(NewEmail):
"""Existing email."""
user_id = UUIDType()
contact_id = UUIDType()
date_insert = DateTimeType(required=True)
date_update = DateTimeType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
class SocialIdentity(NewSocialIdentity):
"""Existing social identity."""
user_id = UUIDType()
contact_id = UUIDType()
date_insert = DateTimeType(required=True)
date_update = DateTimeType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
class PostalAddress(NewPostalAddress):
"""Existing postal address."""
address_id = UUIDType()
contact_id = UUIDType()
user_id = UUIDType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
serialize_when_none = False
class Participant(Model):
address = StringType()
contact_ids = ListType(UUIDType(), default=lambda: [])
label = StringType()
protocol = StringType()
type = StringType()
participant_id = UUIDType()
class Options:
serialize_when_none = False
class SocialIdentity(NewSocialIdentity):
"""Existing social identity."""
contact_id = UUIDType()
social_id = UUIDType()
user_id = UUIDType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
serialize_when_none = False
class Phone(NewPhone):
"""Existing phone."""
contact_id = UUIDType()
phone_id = UUIDType()
user_id = UUIDType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
serialize_when_none = False
class IM(NewIM):
"""Existing IM."""
contact_id = UUIDType()
im_id = UUIDType()
user_id = UUIDType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
serialize_when_none = False
class APIKey(Model):
key = UUIDType(required=True)
secret = UUIDType(required=True)
class Options:
serialize_when_none = False
roles = {
'safe': blacklist('secret'),
}
class Organization(NewOrganization):
"""Existing organization."""
contact_id = UUIDType()
deleted = BooleanType(default=False)
organization_id = UUIDType()
user_id = UUIDType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
serialize_when_none = False
class FinishRequest(Model):
id = UUIDType(required=True)
provider_id = UUIDType(required=True)
reference = StringType(required=True)
commercial_relationship = CommercialRelationshipType(required=True)
provider_config: ProviderConfig = ModelType(ProviderConfig, required=True)
provider_credentials: Optional[ProviderCredentials] = ModelType(
ProviderCredentials, default=None)
custom_data = DictType(BaseType, required=True)
class PostalAddress(NewPostalAddress):
"""Existing postal address."""
user_id = UUIDType()
contact_id = UUIDType()
address_id = UUIDType(required=True)
date_insert = DateTimeType(required=True)
date_update = DateTimeType()
class Options:
roles = {'default': blacklist('user_id', 'contact_id')}
