from flask import current_app
import user as us
import campaign
from BasicCRUD import BasicCRUD
from apps.geofencing.dbmodels.sqldb.administration.account import Account as _account_table
from apps.geofencing.dbmodels.sqldb.administration.join__user__account import JoinUserAccount as _join__user_account_table
from apps.geofencing.extensions.sqldb import sqldb
from apps.geofencing.middleware.pandora.pandora import Pandora
def clean_name(name):
name = name.replace(' ', '').replace('.', '---')
return name
[docs]class AccountApi(BasicCRUD):
[docs] def create(self, user=None, name=None, permission=None, **kwargs):
"""
Creates an Account DB Reccord
:param User user: SQL Alchemy DB object
:param AdminPermission permission: SQL Alchemy DB object
:param string name: account name
:keyword bucket_name: AWS S3 bucket name for the account. If none the account name used to generate one.
:return:
"""
if name is None:
raise ValueError('AccountApi name is null!')
cleaned_name = clean_name(name)
if not current_app.config.get('TESTING', False): # Prevents confusion with test data
if name.find('test') > 0:
raise ValueError('Invalid - account name cannot contain the word "test"')
bucket_name = 'df-geofencing-content-{0}'.format(cleaned_name)
if 'bucket_name' in kwargs:
bucket_name = kwargs['bucket_name']
new_account = _account_table(name=name, bucket_name=bucket_name, **kwargs)
new_account.delete_flag = None
sqldb.session.add(new_account)
self.commit()
if not current_app.config.get('TESTING', False):
Pandora().createNewS3Bucket(bucket_name) # Each account should have separate buckets
if user is not None:
if not hasattr(user, 'id'):
user = us.UserApi().get(id=user)
self.add_user(user, new_account, permission)
return new_account
[docs] def get_all(self, delete_flag=None, **kwargs):
"""
Accepts same arguements as get but return's all matching reccords.
:param delete_flag:
:param kwargs:
"""
return _account_table.query.filter_by(delete_flag=delete_flag, **kwargs)
[docs] def get(self, delete_flag=None, **kwargs):
"""
Query the accounts datbase table by the key value pairs passed in.
:param delete_flag:
:param kwargs:
:return: a single account object.
"""
return self.get_all(delete_flag=delete_flag, **kwargs).first()
[docs] def delete(self, account):
"""
Delte a single account
:param account:
:return:
"""
# disjoin the relationships with user first
join_user_list = account.r_user
for joinUser in join_user_list:
us.UserApi().disjoin__user__account(joinUser.r_user, account)
campaign_list = account.r_campaign
for camp in campaign_list:
campaign.CampaignApi().delete(camp)
self._delete_self(account)
@classmethod
def add_user(cls, user, account, permission=None):
us.UserApi().join__user__account(user, account, permission)
@classmethod
[docs] def get_all_join_on_user(cls, users, delete_flag=None, **kwargs):
"""
Returns a list of accounts when the query by fields include the user relationship
:param delete_flag:
:param users: List of user objects to query on.
:param kwargs:
"""
result = []
try:
for u in users:
if not hasattr(u, 'id'): # assume user id passed in
u = us.UserApi().get(id=u)
result.append(_account_table.query.join(_account_table.r_user, aliased=True)
.filter_by(delete_flag=delete_flag, r_user=u, **kwargs))
return result.pop().union_all(*result)
except TypeError:
if not hasattr(users, 'id'): # assume user id passed in
users = us.UserApi().get(id=users)
return _account_table.query.join(_account_table.r_user, aliased=True) \
.filter_by(delete_flag=delete_flag, r_user=users, **kwargs)
@classmethod
def get_join_client(cls, client, delete_flag=None, **kwargs):
from apps.geofencing.middleware.themis.mobile_app_api.client import Client as ClientAPI
if not hasattr(client, 'id'):
client = ClientAPI().get(id=client)
join__user_account = client.r_join__user__account
return join__user_account.r_account
# result = _join__user_account_table.query.join(
# _join__user_account_table.r_client, aliased=True
# ).filter_by(
# delete_flag=delete_flag,
# id=c.id
# )
# return result