def get_group_manager_by_uuid(group_uuid, person_uuid):
session = baseDao.get_session()
group = groupDao.get_group_by_uuid(session, group_uuid, None)
person = groupDao.get_person_by_uuid(session, person_uuid)
return groupDao.get_group_manager(session, group.group_id, person.person_id)
def test_get_user_by_username(self):
print("running test_get_user_by_username...")
session = baseDao.get_session()
created_group = commonHelper.create_public_group()
group = groupDao.get_group_by_uuid(session, created_group.group_uuid)
self.assertEqual(created_group.group_name, group.group_name)
def remove_group_manager(group_uuid, user_uuid):
core.logger.debug("Removing Group Manager: " + str(group_uuid) + ", " + str(user_uuid))
session = baseDao.get_session()
group = groupDao.get_group_by_uuid(session, group_uuid, None)
if group:
if not group.private_fl:
try:
person = groupDao.get_person_by_uuid(session, user_uuid)
if person is None:
person = Person()
person.user_uuid = user_uuid
person = groupDao.add_person(session, person)
is_removed = groupDao.remove_group_manager(session, group.group_id, person.person_id)
session.commit()
return is_removed
except Exception:
session.rollback()
raise
else:
raise Exception("Not a public group")
else:
raise Exception("Group Doesn't exist!")
def load_application_cache_from_db():
session = baseDao.get_session()
# -- Application Config from Database --
config_items = configDao.get_config_all(session)
for c in config_items:
_application_config_cache.add(c.key, c.value)
def get_public_groups(user_uuid):
session = baseDao.get_session()
public_groups = groupDao.get_groups_by_filter(session, False)
subscribed_groups = groupDao.get_groups_by_user_uuid(session, user_uuid)
return {"groups": public_groups, "subscribed": subscribed_groups}
def create_person(self):
session = baseDao.get_session()
p = Person()
p.user_uuid = uuid.uuid4()
new_person = groupDao.add_person(session, p)
self.assertTrue(new_person.person_id > 0)
return new_person
def get_group_detail(group_id):
session = baseDao.get_session()
group_detail = GroupDetail()
group_detail.group = groupDao.get_group_by_id(session, group_id)
group_detail.active_members = groupDao.get_active_group_members(session, group_id)
group_detail.active_managers = groupDao.get_active_group_managers(session, group_id)
return group_detail
def test_get_config_by_key(self):
print("running test_get_config_by_key...")
session = baseDao.get_session()
config_item = configDao.get_config_by_key(session,
"app.release_number")
print("config_value: " + str(config_item))
self.assertTrue(len(config_item.value) > 0)
def add_group(group_name, group_de):
session = baseDao.get_session()
g = Group()
g.group_uuid = uuid.uuid4()
g.group_name = group_name
g.group_de = group_de
g.created_ts = datetime.now()
g.private_fl = False
g.group_type_cd = 'SP'
return groupDao.add_group(session, g)
def test_get_config_all(self):
print("running get_config_all...")
session = baseDao.get_session()
config_items = configDao.get_config_all(session)
print("config_items: " + str(config_items))
self.assertTrue(len(config_items) > 0)
self.assertTrue(len(config_items[0].key) > 0)
self.assertTrue(len(config_items[0].value) > 0)
def test_add_group(self):
session = baseDao.get_session()
g = Group()
g.group_uuid = uuid.uuid4()
g.group_name = "Group_" + randomUtil.random_string(10, 10)
g.group_de = "Group Description: " + randomUtil.random_string(10, 10)
g.group_type_cd = 'SP'
g.created_ts = datetime.now()
g.private_fl = False
new_group = groupDao.add_group(session, g)
self.assertTrue(new_group.group_id > 0)
def test_get_batch_job_by_id(self):
print("running get_batch_job_by_id...")
session = baseDao.get_session()
batch_job = batchDao.get_batch_job_by_id(session, 1)
# 1, 'STATS', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'COMPLETED',
# 'Testing Stats!'
self.assertEqual(1, batch_job.batch_job_id)
self.assertEqual('STATS', batch_job.job_code)
self.assertEqual('COMPLETED', batch_job.status_code)
self.assertEqual('Testing Stats!', batch_job.details)
def test_get_batch_jobs(self):
print("running test_get_batch_jobs...")
session = baseDao.get_session()
batch_jobs = batchDao.get_batch_jobs(session)
self.assertTrue(len(batch_jobs) > 0)
batch_job = batch_jobs[0]
self.assertEqual(1, batch_job.batch_job_id)
self.assertEqual('STATS', batch_job.job_code)
self.assertEqual('COMPLETED', batch_job.status_code)
self.assertEqual('Testing Stats!', batch_job.details)
def test_add_group_membership(self):
group = self.create_group()
member = self.create_person()
session = baseDao.get_session()
manager = groupDao.get_person_by_id(session, member.person_id)
group_membership = groupDao.add_group_membership(
session, group.group_id, manager)
self.assertEqual(group.group_id, group_membership.group_id)
self.assertEqual(manager.person_id, group_membership.person_id)
self.assertTrue(group_membership.membership_id > 0)
def add_batch_job(session, batch_job):
"""
Creates and saves a BatchJob to the database.
:param batch_job: new BatchJob record
:param session: database session
"""
if session is None:
session = baseDao.get_session()
session.add(batch_job)
session.commit()
return batch_job.batch_job_id
def run_stats():
session = baseDao.get_session()
start_ts = datetime.now()
user_count = groupDao.get_group_count(session)
print("stats: group_count=" + str(user_count))
end_ts = datetime.now()
batch_job = BatchJob()
batch_job.start_ts = start_ts
batch_job.job_code = 'STATS'
batch_job.details = "stats: group_count=" + str(user_count)
batch_job.status_code = 'COMPLETED'
batch_job.end_ts = end_ts
batchDao.add_batch_job(session, batch_job)
def test_add_batch_job(self):
print("running test_add_batch_job...")
session = baseDao.get_session()
batch_job = BatchJob()
batch_job.start_ts = datetime.now()
batch_job.job_code = 'STATS'
batch_job.details = "Testing Stats!"
batch_job.status_code = 'COMPLETED'
batch_job.end_ts = datetime.now()
print("batch_job->type=" + str(type(batch_job)))
print("batch_job=" + str(batch_job))
batch_job_id = batchDao.add_batch_job(session, batch_job)
added_batch_job = batchDao.get_batch_job_by_id(session, batch_job_id)
self.assertEqual(batch_job.job_code, added_batch_job.job_code)
def get_group_detail_by_uuid(group_uuid, is_private_fl=None, user_uuid=None):
session = baseDao.get_session()
group_detail = GroupDetail()
group = groupDao.get_group_by_uuid(session, group_uuid, is_private_fl)
group_detail.group = group
group_detail.active_members = groupDao.get_active_group_members(session, group.group_id)
group_detail.active_managers = groupDao.get_active_group_managers(session, group.group_id)
if user_uuid is not None:
person = groupDao.get_person_by_uuid(session, user_uuid)
core.logger.debug("person=" + str(person))
if person is not None:
is_active_member = groupDao.is_active_group_member(session, group.group_id, person.person_id)
core.logger.debug("is_active_member=" + str(is_active_member))
if is_active_member:
group_detail.group.subscribed = True
else:
is_active_manager = groupDao.is_active_group_manager(session, group.group_id, person.person_id)
core.logger.debug("is_active_manager=" + str(is_active_manager))
if is_active_manager:
group_detail.group.subscribed = True
return group_detail
def add_group_membership(group_uuid, user_uuid):
session = baseDao.get_session()
group = groupDao.get_group_by_uuid(session, group_uuid, None)
if group:
if not group.private_fl:
try:
person = groupDao.get_person_by_uuid(session, user_uuid)
if person is None:
person = Person()
person.user_uuid = user_uuid
person = groupDao.add_person(session, person)
group_membership = groupDao.add_group_membership(session, group.group_id, person)
session.commit()
return group_membership
except Exception:
session.rollback()
raise
else:
raise Exception("Not a public group")
else:
raise Exception("Group Doesn't exist!")
def get_groups():
session = baseDao.get_session()
return groupDao.get_groups(session)
def delete_group(group_id):
session = baseDao.get_session()
return groupDao.delete_group(session, group_id)
def update_group(group_id, group_to_be_updated):
session = baseDao.get_session()
return groupDao.update_group(session, group_id, group_to_be_updated)
def is_group_name_unique(group_name):
session = baseDao.get_session()
return groupDao.is_group_name_unique(session, group_name)
def get_group_by_name(group_name):
session = baseDao.get_session()
return groupDao.get_group_by_name(session, group_name)
def get_group_by_uuid(group_uuid, is_private_fl=None):
session = baseDao.get_session()
return groupDao.get_group_by_uuid(session, group_uuid, is_private_fl)
def get_group_by_id(group_id):
session = baseDao.get_session()
return groupDao.get_group_by_id(session, group_id)
def get_groups_by_user_uuid(user_uuid):
session = baseDao.get_session()
return groupDao.get_groups_by_user_uuid(session, user_uuid)
def get_code_table(code_table_name):
session = baseDao.get_session()
data = codetableDao.get_code_table(session, code_table_name)
return data
