class Office(Model):
class Meta:
table_name = 'OfficeModel'
host = "http://localhost:{}".format(environ['DOCKER_PORT'])
office_id = NumberAttribute(hash_key=True)
address = Location()
employees = ListAttribute(of=OfficeEmployeeMap)
departments = UnicodeSetAttribute()
numbers = NumberSetAttribute()
def test_unicode_set_serialize(self):
"""
UnicodeSetAttribute.serialize
"""
attr = UnicodeSetAttribute()
self.assertEqual(attr.attr_type, STRING_SET)
self.assertEqual(attr.deserialize(None), None)
self.assertEqual(
attr.serialize(set([six.u('foo'), six.u('bar')])),
sorted([six.u('foo'), six.u('bar')])
)
class Thread(Model):
class Meta:
table_name = 'Thread'
forum_name = UnicodeAttribute(hash_key=True)
subject = UnicodeAttribute(range_key=True)
views = NumberAttribute(default=0)
replies = NumberAttribute(default=0)
answered = NumberAttribute(default=0)
tags = UnicodeSetAttribute()
last_post_datetime = UTCDateTimeAttribute()
class BtcNodeIdentifier(Model):
"""
Class representing mapping from node identifier to list of addresses
that belong to the node. We think of this as the all the addresses
a particular user controls
"""
class Meta:
table_name = 'btc_node_ids'
node_id = NumberAttribute(hash_key=True)
addresses = UnicodeSetAttribute(default=set([]))
class AliasedModel(Model):
class Meta:
table_name = "AliasedModel"
host = "http://localhost:8000"
forum_name = UnicodeAttribute(hash_key=True, attr_name='fn')
subject = UnicodeAttribute(range_key=True, attr_name='s')
views = NumberAttribute(default=0, attr_name='v')
replies = NumberAttribute(default=0, attr_name='rp')
answered = NumberAttribute(default=0, attr_name='an')
tags = UnicodeSetAttribute(attr_name='t')
last_post_datetime = UTCDateTimeAttribute(attr_name='lp')
class KeyValueEntry(Model):
class Meta:
table_name = os.environ["DYNAMODB_TABLE"]
if "LOCAL" in os.environ:
host = "http://localhost:8000"
else:
region = "us-west-1"
host = "https://dynamodb.us-west-1.amazonaws.com"
key = UnicodeAttribute(hash_key=True, null=False)
value = UnicodeSetAttribute(null=False)
def test_unicode_set_deserialize(self):
"""
UnicodeSetAttribute.deserialize old way
"""
attr = UnicodeSetAttribute()
value = set([six.u('foo'), six.u('bar')])
old_value = set([json.dumps(val) for val in value])
self.assertEqual(
attr.deserialize(old_value),
value
)
class Thread(Model):
class Meta:
read_capacity_units = 1
write_capacity_units = 1
table_name = "Thread"
host = "http://localhost:8000"
forum_name = UnicodeAttribute(hash_key=True)
subject = UnicodeAttribute(range_key=True)
views = NumberAttribute(default=0)
replies = NumberAttribute(default=0)
answered = NumberAttribute(default=0)
tags = UnicodeSetAttribute()
last_post_datetime = UTCDateTimeAttribute(null=True)
class Order(Base, discriminator="Order"):
email = UnicodeAttribute()
items = UnicodeSetAttribute()
size = SetSizeAttribute(source="items")
gsi1_pk = CompoundTemplateAttribute(
template="ORDER#$email",
attrs=["email"],
)
gsi1_sk = CopiedULIDAttribute(source="ulid")
gsi2_pk = CompoundTemplateAttribute(
template="BYSIZE#$size",
attrs=["size"],
)
gsi2_sk = CopiedIntegerAttribute(source="ulid")
class AttributeTestModel(Model):
class Meta:
host = 'http://localhost:8000'
table_name = 'test'
binary_attr = BinaryAttribute()
binary_set_attr = BinarySetAttribute()
number_attr = NumberAttribute()
number_set_attr = NumberSetAttribute()
unicode_attr = UnicodeAttribute()
unicode_set_attr = UnicodeSetAttribute()
datetime_attr = UTCDateTimeAttribute()
bool_attr = BooleanAttribute()
json_attr = JSONAttribute()
class User(Model):
class Meta:
table_name = 'users'
read_capacity_units = 3
write_capacity_units = 3
if 'PYCOFFEE_DEV' in os.environ:
host = "http://local.docker:8000"
else:
region = "us-west-2"
coffee_id = UnicodeAttribute(hash_key=True)
user_id = UnicodeAttribute(range_key=True)
session_key = UnicodeAttribute(default="")
votes = UnicodeSetAttribute()
class Service(Model):
class Meta:
table_name = app.config.get('DYNAMODB_TABLE')
if app.config.get('DYNAMODB_URL'):
host = app.config.get('DYNAMODB_URL')
id = UnicodeAttribute(hash_key=True)
data_type = UnicodeAttribute()
data_type_date_index = DataTypeDateIndex()
data_type_revision_index = DataTypeRevisionIndex()
revision = NumberAttribute()
enabled = BooleanAttribute(default=True)
credentials = UnicodeSetAttribute(default=set([]))
modified_date = UTCDateTimeAttribute(default=datetime.now)
modified_by = UnicodeAttribute()
class Office(Model):
class Meta:
table_name = "OfficeModel"
host = "http://localhost:{}".format(environ.get("DOCKER_PORT", 8000))
aws_access_key_id = "my_access_key_id"
aws_secret_access_key = "my_secret_access_key"
office_id = UUIDAttribute(hash_key=True)
address = Location()
employees = ListAttribute(of=OfficeEmployeeMap)
departments = UnicodeSetAttribute()
numbers = NumberSetAttribute()
security_number = UnicodeAttribute(null=True)
office_times = ListAttribute()
cls = DiscriminatorAttribute()
def test_round_trip_unicode_set(self):
"""
Round trip a unicode set
"""
attr = UnicodeSetAttribute()
orig = set([six.u('foo'), six.u('bar')])
assert orig == attr.deserialize(attr.serialize(orig))
orig = set([six.u('true'), six.u('false')])
assert orig == attr.deserialize(attr.serialize(orig))
orig = set([six.u('1'), six.u('2.8')])
assert orig == attr.deserialize(attr.serialize(orig))
orig = set([six.u('[1,2,3]'), six.u('2.8')])
assert orig == attr.deserialize(attr.serialize(orig))
def test_unicode_set_serialize(self):
"""
UnicodeSetAttribute.serialize
"""
attr = UnicodeSetAttribute()
assert attr.attr_type == STRING_SET
assert attr.deserialize(None) is None
expected = sorted([six.u('foo'), six.u('bar')])
assert attr.serialize(set([six.u('foo'), six.u('bar')])) == expected
expected = sorted([six.u('True'), six.u('False')])
assert attr.serialize(set([six.u('True'), six.u('False')])) == expected
expected = sorted([six.u('true'), six.u('false')])
assert attr.serialize(set([six.u('true'), six.u('false')])) == expected
def test_unicode_set_serialize(self):
"""
UnicodeSetAttribute.serialize
"""
attr = UnicodeSetAttribute()
assert attr.attr_type == STRING_SET
assert attr.deserialize(None) is None
expected = sorted(['foo', 'bar'])
assert attr.serialize({'foo', 'bar'}) == expected
expected = sorted(['True', 'False'])
assert attr.serialize({'True', 'False'}) == expected
expected = sorted(['true', 'false'])
assert attr.serialize({'true', 'false'}) == expected
def test_round_trip_unicode_set(self):
"""
Round trip a unicode set
"""
attr = UnicodeSetAttribute()
orig = {'foo', 'bar'}
assert orig == attr.deserialize(attr.serialize(orig))
orig = {'true', 'false'}
assert orig == attr.deserialize(attr.serialize(orig))
orig = {'1', '2.8'}
assert orig == attr.deserialize(attr.serialize(orig))
orig = {'[1,2,3]', '2.8'}
assert orig == attr.deserialize(attr.serialize(orig))
def test_unicode_set_deserialize(self):
"""
UnicodeSetAttribute.deserialize
"""
attr = UnicodeSetAttribute()
value = {'foo', 'bar'}
assert attr.deserialize(value) == value
value = {'True', 'False'}
assert attr.deserialize(value) == value
value = {'true', 'false'}
assert attr.deserialize(value) == value
value = {'1', '2.8'}
assert attr.deserialize(value) == value
def test_unicode_set_deserialize(self):
"""
UnicodeSetAttribute.deserialize
"""
attr = UnicodeSetAttribute()
value = set([six.u('foo'), six.u('bar')])
assert attr.deserialize(value) == value
value = set([six.u('True'), six.u('False')])
assert attr.deserialize(value) == value
value = set([six.u('true'), six.u('false')])
assert attr.deserialize(value) == value
value = set([six.u('1'), six.u('2.8')])
assert attr.deserialize(value) == value
class MemberModel(Model):
class Meta:
table_name = 'members'
region = 'us-west-2'
read_capacity_units = 5
write_capacity_units = 5
uid = UnicodeAttribute(hash_key=True)
last_logged_in_stamp = NumberAttribute(default=time.time())
last_logged_in = UnicodeAttribute(default='')
username = UnicodeAttribute(default='')
location = UnicodeAttribute(default='')
pics = UnicodeSetAttribute(default=set())
msgs = JSONAttribute(default=[])
phone = UnicodeAttribute(default='')
last_updated = NumberAttribute(default=time.time())
last_full_updated = NumberAttribute(default=0)
class Topic(Model):
class Meta:
table_name = 'topics'
read_capacity_units = 10
write_capacity_units = 10
if 'PYCOFFEE_DEV' in os.environ:
host = "http://local.docker:8000"
else:
region = "us-west-2"
coffee_id = UnicodeAttribute(hash_key=True)
topic_id = UnicodeAttribute(range_key=True)
creator_id = UnicodeAttribute()
title = UnicodeAttribute(default="")
description = UnicodeAttribute(default="")
votes = UnicodeSetAttribute()
state = UnicodeAttribute(default="to_discuss")
endtime = UTCDateTimeAttribute(default=datetime.datetime.utcnow())
class VanifyModel(Model):
class Meta:
table_name = "ConnectVanify"
region = "us-east-1"
contact_id = UnicodeAttribute(attr_name="contactId", hash_key=True)
caller_id = UnicodeAttribute(range_key=True, attr_name="callerId")
date = UTCDateTimeAttribute()
input = UnicodeAttribute(default_for_new=datetime.now)
results = UnicodeSetAttribute()
def as_dict(self):
"""Dump instance as dict."""
date = self.date.astimezone(timezone.utc).strftime(DATETIME_FORMAT)
attrs = self.attribute_values
attrs["date"] = date
attrs["results"] = list(self.results)
return attrs
class Project(Model):
class Meta:
table_name = 'projects'
region = 'eu-west-1'
id = UnicodeAttribute(hash_key=True)
name = UnicodeAttribute()
members = UnicodeSetAttribute(null=True)
owner = UnicodeAttribute()
def __iter__(self):
yield 'id', self.id
yield 'name', self.name
yield 'owner', self.owner
yield 'members', list(self.members) if self.members is not None else []
def all_members(self):
return (self.members
if self.members is not None else set()) | {self.owner}
class MetaData(Model):
class Meta:
table_name = db_name
region = "ap-northeast-2"
read_capacity_units = 1
write_capacity_units = 1
file = UnicodeAttribute(hash_key=True)
timestamp = UTCDateTimeAttribute(range_key=True,
default=datetime.now(tz=timezone.utc))
trees_count = NumberAttribute(null=True)
species = UnicodeSetAttribute(null=True)
species_count = UnicodeAttribute(null=True)
min_num = NumberAttribute(null=True)
max_num = NumberAttribute(null=True)
min_height = NumberAttribute(null=True)
max_height = NumberAttribute(null=True)
description = UnicodeAttribute(null=True)
upload_by = UnicodeAttribute(null=True)
uploader = UnicodeAttribute(null=True)
class BlindCredential(Model):
class Meta:
table_name = app.config.get('DYNAMODB_TABLE')
if app.config.get('DYNAMODB_URL'):
host = app.config.get('DYNAMODB_URL')
region = app.config.get('AWS_DEFAULT_REGION')
id = UnicodeAttribute(hash_key=True)
revision = NumberAttribute()
data_type = UnicodeAttribute()
data_type_date_index = DataTypeDateIndex()
name = UnicodeAttribute()
credential_pairs = JSONAttribute()
credential_keys = UnicodeSetAttribute(default=set([]), null=True)
enabled = BooleanAttribute(default=True)
data_key = JSONAttribute()
cipher_version = NumberAttribute()
cipher_type = UnicodeAttribute()
metadata = JSONAttribute(default={}, null=True)
modified_date = UTCDateTimeAttribute(default=datetime.now)
modified_by = UnicodeAttribute()
class UserModel(GenericModel):
class Meta(GenericMeta):
table_name = os.getenv('TABLE_USERS', 'd-users')
columns = (
('username', UnicodeAttribute(hash_key=True)),
('active', BooleanAttribute(null=True)),
('first_name', UnicodeAttribute(null=True)),
('middle_name', UnicodeAttribute(null=True)),
('last_name', UnicodeAttribute(null=True)),
('email', UnicodeAttribute()),
('bio', UnicodeAttribute(null=True)),
('phone', UnicodeAttribute(null=True)),
('street_address', UnicodeAttribute(null=True)),
('city', UnicodeAttribute(null=True)),
('state', UnicodeAttribute(null=True)),
('zip_code', UnicodeAttribute(null=True)),
('user_roles', UnicodeSetAttribute(null=True)),
)
for column in columns:
locals()[column[0]] = column[1]
class Advertisement(Model):
class Meta:
table_name = "atnap_advertisement"
region = region
title = UnicodeAttribute(null=False)
advertiserTaxId = UnicodeAttribute(null=False, hash_key=True)
category = UnicodeAttribute(null=False, range_key=True)
phoneNumber = UnicodeAttribute(null=False)
description = UnicodeAttribute(null=False)
whatsAppApi = UnicodeAttribute(null=True)
picturesUrl = UnicodeAttribute(null=True)
socialMedia = UnicodeAttribute(null=True)
tags = UnicodeSetAttribute(null=True)
price = NumberAttribute(null=False)
created = UTCDateTimeAttribute(null=False, default=datetime.now())
updated = UTCDateTimeAttribute(null=True)
deletedBy = UnicodeAttribute(null=True)
@classmethod
def newItem(cls, title, category, description, phoneNumber,
price, advertiserTaxId, whatsAppApi=None,
tags=None, socialMedia=None, picturesUrl=None):
advertisement = Advertisement(
title=title,
category=category,
description=description,
tags=tags,
price=price,
advertiserTaxId=advertiserTaxId,
phoneNumber=phoneNumber,
picturesUrl=picturesUrl,
whatsAppApi=whatsAppApi,
socialMedia=socialMedia,
)
return advertisement.save()
@classmethod
def deleteItem(cls, taxId, email):
advertisement = Advertisement(
taxId=taxId,
email=email
)
return advertisement.delete()
@classmethod
def updateItem(cls, **kwargs):
user = Advertisement.get(
kwargs.get("advertiserTaxId"),
)
user.refresh()
user.update(actions=[
Advertisement.phoneNumber.set(kwargs.get("phoneNumber")) or Advertisement.phoneNumber,
Advertisement.updated.set(datetime.now())
])
@classmethod
def detailedAdvertisement(cls, advertisement):
return {
"fullName": advertisement.fullName,
"companyName": advertisement.companyName,
"taxId": advertisement.taxId,
"email": advertisement.email,
"phoneNumber": advertisement.phoneNumber,
"created": advertisement.created.strftime("%Y-%m-%d"),
}
@classmethod
def createTable(cls):
if not Advertisement.exists():
Advertisement.create_table(
read_capacity_units=10,
write_capacity_units=10,
wait=True
)
@classmethod
def queryByTaxId(cls, taxId):
queryResult = []
for item in Advertisement.query(taxId):
queryResult.append(cls.json(item))
return queryResult
@classmethod
def dropTable(cls):
if Advertisement.exists():
Advertisement.delete_table()
@classmethod
def tableDefinitions(cls):
if Advertisement.exists():
return Advertisement.describe_table()
@classmethod
def json(cls, advertisement):
return {
"title": advertisement.title,
"description": advertisement.description,
"taxId": advertisement.advertiserTaxId,
"category": advertisement.category,
"whatsAppApi": advertisement.whatsAppApi,
"phoneNumber": advertisement.phoneNumber,
"price": advertisement.price,
"tags": (list(advertisement.tags)) if advertisement.tags else "None",
"created": advertisement.created.strftime("%Y-%m-%d"),
}
class TaskModel(Model):
"""
DynamoDB TaskModel
"""
class Meta():
table_name = os.environ['tasksTable']
if 'IS_LOCAL' in os.environ:
host = 'http://localhost:8000'
else:
region = os.environ['AWS_REGION']
host = 'https://dynamodb.{}.amazonaws.com'.format(region)
id = UnicodeAttribute(hash_key=True)
name = UnicodeAttribute()
description = UnicodeAttribute()
taskListId = UnicodeAttribute()
tasks_gsi_taskListId = TaskListIdIndex()
userIds = UnicodeSetAttribute()
done = BooleanAttribute(default=False)
createdAt = UTCDateTimeAttribute(default=datetime.now())
updatedAt = UTCDateTimeAttribute(default=datetime.now())
deleteFlag = BooleanAttribute(default=False)
def __iter__(self):
for name, attr in self.get_attributes().items():
if name != 'deleteFlag':
yield name, attr.serialize(getattr(self, name))
@classmethod
def get(cls,
hash_key,
range_key=None,
consistent_read=False,
attributes_to_get=None):
"""
override: get()
"""
task = super().get(hash_key, range_key, consistent_read,
attributes_to_get)
if not task.deleteFlag:
return task
else:
raise cls.DoesNotExist()
def update(self, actions=[], condition=None):
actions.append(TaskModel.updatedAt.set(datetime.now()))
super().update(actions, condition)
def save(self, condition=None):
self.before_save()
self.updatedAt = datetime.now()
super().save(condition)
def before_save(self):
# validation for name
if not self.name:
raise InvalidNameError('The name attribute has not to be empty')
if not isinstance(self.name, str):
raise InvalidNameError('The name attribute has to be string')
# validation for description
if not self.description:
raise InvalidDescriptionError(
'The description attribute has not to be empty')
if not isinstance(self.description, str):
raise InvalidDescriptionError(
'The description attribute has to be string')
# validation for taskListId
if not self.taskListId:
raise InvalidTaskListError(
'The taskListId attribute has not to be empty')
if not isinstance(self.taskListId, str):
raise InvalidTaskListError(
'The taskListId attribute has to be string')
try:
self.get_task_list()
except models.task_list_model.TaskListModel.DoesNotExist:
raise InvalidTaskListError('The taskList does not exist')
# validation for userIds
if not (isinstance(self.userIds, list)
or isinstance(self.userIds, set)):
raise InvalidUserError('The userIds attribute has to be array')
else:
for user_id in self.userIds:
if not isinstance(user_id, str):
raise InvalidUserError('The userIds contains only strings')
try:
self.get_users()
except models.user_model.UserModel.DoesNotExist:
raise InvalidUserError('The userIds contains a invalid userId')
def get_task_list(self):
task_list = models.task_list_model.TaskListModel.get(self.taskListId)
return task_list
def get_users(self):
users = []
for user_id in self.userIds:
user = models.user_model.UserModel.get(user_id)
users.append(user)
return users
def logic_delete(self):
"""
change deleteFlag to True
"""
actions = [TaskModel.deleteFlag.set(True)]
self.update(actions)
def status_update(self, flag):
"""
change done_flag
"""
actions = [TaskModel.done.set(flag)]
self.update(actions)
def user_ids_update(self, user_ids, flag):
user_ids = set(user_ids)
for user_id in user_ids:
try:
models.user_model.UserModel.get(user_id)
except models.user_model.UserModel.DoesNotExist:
raise InvalidUserError('The userIds contains a invalid userId')
if flag:
actions = [TaskModel.userIds.add(user_ids)]
else:
actions = [TaskModel.userIds.delete(user_ids)]
self.update(actions)
class MultiValue(MapAttribute):
flag = BooleanAttribute(null=True)
name = UnicodeAttribute(null=True)
number = NumberAttribute(null=True)
nameset = UnicodeSetAttribute(null=True)
class DefaultsMap(MapAttribute):
map_field = MapAttribute(default={})
string_set_field = UnicodeSetAttribute(null=True)
