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 User(AuthModel):
fields = [
Field("money", "integer", default=0),
Field("avatar", "upload", uploadfolder='uploads'),
]
profile_visibility = {"avatar": (True, True)}
@fieldmethod('campaigns')
def get_campaigns(self, row):
return self.db.Campaign._find_owned(owner=row.auth_user.id)
@fieldmethod('donations')
def get_donations(self, row):
return self.db.Donation._find_owned(owner=row.auth_user.id)
@fieldmethod('backed_campaigns')
def get_backed_campaigns(self, row):
campaigns = self.db(
self.db.Donation.donator == row.auth_user.id).select(
self.db.Donation.campaign, groupby=self.db.Donation.campaign)
return len(campaigns)
@fieldmethod('backed_amount')
def get_backed_amount(self, row):
total = self.db.Donation.amount.sum()
row = self.db(self.db.Donation.donator == row.auth_user.id).select(
total, groupby=self.db.Donation.donator).first()
if row:
return row._extra[total]
return 0
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 B(Model):
tablename = "b"
a = Field()
b = Field(validation={'len': {'gte': 5}})
validation = {'a': {'len': {'gte': 5}}}
class Person(Model):
has_many(
'things', {'features': {'via': 'things'}}, {'pets': 'Dog.owner'},
'subscriptions')
name = Field()
age = Field('integer')
class User(AuthUser):
has_many('campaigns', 'donations')
money = Field('int', default=0)
avatar = Field('upload', uploadfolder='uploads')
form_profile_rw = {
"avatar": True
}
@rowmethod('backed_campaigns')
def get_backed_campaigns(self, row):
count = self.db.Donation.campaign.count()
return (
row.donations(
count, groupby=self.db.Donation.campaign).first() or {}
).get(count) or 0
@rowmethod('backed_amount')
def get_backed_amount(self, row):
total = self.db.Donation.amount.sum()
return (
self.db(self.db.Donation.user == row.id).select(
total, groupby=self.db.Donation.user).first() or {}
).get(total) or 0
class Donation(Model):
tablename = "donations"
fields = [
Field("donator", "reference auth_user"),
Field("campaign", "reference campaigns"),
Field("date", "datetime", default=lambda: request.now),
Field("amount", "integer")
]
visibility = {
"donator": (False, False),
"campaign": (False, False),
"date": (False, False)
}
validators = {
"amount": isIntInRange(1, None)
}
@modelmethod
def find_owned(db, entity, query=None, owner=None):
uid = owner or (session.auth.user.id if session.auth else None)
_query = (entity.donator == uid)
if query:
_query = _query & query
return db(_query).select()
class Donation(Model):
belongs_to('user', 'campaign')
date = Field('datetime', default=lambda: request.now)
amount = Field('integer')
form_rw = {"user": False, "campaign": False, "date": False}
validation = {'amount': {'gt': 1}}
class Comment(Model):
belongs_to('user', 'post')
text = Field('text')
date = Field('datetime')
default_values = {
'user': lambda: session.auth.user.id,
'date': lambda: request.now
}
validation = {'text': {'presence': True}}
form_rw = {'user': False, 'post': False, 'date': False}
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': lambda: request.now
}
validation = {'title': {'presence': True}, 'text': {'presence': True}}
form_rw = {'user': False, 'date': False}
class Cost(Model):
belongs_to('campaign')
name = Field(notnull=True)
date = Field('datetime', default=lambda: request.now)
amount = Field('integer')
form_rw = {
"campaign": False,
"date": False
}
validation = {
'amount': {'gt': 1}
}
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 Membership(Model):
belongs_to('user', 'organization')
role = Field()
@scope('admins')
def filter_admins(self):
return self.role == 'admin'
class Fortune(Model):
tablename = "fortune"
message = Field()
@rowmethod('serialize')
def _serialize(self, row):
return {'id': row.id, 'message': row.message}
class World(Model):
tablename = "world"
randomnumber = Field('int')
@rowmethod('serialize')
def _serialize(self, row):
return {'id': row.id, 'randomNumber': row.randomnumber}
class Comment(Model):
tablename = "comments"
fields = [
Field("author", "reference auth_user",
default=lambda: session.auth.user.id),
Field("post", "reference posts"),
Field("text", "text"),
Field("date", "datetime", default=lambda: request.now)
]
visibility = {
"author": (False, False),
"post": (False, False),
"date": (False, False)
}
validators = {
"text": isntEmpty()
}
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 Organization(Model):
name = Field()
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'}})
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 Campaign(Model):
tablename = "campaigns"
fields = [
Field("owner", "reference auth_user"),
Field("title", "string"),
Field("description", "text"),
Field("start", "datetime"),
Field("end", "datetime"),
Field("goal", "integer"),
Field("closed", "boolean", default=True),
]
visibility = {
"owner": (False, False),
"closed": (False, False)
}
validators = {
"title": isntEmpty(),
"description": isntEmpty(),
"goal": isIntInRange(1, None)
}
labels = {
"title": T("Title: ")
}
@fieldmethod('donations')
def get_donations(self, row):
cid = row.campaigns.id
return self.db(self.db.Donation.campaign == cid).select()
@fieldmethod('pledged')
def get_pledge(self, row):
donations = row.campaigns.donations()
amount = 0
for donation in donations:
amount += donation.amount
return amount
@fieldmethod('costs')
def get_costs(self, row):
cid = row.campaigns.id
return self.db(self.db.Cost.campaign == cid).select()
@fieldmethod('spended')
def get_spended(self, row):
costs = row.campaigns.costs()
amount = 0
for cost in costs:
amount += cost.amount
return amount
@modelmethod
def find_owned(db, entity, query=None, owner=None):
uid = owner or (session.auth.user.id if session.auth else None)
_query = (entity.owner == uid)
if query:
_query = _query & query
return db(_query).select(orderby=~entity.end)
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()
@virtualfield('pretty')
def get_pretty(self, row):
return row.name+" "+row.color
@before_insert
def bi2(self, *args, **kwargs):
pass
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 Consist(Model):
email = Field()
url = Field()
ip = Field()
image = Field('upload')
emails = Field('list:string')
emailsplit = Field('list:string')
validation = {
'email': {
'is': 'email'
},
'url': {
'is': 'url'
},
'ip': {
'is': 'ip'
},
'image': {
'is': 'image'
},
'emails': {
'is': 'list:email'
},
'emailsplit': {
'is': {
'list:email': {
'splitter': ',;'
}
}
}
}
class Animal(Model):
belongs_to('zoo')
name = Field()
@virtualfield('doublename')
def get_double_name(self, row):
return row.name*2
@virtualfield('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 Campaign(Model):
belongs_to('user')
has_many('donations', 'costs')
title = Field('string', notnull=True)
description = Field('string', notnull=True)
start = Field('datetime')
end = Field('datetime')
goal = Field('int')
closed = Field('bool', default=True)
form_rw = {"user": False, "closed": False}
validation = {
"goal": {
'gt': 1
},
"start": {
'gt': lambda: request.now,
'format': "%d/%m/%Y %H:%M:%S"
},
"end": {
'gt': lambda: request.now,
'format': "%d/%m/%Y %H:%M:%S"
}
}
form_labels = {"title": T("Title: ")}
@rowmethod('pledged')
def get_pledge(self, row):
summed = self.db.Donation.amount.sum()
return row.donations(summed).first()[summed] or 0
@rowmethod('spended')
def get_spended(self, row):
summed = self.db.Cost.amount.sum()
return row.costs(summed).first()[summed] or 0
class TModel(Model):
tablename = "test"
fields = [
Field("a", "string"),
Field("b"),
Field("price", "double"),
Field("quantity", "integer"),
Field("total", "double"),
Field("invisible")
]
validators = {"a": isntEmpty()}
visibility = {"invisible": (False, False)}
labels = {"a": "A label"}
comments = {"a": "A comment"}
updates = {"a": "a_update"}
representation = {"a": _represent_f}
widgets = {"a": _widget_f}
def setup(self):
self.entity.b.requires = notInDb(self.db, self.entity.b)
@computation('total')
def eval_total(self, row):
return row.price * row.quantity
@before_insert
def bi(self, fields):
return _call_bi(fields)
@after_insert
def ai(self, fields, id):
return _call_ai(fields, id)
@before_update
def bu(self, set, fields):
return _call_u(set, fields)
@after_update
def au(self, set, fields):
return _call_u(set, fields)
@before_delete
def bd(self, set):
return _call_d(set)
@after_delete
def ad(self, set):
return _call_d(set)
@virtualfield('totalv')
def eval_total_v(self, row):
return row.test.price * row.test.quantity
@fieldmethod('totalm')
def eval_total_m(self, row):
return row.test.price * row.test.quantity
@modelmethod
def method_test(db, entity, t):
return db, entity, t
