def create_project_auth(project, session):
auth = Auth_api()
session.add(auth)
member = Member()
session.add(member)
member.kind = "api"
member.auth_api = auth
auth.member_id = member.id
auth.permission_level = 'Editor'
auth.project_string_id = project.project_string_id
auth.is_live = True
if auth.is_live == True:
auth.client_id = "LIVE__"
else:
auth.client_id = "TEST__"
auth.client_id += create_random_string(length=20)
auth.client_secret = create_random_string(length=60)
auth.project_id = project.id
# Careful we are placing this in the member not the auth
# for now...
session.commit()
return auth
def create(session, project_string_id, permission_level, is_live):
"""
Creates new Auth_api object
Arguments:
session, db object
project_string_id, string
permission_level, string
is_live, bool
Returns:
Auth object
"""
auth = Auth_api()
session.add(auth)
member = Member()
session.add(member)
member.kind = "api"
session.flush()
member.auth_api = auth
auth.member_id = member.id
auth.permission_level = permission_level
auth.project_string_id = project_string_id
auth.is_live = is_live
auth = create_client_auth_pair(auth)
project = Project.get(session, project_string_id)
auth.project_id = project.id
# Careful we are placing this in the member not the auth
# for now...
user = User.get(session=session)
# Careful! this is the user created not the new member()
Event.new(session=session,
kind="new_api_auth",
member_id=user.member_id,
success=True,
project_id=project.id,
email=user.email)
return auth
def register_member(user, session):
new_member = Member(
user = user
)
session.add(new_member)
regular_methods.commit_with_rollback(session)
return new_member
def threaded_job_resync(task_template_id, member_id):
with sessionMaker.session_scope_threaded() as session:
log = regular_log.default()
member = Member.get_by_id(session=session, member_id=member_id)
task_template = Job.get_by_id(session=session, job_id=task_template_id)
attached_dirs = task_template.get_attached_dirs(session=session,
sync_types=['sync'])
task_list = task_template.task_list(session=session)
file_ids = [t.file_id for t in task_list]
missing_files = []
for directory in attached_dirs:
files = WorkingDirFileLink.file_list(session=session,
limit=None,
working_dir_id=directory.id)
for file in files:
if file.id not in file_ids:
logger.info(
'Resyncing File {} on Job {} From Dir {}'.format(
file.id, task_template_id, directory.id))
job_sync_dir_manger = job_dir_sync_utils.JobDirectorySyncManager(
session=session, job=task_template, log=log)
job_sync_dir_manger.create_file_links_for_attached_dirs(
sync_only=True,
create_tasks=True,
file_to_link=file,
file_to_link_dataset=directory,
related_input=None,
member=member)
task_template.update_file_count_statistic(session=session)
missing_files.append(file)
logger.info('Resyncing on Job {} Success. {} Missing files synced'.format(
task_template_id, len(missing_files)))
return missing_files
def verify_member_list_untrusted(self):
for member_untrusted in self.member_list_untrusted:
member = Member.get_by_id(
session=self.session,
member_id=member_untrusted.get('member_id'))
if member.user == self.user_who_made_request:
self.log['error'][
'user_who_made_request'] = "Can't remove yourself."
return
self.member_list.append(member)
def verify_member_list_untrusted(self):
if 'all' in self.member_list_untrusted:
user_ids = [u.id for u in self.project.users]
members = self.session.query(Member).filter(
Member.id.in_(user_ids))
self.member_list = members
return
for member_untrusted in self.member_list_untrusted:
member = Member.get_by_id(session=self.session,
member_id=member_untrusted)
if not member:
self.log['error']['member'] = "Member does not exist."
return
self.member_list.append(member)
def create_project_with_context(context_data, session):
"""
This function will create mock data for a project and all the necessary context for any unit testing
to be performed.
context_data will be a dictionary with all the context for creating the project.
The idea is that you'll be able to specify users, labels, tasks, etc... and the function will make sure all the
data is mocked properly.
Example: For my test I need a project with 2 users, 1 admin and another with view permissions. I also need 3 labels.
The context_data should look something like this:
{
'project_name': 'My test project',
'users': [
{'name': 'john', permissions: 'admin'}
{'name': 'maria', permissions: 'view'}
},
'labels': [
{'name': 'catlabel', 'type': 'box'}
{'name': 'dogabel2', 'type': 'box'}
]
The function will return a similar data structure with the ID's on the test database for further querying
inside the test cases.
:param context_data:
:return:
"""
random_name = get_random_string(8)
project_string_id = context_data.get('project_string_id', random_name)
project_name = context_data.get('project_name', random_name)
default_project_limit = 10
user = register_user(
{'username': '******'.format(project_string_id),
'email': 'test{}@test.com'.format(project_string_id),
'password': '******'},
session
)
member = Member(kind = 'human')
session.add(member)
session.flush()
user.member = member
project = Project.new(
session = session,
name = project_name,
project_string_id = project_string_id,
goal = 'Test stuff',
member_created = None,
user = user
)
user_list = []
for user in context_data['users']:
if user.get('project_string_id') is None:
user['project_string_id'] = random_name
new_user = register_user(user, session)
member = Member(kind = 'human')
session.add(member)
session.flush()
new_user.member = member
new_user.member_id = member.id
session.add(new_user)
user_list.append(new_user)
regular_methods.commit_with_rollback(session)
return {
'project': project,
'users': user_list
}
def user_new_core(session, email, user_signup_code=None):
"""
Goals:
Blindly creates a new user and accepts signup code
Used in context with a api that checks validity of request
Start email verification
Arguments:
session, db session object
email, string
user_signup_code, class Auth_code (prior Signup_Code) object
Returns:
new_user, class User() object
project_string_id, string project id (future maybe just return class Project() object?)
"""
member = Member()
session.add(member)
member.kind = "human"
new_user = User(email=email,
created_remote_address=request.remote_addr,
member=member)
# For Open Core Installs
# Make the first user the super admin by default.
user_list = session.query(User).all()
if len(user_list) == 0:
new_user.is_super_admin = True
new_user.security_email_verified = True
session.add(new_user)
session.flush() # Get ids (member and user)
member.user = new_user
new_user.member_id = member.id
new_user.username = new_user.id
new_user.permissions_projects = {
} # I don't like having this here but alternative of committing object seems worse
### VERIFY
# context,this is below signup code
# as potentially signup code effects what type of verify email we send?
# ie "welcome to xyz project message??"
if new_user.is_super_admin != True:
if settings.EMAIL_VALIDATION:
start_verify_result, _ = account_verify.start_verify_via_email(
session=session, user=new_user)
else:
new_user.security_email_verified = True
# Routing if invited to something through signup code
# ie a specific project / org / file
# Sort of handled by project_string_id
General_permissions.add('normal_user', new_user)
session.add(new_user)
Event.identify_user(new_user)
Event.new(session=session,
kind="new_user",
member_id=new_user.member_id,
success=True,
email=new_user.email)
return new_user