class Signature(Model):
refers_to({'created_by': 'User'}, {'updated_by': 'User'})
created_at = Field.datetime()
updated_at = Field.datetime()
#~ validation = {
#~ 'created_by': {'allow': 'empty'},
#~ 'updated_by': {'allow': 'empty'},
#~ }
default_values = {
'created_by': lambda: get_user(),
'updated_by': lambda: get_user(),
'created_at': lambda: local_now(),
'updated_at': lambda: local_now(),
}
update_values = {
'updated_by': lambda: get_user(),
'updated_at': lambda: local_now(),
}
fields_rw = {
'created_by': False,
'updated_by': False,
'created_at': False,
'updated_at': False,
}
class B(Model):
tablename = "b"
a = Field()
b = Field(validation={'len': {'gte': 5}})
validation = {'a': {'len': {'gte': 5}}}
class Len(Model):
a = Field()
b = Field()
c = Field()
d = Field()
validation = {
'a': {
'len': 5
},
'b': {
'len': {
'gt': 4,
'lt': 13
}
},
'c': {
'len': {
'gte': 5,
'lte': 12
}
},
'd': {
'len': {
'range': (5, 13)
}
}
}
class Organization(Model):
name = Field()
is_cover = Field.bool(default=False)
@has_many()
def admin_memberships3(self):
return Membership.admins()
has_many('memberships', {'users': {
'via': 'memberships'
}}, {'admin_memberships': {
'target': 'Membership',
'scope': 'admins'
}}, {'admins': {
'via': 'admin_memberships.user'
}}, {
'admin_memberships2': {
'target': 'Membership',
'where': lambda m: m.role == 'admin'
}
}, {'admins2': {
'via': 'admin_memberships2.user'
}}, {'admins3': {
'via': 'admin_memberships3.user'
}})
class Person(Model):
has_many('things', {'features': {
'via': 'things'
}}, {'pets': 'Dog.owner'}, 'subscriptions')
name = Field()
age = Field.int()
class Comment(Model):
belongs_to('user', 'post')
text = Field.text()
date = Field.datetime()
default_values = {'user': lambda: session.auth.user.id, 'date': now}
validation = {'text': {'presence': True}}
fields_rw = {'user': False, 'post': False, 'date': False}
class Subscription(Signature):
tablename = "subscriptions"
subscription = Field.json()
user_id = Field.int()
defaulf_values = {'user_id': 0}
@scope('by_user')
def _by_user(self, user_id):
return self.user_id == user_id
class Post(Model):
belongs_to('user')
has_many('comments')
title = Field()
text = Field.text()
date = Field.datetime()
default_values = {'user': lambda: session.auth.user.id, 'date': now}
validation = {'title': {'presence': True}, 'text': {'presence': True}}
fields_rw = {'user': False, 'date': False}
class Match(Model):
a = Field()
b = Field()
validation = {
'a': {
'match': 'ab'
},
'b': {
'match': {
'expression': 'ab',
'strict': True
}
}
}
class A(Model):
tablename = "a"
name = Field()
val = Field.int()
fval = Field.float()
text = Field.text()
password = Field.password()
d = Field.date()
t = Field.time()
dt = Field.datetime()
json = Field.json()
class World(Model):
tablename = "world"
randomnumber = Field.int()
@rowmethod('serialize')
def _serialize(self, row):
return {'id': row.id, 'randomNumber': row.randomnumber}
class Fortune(Model):
tablename = "fortune"
message = Field.string()
@rowmethod('serialize')
def _serialize(self, row):
return {'id': row.id, 'message': row.message}
class Membership(Model):
belongs_to('user', 'organization')
role = Field()
@scope('admins')
def filter_admins(self):
return self.role == 'admin'
class Eq(Model):
a = Field()
b = Field.int()
c = Field.float()
validation = {
'a': {
'equals': 'asd'
},
'b': {
'equals': 2
},
'c': {
'not': {
'equals': 2.4
}
}
}
class Subscription(Model):
belongs_to('person')
name = Field()
status = Field.int()
expires_at = Field.datetime()
STATUS = {'active': 1, 'suspended': 2, 'other': 3}
@scope('expired')
def get_expired(self):
return self.expires_at < datetime.now()
@scope('of_status')
def filter_status(self, *statuses):
if len(statuses) == 1:
return self.status == self.STATUS[statuses[0]]
return self.status.belongs(*[self.STATUS[v] for v in statuses])
class Thing(Model):
belongs_to('person')
name = Field()
color = Field()
uid = Field(unique=True)
validation = {
'name': {
'presence': True
},
'color': {
'in': ['blue', 'red']
},
'uid': {
'empty': False
}
}
class User(Model):
name = Field()
has_many('memberships', {'organizations': {
'via': 'memberships'
}}, {
'cover_orgs': {
'via': 'memberships.organization',
'where': lambda m: m.is_cover == True
}
})
class Elephant(Animal):
belongs_to('mouse')
color = Field()
@rowattr('pretty')
def get_pretty(self, row):
return row.name + " " + row.color
@before_insert
def bi2(self, *args, **kwargs):
pass
class Consist(Model):
email = Field()
url = Field()
ip = Field()
image = Field.upload()
emails = Field.string_list()
emailsplit = Field.string_list()
validation = {
'email': {
'is': 'email'
},
'url': {
'is': 'url'
},
'ip': {
'is': 'ip'
},
'image': {
'is': 'image'
},
'emails': {
'is': 'list:email'
},
'emailsplit': {
'is': {
'list:email': {
'splitter': ',;'
}
}
}
}
class Proc(Model):
a = Field()
b = Field()
c = Field()
d = Field()
e = Field.password()
f = Field.password()
validation = {
'a': {
'lower': True
},
'b': {
'upper': True
},
'c': {
'clean': True
},
'd': {
'urlify': True
},
'e': {
'len': {
'range': (6, 25)
},
'crypt': True
},
'f': {
'len': {
'gt': 5,
'lt': 25
},
'crypt': 'md5'
}
}
class Post(Signature):
tablename = "posts"
caption = Field.string(length=250)
location = Field.string(length=250)
photo = Field.upload()
date = Field.datetime()
default_values = {}
validation = {
'caption': {
'presence': True
},
'location': {
'presence': True
}
}
@after_insert
def send_notification(self, fields, rid):
# user_id = recover from created post
user_id = 5
subscriptions = Subscription.by_user(user_id).select()
message = {
"title": "Post created",
"body": "Este es el cuerpo de la notificación",
"openUrl": "/#/"
}
for subscription in subscriptions:
try:
webpush(subscription_info=json.loads(
json.dumps(subscription.subscription)),
data=json.dumps(message),
vapid_private_key=VAPID_PRIVATE_KEY,
vapid_claims=VAPID_CLAIMS)
except WebPushException as ex:
if '410 Gone' in str(ex):
subscription.delete_record()
class User(AuthUser):
tablename = 'auth_users'
avatar = Field.upload(autodelete=True)
email = Field.string(length=255)
has_many(
{'suscripciones': 'Suscripcion.user'},
{'posts': 'Post.user'},
)
default_vales = {}
validation = {
'email': {
'is': 'email'
},
}
form_labels = {
'email': 'Correo Electrónico',
'password': '******',
'first_name': 'Nombre',
'last_name': 'Apellido',
}
fields_rw = {}
rest_rw = {
# 'id': True,
}
@rowattr('nombre_completo')
def _nombre_completo(self, row):
return '%s %s' % (row.last_name.capitalize()
or '', row.first_name.capitalize() or '')
class Animal(Model):
belongs_to('zoo')
name = Field()
@rowattr('doublename')
def get_double_name(self, row):
return row.name * 2
@rowattr('pretty')
def get_pretty(self, row):
return row.name
@before_insert
def bi(self, *args, **kwargs):
pass
@before_insert
def bi2(self, *args, **kwargs):
pass
class Mixed(Model):
belongs_to('person')
date = Field.date()
type = Field()
inside = Field()
number = Field.int()
dont = Field()
yep = Field()
psw = Field.password()
validation = {
'date': {
'format': '%d/%m/%Y',
'gt': lambda: datetime.utcnow().date()
},
'type': {
'in': ['a', 'b'],
'allow': None
},
'inside': {
'in': ['asd', 'lol']
},
'number': {
'allow': 'blank'
},
'dont': {
'empty': True
},
'yep': {
'presence': True
},
'psw': {
'len': {
'range': (6, 25)
},
'crypt': True
}
}
class Sample(Model):
str = Field()
int = Field.int(default=0)
float = Field.float(default=0.0)
class Sample(Model):
str = Field()
int = Field.int()
float = Field.float()
datetime = Field.datetime()
class Sample(Model):
str = Field()
class Register(Model):
value = Field.int()
class StepOneThing(Model):
name = Field()
value = Field.float()
class StepFiveThing(Model):
name = Field()
value = Field.int()
created_at = Field.datetime()
indexes = {'name': True, ('name', 'value'): True}
