def profile(self, *args, **kwargs):
user = User.visible(request).filter(
User.username == request.user.username).one()
used = {
'total_repos': 0,
'cron_jobs': 0,
'api_keys': 0,
'users': 0,
'groups': 0,
'nodes': 0
}
used['total_repos'] = Repository.count(request)
used['cron_jobs'] = Job.count(request)
used['api_keys'] = ApiKey.count(request)
used['users'] = User.count(request)
used['groups'] = Group.count(request)
used['nodes'] = Node.count(request)
used['deployments'] = Deployment.count(request)
used['cloud_profiles'] = CloudProfile.count(request)
quotas = dict((k, dict(allowed=v, used=used[k]))
for k, v in request.user.tier._items.items()
if k in used)
return O.user(quotas=quotas,
plan=request.user.tier.name,
**user.serialize(skip=['id', 'org_id', 'password'],
rel=[('groups.name', 'groups')]))
def users(self, name=None, *args, **kwargs):
def modifier(roles):
return [
dict(as_user=role.as_user, servers=role.servers)
for role in roles
]
if name:
user = User.visible(request).filter(User.username == name).first()
return O.user(
user.serialize(skip=['id', 'org_id', 'password'],
rel=[('groups.name', 'groups')]))
else:
users = [
u.serialize(skip=['id', 'org_id', 'password'],
rel=[('groups.name', 'groups')]) for u in
User.visible(request).options(joinedload(User.groups)).all()
]
groups = [
u.serialize(skip=['id', 'org_id'],
rel=[
('roles', 'roles', modifier),
('users', 'users',
lambda us: [u.username for u in us]),
])
for u in Group.visible(request).options(joinedload(
Group.users)).options(joinedload(Group.roles)).all()
]
return O._anon(users=users,
groups=groups,
quota=dict(users=request.user.tier.users,
groups=request.user.tier.groups))
def add_profile(self, name, *args, **kwargs):
p_type = kwargs['type']
user = User.visible(request).filter(
User.id == request.user.id).first()
name = name or kwargs['name']
if p_type == "shared":
username = kwargs.pop('username')
password = kwargs.pop('password')
share = request.db.query(CloudShare).filter(
CloudShare.name == username,
CloudShare.password == password).first()
if not share:
return O.error(msg="The specified shared profile is not found")
prof = CloudProfile(name=name, username=username,
password=password,
owner=user,
type=share.profile.type,
shared=share.profile)
request.db.add(prof)
else:
username = kwargs.pop('username')
password = kwargs.pop('password')
arguments = kwargs.pop('arguments')
clear_nodes = (bool(kwargs.get('clear_nodes'))
and not kwargs.get('clear_nodes')
in ['0', 'false', 'False'])
prof = CloudProfile(name=name, username=username,
password=password, arguments=arguments,
owner=user,
clear_nodes=clear_nodes,
type=p_type)
request.db.add(prof)
def patch(self, username=None, *args, **kwargs):
name = username
user = User.visible(request).filter(User.username == name).first()
if not user:
return O.error(msg="User not found")
if not user.enabled:
# Allow only enabling
enable = kwargs.get("enable")
if not enable or enable not in ["1", "true", "True"]:
return O.error(msg="Cannot modify inactive user")
user.enabled = True
for k in set(kwargs.keys()).intersection(User.attrs):
setattr(user, k, kwargs[k])
groups = request.POST.getall('groups')
if groups:
to_remove = [g for g in user.groups if g.name not in groups]
for g in to_remove:
user.groups.remove(g)
grps = Group.visible(request).filter(Group.name.in_(groups)).all()
for g in grps:
user.groups.append(g)
else:
user.groups[:] = []
password = kwargs.get('password')
if password:
user.set_password(password)
phone = kwargs.get('phone')
if phone:
user.phone = phone
request.db.add(user)
def delete(self, username, *args):
name = username
user = User.visible(request).filter(User.username == name).first()
if not user:
return O.error(msg="User not found")
request.db.delete(user)
def rm_role(self, username=None, as_user=None, servers=None):
user = User.visible(request).filter(User.username == username).one()
role = [r for r in user.roles
if r.as_user == as_user and r.servers == servers]
if role:
map(request.db.delete, role)
request.db.commit()
def rm_role(self, username=None, as_user=None, servers=None):
user = User.visible(request).filter(User.username == username).one()
role = [
r for r in user.roles
if r.as_user == as_user and r.servers == servers
]
if role:
map(request.db.delete, role)
request.db.commit()
def create(self, username=None, *args, **kwargs):
username = username or kwargs['username']
email = kwargs['email']
password = kwargs['password']
first_name = kwargs['first_name']
last_name = kwargs['last_name']
department = kwargs['department']
position = kwargs['position']
org = request.db.query(Org).filter(Org.name == request.user.org).one()
new_user = User(username=username,
email=email,
first_name=first_name,
last_name=last_name,
department=department,
position=position,
org=org)
new_user.set_password(password)
request.db.add(new_user)
def add_role(self, username=None, **kwargs):
user = User.visible(request).filter(User.username == username).one()
as_user = str(kwargs['as_user'])
servers = kwargs['servers']
if as_user == '*':
as_user = "******"
elif not Role.is_valid(as_user):
return O.error(msg="Invalid user name: %s" % as_user)
role = Role(as_user=as_user, servers=servers)
user.roles.append(role)
request.db.commit()
def add_role(self, username=None, **kwargs):
user = User.visible(request).filter(User.username == username).one()
as_user = str(kwargs['as_user'])
servers = kwargs['servers']
if as_user == '*':
as_user = "******"
elif not Role.is_valid(as_user):
return O.error(msg="Invalid user name: %s" % as_user)
role = Role(as_user=as_user, servers=servers)
user.roles.append(role)
request.db.commit()
def profile(self, *args, **kwargs):
user = User.visible(request).filter(
User.username == request.user.username).one()
used = {'total_repos': 0, 'cron_jobs': 0,
'api_keys': 0, 'users': 0, 'groups': 0, 'nodes': 0}
used['total_repos'] = Repository.count(request)
used['cron_jobs'] = Job.count(request)
used['api_keys'] = ApiKey.count(request)
used['users'] = User.count(request)
used['groups'] = Group.count(request)
used['nodes'] = Node.count(request)
used['deployments'] = Deployment.count(request)
used['cloud_profiles'] = CloudProfile.count(request)
quotas = dict((k, dict(allowed=v, used=used[k]))
for k, v in request.user.tier._items.items()
if k in used)
return O.user(quotas=quotas,
plan=request.user.tier.name,
**user.serialize(
skip=['id', 'org_id', 'password'],
rel=[('groups.name', 'groups')]))
def roles(self, username=None, *args):
user = User.visible(request).filter(User.username == username).one()
roles = []
def append_roles(r):
return roles.extend(r)
map(append_roles, [group.roles for group in user.groups])
roles.extend(user.roles)
return O.roles(roles=[r.serialize(
skip=['id', 'group_id', 'user_id'],
rel=([('group.name', 'group')])) for r in roles],
quota=dict(allowed=request.user.tier.roles))
def account(self, *args, **kwargs):
"""
.. http:get:: /billing/account
Returns basic account information
>header: Auth token
"""
CS = request.braintree.CustomerSearch
customers = [
c for c in request.braintree.Customer.search(
CS.company == request.user.org).items
]
if not customers:
# Try to create customer
user = User.visible(request).filter(
User.username == request.user.username).one()
result = request.braintree.Customer.create({
"first_name": user.first_name,
"last_name": user.last_name,
"company": user.org.name,
"email": user.email,
"phone": user.phone,
})
if not result.is_success:
return O.error("Cannot fetch data from billing system")
customers = [result.customer]
customer = customers[0]
card, subs = {}, {}
if customer.credit_cards:
cc = customer.credit_cards[0]
card['number'] = cc.masked_number
card['expire'] = cc.expiration_date
card['type'] = cc.card_type
if cc.subscriptions:
sub = cc.subscriptions[0]
subs['next_date'] = sub.next_billing_date
subs['next_amount'] = sub.next_billing_period_amount
TS = request.braintree.TransactionSearch
history = request.braintree.Transaction.search(
[TS.customer_company == request.user.org])
return O.billing(transactions=[serialize_t(h) for h in history.items],
plan=subs,
cards=card)
def roles(self, username=None, *args):
user = User.visible(request).filter(User.username == username).one()
roles = []
def append_roles(r):
return roles.extend(r)
map(append_roles, [group.roles for group in user.groups])
roles.extend(user.roles)
return O.roles(roles=[
r.serialize(skip=['id', 'group_id', 'user_id'],
rel=([('group.name', 'group')])) for r in roles
],
quota=dict(allowed=request.user.tier.roles))
def create(self, name, **kwargs):
if request.method != "POST":
return O.none()
name = name or kwargs['name']
try:
user = User.visible(request).filter(
User.id == request.user.id).first()
content = kwargs.pop('content')
if not isinstance(content, dict):
content = json.loads(content)
_validate(content)
except KeyError, kerr:
return O.error(msg="Missing content data: %s" % kerr)
def account(self, *args, **kwargs):
"""
.. http:get:: /billing/account
Returns basic account information
>header: Auth token
"""
CS = request.braintree.CustomerSearch
customers = [c for c in request.braintree.Customer.search(
CS.company == request.user.org).items]
if not customers:
# Try to create customer
user = User.visible(request).filter(
User.username == request.user.username).one()
result = request.braintree.Customer.create({
"first_name": user.first_name,
"last_name": user.last_name,
"company": user.org.name,
"email": user.email,
"phone": user.phone,
})
if not result.is_success:
return O.error("Cannot fetch data from billing system")
customers = [result.customer]
customer = customers[0]
card, subs = {}, {}
if customer.credit_cards:
cc = customer.credit_cards[0]
card['number'] = cc.masked_number
card['expire'] = cc.expiration_date
card['type'] = cc.card_type
if cc.subscriptions:
sub = cc.subscriptions[0]
subs['next_date'] = sub.next_billing_date
subs['next_amount'] = sub.next_billing_period_amount
TS = request.braintree.TransactionSearch
history = request.braintree.Transaction.search([
TS.customer_company == request.user.org])
return O.billing(transactions=[serialize_t(h) for h in history.items],
plan=subs, cards=card)
def add_profile(self, name, *args, **kwargs):
p_type = kwargs['type']
user = User.visible(request).filter(User.id == request.user.id).first()
name = name or kwargs['name']
if p_type == "shared":
username = kwargs.pop('username')
password = kwargs.pop('password')
share = request.db.query(CloudShare).filter(
CloudShare.name == username,
CloudShare.password == password).first()
if not share:
return O.error(msg="The specified shared profile is not found")
prof = CloudProfile(name=name,
username=username,
password=password,
owner=user,
type=share.profile.type,
shared=share.profile)
request.db.add(prof)
else:
username = kwargs.pop('username')
password = kwargs.pop('password')
arguments = kwargs.pop('arguments')
clear_nodes = (
bool(kwargs.get('clear_nodes'))
and not kwargs.get('clear_nodes') in ['0', 'false', 'False'])
prof = CloudProfile(name=name,
username=username,
password=password,
arguments=arguments,
owner=user,
clear_nodes=clear_nodes,
type=p_type)
request.db.add(prof)
def profile_update(self, **kwargs):
user = User.visible(request).filter(
User.username == request.user.username).one()
for k in set(kwargs.keys()).intersection(User.attrs):
setattr(user, k, kwargs[k])
request.db.add(user)
def profile_update(self, **kwargs):
user = User.visible(request).filter(
User.username == request.user.username).one()
for k in set(kwargs.keys()).intersection(User.attrs):
setattr(user, k, kwargs[k])
request.db.add(user)