def test_insert_missing_agents(self): # 1: in confd + in stat # 2: in confd + not in stat', # 3: not in confd + in stat', confd_agents = [ { 'id': 1, 'number': '1', 'tenant_uuid': 'tenant1', }, { 'id': 2, 'number': '2', 'tenant_uuid': 'tenant2', }, ] self._insert_agent('Agent/1', 'tenant1', 1) self._insert_agent('Agent/3', 'tenant3', 3) with flush_session(self.session): stat_agent_dao.insert_missing_agents(self.session, confd_agents) result = self._fetch_stat_agents() assert_that( result, contains_inanyorder( ('Agent/1', 'tenant1', 1, False), ('Agent/2', 'tenant2', 2, False), ('Agent/3', 'tenant3', 3, True), ))
def edit(session, meeting): with flush_session(session): Persistor(session, meeting_search).edit(meeting) if not meeting.require_authorization: for authorization in meeting.meeting_authorizations: if authorization.status == 'pending': authorization.status = 'accepted'
def associate(session, queue_member): with flush_session(session): agent = (session.query(AgentFeaturesSchema.number) .filter(AgentFeaturesSchema.id == queue_member.agent_id).first()) queue = (session.query(QueueFeaturesSchema.name) .filter(QueueFeaturesSchema.id == queue_member.queue_id).first()) current_max_pos = (session.query(func.max(QueueMemberSchema.position)) .filter(QueueFeaturesSchema.name == QueueMemberSchema.queue_name) .filter(QueueMemberSchema.usertype == 'agent')).scalar() if current_max_pos is None: max_pos = 0 else: max_pos = current_max_pos + 1 db_qm = db_converter.to_source(queue_member) db_qm.queue_name = queue.name db_qm.interface = 'Agent/%s' % agent.number db_qm.commented = 0 db_qm.usertype = 'agent' db_qm.channel = 'Agent' db_qm.category = 'queue' db_qm.position = max_pos session.add(db_qm) return queue_member
def delete_from_list(session, call_log_ids): with flush_session(session): for call_log_id in call_log_ids: (session .query(CallLogSchema) .filter(CallLogSchema.id == call_log_id) .delete())
def test_remove_after(self): _, agent_id = self._insert_agent_to_stat_agent() stats = { dt(2012, 1, 1): { agent_id: { 'login_time': timedelta(minutes=15), 'pause_time': timedelta(minutes=13) }, }, dt(2012, 1, 2): { agent_id: { 'login_time': timedelta(minutes=20), 'pause_time': timedelta(minutes=13) }, }, dt(2012, 1, 3): { agent_id: { 'login_time': timedelta(minutes=25), 'pause_time': timedelta(minutes=13) }, }, } with flush_session(self.session): for period_start, agents_stats in stats.iteritems(): stat_agent_periodic_dao.insert_stats(self.session, agents_stats, period_start) stat_agent_periodic_dao.remove_after(self.session, dt(2012, 1, 2)) res = self.session.query(StatAgentPeriodic.time) self.assertEqual(res.count(), 1) self.assertEqual(res[0].time, dt(2012, 1, 1))
def edit_agent_queue_association(session, queue_member): with flush_session(session): row = (session.query(QueueMemberSchema) .filter(QueueFeaturesSchema.name == QueueMemberSchema.queue_name) .filter(QueueMemberSchema.usertype == 'agent') .filter(QueueMemberSchema.userid == queue_member.agent_id) .filter(QueueFeaturesSchema.id == queue_member.queue_id)).first() row.penalty = queue_member.penalty
def edit(session, extension): extension_row = find_query(session, {'id': extension.id}).one() db_converter.update_source(extension_row, extension) with flush_session(session): session.add(extension_row) session.flush() ExtensionFixes(session).fix(extension_row.id)
def create(session, context): context_row = context_converter.to_source(context) context_row.entity = entity_dao.default_entity_name() with flush_session(session): session.add(context_row) return context
def create(session, incall): extension = extension_dao.get(incall.extension_id) with flush_session(session): incall.id = _create_incall(session, incall, extension) _update_extension(session, incall) _create_dialaction(session, incall) return incall
def add_user_to_schedule(session, userid, scheduleid, order=0): schedulepath = SchedulePath() schedulepath.path = 'user' schedulepath.schedule_id = scheduleid schedulepath.pathid = userid schedulepath.order = order with flush_session(session): session.add(schedulepath)
def edit(session, user_cti_profile): with flush_session(session): user = (session.query(UserSchema) .filter(UserSchema.id == user_cti_profile.user_id) .first()) if user_cti_profile.enabled is not None: user.enableclient = 1 if user_cti_profile.enabled else 0 if user_cti_profile.cti_profile_id is not None: user.cti_profile_id = user_cti_profile.cti_profile_id session.add(user)
def add_entry(session, call_time, queue_name, caller_id_num, uniqueid): entry = QueueInfo( call_time_t=call_time, queue_name=queue_name, caller=caller_id_num, caller_uniqueid=uniqueid, ) with flush_session(session): session.add(entry)
def test_insert_periodic_stat(self): _, agent_id_1 = self._insert_agent_to_stat_agent() _, agent_id_2 = self._insert_agent_to_stat_agent() stats = { dt(2012, 1, 1, 1, 0, 0, tzinfo=UTC): { agent_id_1: { 'login_time': timedelta(minutes=50), 'pause_time': timedelta(minutes=13) }, agent_id_2: { 'login_time': ONE_HOUR, 'pause_time': timedelta(minutes=13) }, }, dt(2012, 1, 1, 2, 0, 0, tzinfo=UTC): { agent_id_1: { 'login_time': timedelta(minutes=20), 'pause_time': timedelta(minutes=33) }, agent_id_2: { 'login_time': ONE_HOUR, 'pause_time': timedelta(minutes=13) }, }, dt(2012, 1, 1, 3, 0, 0, tzinfo=UTC): { agent_id_2: { 'login_time': ONE_HOUR, 'pause_time': ONE_HOUR }, }, dt(2012, 1, 1, 4, 0, 0, tzinfo=UTC): { agent_id_2: { 'login_time': ONE_HOUR, 'pause_time': ONE_HOUR }, } } with flush_session(self.session): for period_start, agents_stats in six.iteritems(stats): stat_agent_periodic_dao.insert_stats(self.session, agents_stats, period_start) period_start = dt(2012, 1, 1, 1, 0, 0, tzinfo=UTC) try: result = (self.session.query(StatAgentPeriodic).filter( StatAgentPeriodic.time == period_start).filter( StatAgentPeriodic.stat_agent_id == agent_id_1)[0]) self.assertEqual(result.login_time, timedelta(minutes=50)) except LookupError: self.fail('Should have found a row')
def create(session, extension): extension_row = db_converter.to_source(extension) extension_row.type = 'user' extension_row.typeval = '0' with flush_session(session): session.add(extension_row) extension.id = extension_row.id return extension
def test_insert_if_missing(self): # queue1: in confd + in cel + in stat # queue2: in confd + not in cel + in stat # queue3: in confd + not in cel + not in stat', # queue4: in confd + in cel + not in stat', # queue5: not in confd + in cel + not in stat', # queue6: not in confd + in cel + in stat', # queue7: not in confd + not in cel + in stat', confd_queues = [ { 'id': 1, 'name': 'queue1', 'tenant_uuid': 'tenant1', }, { 'id': 2, 'name': 'queue2', 'tenant_uuid': 'tenant2', }, { 'id': 3, 'name': 'queue3', 'tenant_uuid': 'tenant3', }, { 'id': 4, 'name': 'queue4', 'tenant_uuid': 'tenant4', }, ] self._insert_queue('queue1', 'tenant1', 1) self._insert_queue('queue2', 'tenant2', 2) self._insert_queue('queue6', 'tenant6', 6) self._insert_queue('queue7', 'tenant7', 7) new_queues = ['queue1', 'queue4', 'queue5'] master_tenant = str(uuid.uuid4()) with flush_session(self.session): stat_queue_dao.insert_if_missing(self.session, new_queues, confd_queues, master_tenant) result = self._fetch_stat_queues() assert_that( result, contains_inanyorder( ('queue1', 'tenant1', 1, False), ('queue2', 'tenant2', 2, False), ('queue3', 'tenant3', 3, False), ('queue4', 'tenant4', 4, False), ('queue5', master_tenant, None, True), ('queue6', 'tenant6', 6, True), ('queue7', 'tenant7', 7, True), ))
def add_agent_to_queue(session, agent_id, agent_number, queue_name): next_position = _get_next_position_for_queue(session, queue_name) queue_member = QueueMember() queue_member.queue_name = queue_name queue_member.interface = 'Agent/%s' % agent_number queue_member.usertype = 'agent' queue_member.userid = agent_id queue_member.channel = 'Agent' queue_member.category = 'queue' queue_member.position = next_position with flush_session(session): session.add(queue_member)
def add_user_to_queue(session, user_id, queue): next_position = _get_next_position_for_queue(session, queue) queue_member = QueueMember() queue_member.queue_name = queue queue_member.interface = user_line_dao.get_line_identity_by_user_id(user_id) queue_member.usertype = 'user' queue_member.userid = user_id queue_member.channel = queue_member.interface.split('/', 1)[0] queue_member.category = 'queue' queue_member.position = next_position with flush_session(session): session.add(queue_member)
def test_insert_periodic_stat(self): _, agent_id_1 = self._insert_agent_to_stat_agent() _, agent_id_2 = self._insert_agent_to_stat_agent() stats = { dt(2012, 01, 01, 01, 00, 00): { agent_id_1: { 'login_time': timedelta(minutes=50), 'pause_time': timedelta(minutes=13) }, agent_id_2: { 'login_time': ONE_HOUR, 'pause_time': timedelta(minutes=13)}, }, dt(2012, 01, 01, 02, 00, 00): { agent_id_1: { 'login_time': timedelta(minutes=20), 'pause_time': timedelta(minutes=33) }, agent_id_2: { 'login_time': ONE_HOUR, 'pause_time': timedelta(minutes=13) }, }, dt(2012, 01, 01, 03, 00, 00): { agent_id_2: { 'login_time': ONE_HOUR, 'pause_time': ONE_HOUR }, }, dt(2012, 01, 01, 04, 00, 00): { agent_id_2: { 'login_time': ONE_HOUR, 'pause_time': ONE_HOUR }, } } with flush_session(self.session): for period_start, agents_stats in stats.iteritems(): stat_agent_periodic_dao.insert_stats(self.session, agents_stats, period_start) period_start = dt(2012, 01, 01, 01, 00, 00) try: result = (self.session.query(StatAgentPeriodic) .filter(StatAgentPeriodic.time == period_start) .filter(StatAgentPeriodic.agent_id == agent_id_1)[0]) self.assertEqual(result.login_time, timedelta(minutes=50)) except LookupError: self.fail('Should have found a row')
def test_when_agent_marked_as_deleted_then_new_one_is_created(self): confd_agents = [{'id': 1, 'number': '1', 'tenant_uuid': 'tenant'}] self._insert_agent('Agent/1', 'tenant', agent_id=999, deleted=True) with flush_session(self.session): stat_agent_dao.insert_missing_agents(self.session, confd_agents) result = self._fetch_stat_agents() assert_that( result, contains_inanyorder( ('Agent/1', 'tenant', 1, False), ('Agent/1_', 'tenant', 999, True), ))
def test_insert_if_missing(self): old_queues = ['queue_%s' % number for number in range(5)] for queue_name in old_queues: self._insert_queue(queue_name) new_queues = ['queue_%s' % number for number in range(5, 10)] all_queues = sorted(old_queues + new_queues) with flush_session(self.session): stat_queue_dao.insert_if_missing(self.session, all_queues) result = sorted(r.name for r in self.session.query(StatQueue.name)) self.assertEqual(result, all_queues)
def delete(session, incall): incall_query = (session.query(Incall) .filter(Incall.id == incall.id)) dialaction_query = (session.query(Dialaction) .filter(Dialaction.category == 'incall') .filter(Dialaction.categoryval == str(incall.id))) extension_query = (session.query(Extension) .filter(Extension.id == incall.extension_id)) with flush_session(session): incall_query.delete() dialaction_query.delete() extension_query.update({'type': 'user', 'typeval': '0'})
def test_mark_non_confd_queues_as_deleted(self): confd_queues = [{'id': 1, 'name': 'queue1', 'tenant_uuid': 'tenant'}] self._insert_queue('queue2', 'tenant', queue_id=2, deleted=False) self._insert_queue('queue3', 'tenant', queue_id=None, deleted=False) with flush_session(self.session): stat_queue_dao._mark_non_confd_queues_as_deleted( self.session, confd_queues) result = self._fetch_stat_queues() assert_that( result, contains_inanyorder( ('queue2', 'tenant', 2, True), ('queue3', 'tenant', None, True), ))
def test_get_most_recent_time(self): self.assertRaises(LookupError, stat_queue_periodic_dao.get_most_recent_time, self.session) stats = self._get_stats_for_queue() start = datetime.datetime(2012, 01, 01, 00, 00, 00) with flush_session(self.session): for minute_increment in [-5, 5, 15, 22, 35, 65, 120]: delta = datetime.timedelta(minutes=minute_increment) time = start + delta stat_queue_periodic_dao.insert_stats(self.session, stats, time) result = stat_queue_periodic_dao.get_most_recent_time(self.session) expected = start + datetime.timedelta(minutes=120) self.assertEqual(result, expected)
def test_mark_non_confd_agents_as_deleted(self): confd_agents = [{'id': 1, 'number': '1', 'tenant_uuid': 'tenant'}] self._insert_agent('Agent/2', 'tenant', agent_id=2, deleted=False) self._insert_agent('Agent/3', 'tenant', agent_id=None, deleted=False) with flush_session(self.session): stat_agent_dao._mark_non_confd_agents_as_deleted( self.session, confd_agents) result = self._fetch_stat_agents() assert_that( result, contains_inanyorder( ('Agent/2', 'tenant', 2, True), ('Agent/3', 'tenant', None, True), ))
def test_mark_recreated_agents_with_same_number_as_deleted(self): confd_agents = { 'Agent/1': { 'id': 1, 'number': '1', 'tenant_uuid': 'tenant' } } self._insert_agent('Agent/1', 'tenant', agent_id=999, deleted=False) with flush_session(self.session): stat_agent_dao._mark_recreated_agents_with_same_number_as_deleted( self.session, confd_agents) result = self._fetch_stat_agents() assert_that(result, contains_inanyorder(('Agent/1', 'tenant', 999, True)))
def test_when_queue_marked_as_deleted_then_new_one_is_created(self): confd_queues = [{'id': 1, 'name': 'queue', 'tenant_uuid': 'tenant'}] self._insert_queue('queue', 'tenant', queue_id=999, deleted=True) new_queues = ['queue'] master_tenant = str(uuid.uuid4()) with flush_session(self.session): stat_queue_dao.insert_if_missing(self.session, new_queues, confd_queues, master_tenant) result = self._fetch_stat_queues() assert_that( result, contains_inanyorder( ('queue', 'tenant', 1, False), ('queue_', 'tenant', 999, True), ))
def test_mark_recreated_queues_with_same_name_as_deleted(self): confd_queues = { 'queue': { 'id': 1, 'name': 'queue', 'tenant_uuid': 'tenant' } } self._insert_queue('queue', 'tenant', queue_id=999, deleted=False) with flush_session(self.session): stat_queue_dao._mark_recreated_queues_with_same_name_as_deleted( self.session, confd_queues) result = self._fetch_stat_queues() assert_that(result, contains_inanyorder(('queue', 'tenant', 999, True), ))
def test_get_most_recent_time(self): self.assertRaises(LookupError, stat_queue_periodic_dao.get_most_recent_time, self.session) stats = self._get_stats_for_queue() start = dt(2012, 1, 1, 00, 00, 00, tzinfo=UTC) with flush_session(self.session): for minute_increment in [-5, 5, 15, 22, 35, 65, 120]: delta = timedelta(minutes=minute_increment) time = start + delta stat_queue_periodic_dao.insert_stats(self.session, stats, time) result = stat_queue_periodic_dao.get_most_recent_time(self.session) expected = start + timedelta(minutes=120) self.assertEqual(result, expected)
def test_remove_after(self): queue_name, queue_id = self._insert_queue_to_stat_queue() stats = {queue_id: {'full': 4, 'total': 10}} with flush_session(self.session): stat_queue_periodic_dao.insert_stats(self.session, stats, dt(2012, 1, 1, tzinfo=UTC)) stat_queue_periodic_dao.insert_stats(self.session, stats, dt(2012, 1, 2, tzinfo=UTC)) stat_queue_periodic_dao.insert_stats(self.session, stats, dt(2012, 1, 3, tzinfo=UTC)) stat_queue_periodic_dao.remove_after(self.session, dt(2012, 1, 2, tzinfo=UTC)) res = self.session.query(StatQueuePeriodic.time) self.assertEqual(res.count(), 1) self.assertEqual(res[0].time, dt(2012, 1, 1, tzinfo=UTC))
def _insert_queue_log_data(self, queue_log_data): with flush_session(self.session): lines = queue_log_data.split('\n') lines.pop() header = self._strip_content_list(lines.pop(0).split('|')[1:-1]) for line in lines: tmp = self._strip_content_list(line[1:-1].split('|')) data = dict(zip(header, tmp)) queue_log = QueueLog(time=data['time'], callid=data['callid'], queuename=data['queuename'], agent=data['agent'], event=data['event'], data1=data['data1'], data2=data['data2'], data3=data['data3'], data4=data['data4'], data5=data['data5']) self.session.add(queue_log)
def test_create_missing_agents(self): confd_agents = { 'Agent/1': { 'id': 1, 'number': '1', 'tenant_uuid': 'tenant' }, } self._insert_agent('Agent/2', 'tenant', deleted=True) with flush_session(self.session): stat_agent_dao._create_missing_agents(self.session, confd_agents) result = self._fetch_stat_agents() assert_that( result, contains_inanyorder( ('Agent/1', 'tenant', 1, False), ('Agent/2', 'tenant', None, True), ))
def test_remove_after(self): queue_name, queue_id = self._insert_queue_to_stat_queue() stats = { queue_id: { 'full': 4, 'total': 10 } } with flush_session(self.session): stat_queue_periodic_dao.insert_stats(self.session, stats, datetime.datetime(2012, 1, 1)) stat_queue_periodic_dao.insert_stats(self.session, stats, datetime.datetime(2012, 1, 2)) stat_queue_periodic_dao.insert_stats(self.session, stats, datetime.datetime(2012, 1, 3)) stat_queue_periodic_dao.remove_after(self.session, datetime.datetime(2012, 1, 2)) res = self.session.query(StatQueuePeriodic.time) self.assertEqual(res.count(), 1) self.assertEqual(res[0].time, datetime.datetime(2012, 1, 1))
def _insert_queue_log_data(self, queue_log_data): with flush_session(self.session): lines = queue_log_data.split('\n') lines.pop() header = self._strip_content_list(lines.pop(0).split('|')[1:-1]) for line in lines: tmp = self._strip_content_list(line[1:-1].split('|')) data = dict(zip(header, tmp)) queue_log = QueueLog( time=data['time'], callid=data['callid'], queuename=data['queuename'], agent=data['agent'], event=data['event'], data1=data['data1'], data2=data['data2'], data3=data['data3'], data4=data['data4'], data5=data['data5'] ) self.session.add(queue_log)
def test_rename_deleted_agents_with_duplicate_name(self): confd_agents = { 'Agent/1': { 'id': 1, 'number': 'agent', 'tenant_uuid': 'tenant' } } self._insert_agent('Agent/1', 'tenant', agent_id=1, deleted=True) self._insert_agent('Agent/1', 'tenant', agent_id=1, deleted=True) with flush_session(self.session): stat_agent_dao._rename_deleted_agents_with_duplicate_name( self.session, confd_agents) result = self._fetch_stat_agents() assert_that( result, contains_inanyorder( ('Agent/1_', 'tenant', 1, True), ('Agent/1__', 'tenant', 1, True), ))
def test_rename_deleted_queues_with_duplicate_name(self): confd_queues = { 'queue': { 'id': 1, 'name': 'queue', 'tenant_uuid': 'tenant' } } self._insert_queue('queue', 'tenant', queue_id=1, deleted=True) self._insert_queue('queue', 'tenant', queue_id=1, deleted=True) with flush_session(self.session): stat_queue_dao._rename_deleted_queues_with_duplicate_name( self.session, confd_queues) result = self._fetch_stat_queues() assert_that( result, contains_inanyorder( ('queue_', 'tenant', 1, True), ('queue__', 'tenant', 1, True), ))
def test_insert_periodic_stat(self): stats = self._get_stats_for_queue() period_start = datetime.datetime(2012, 01, 01, 00, 00, 00) with flush_session(self.session): stat_queue_periodic_dao.insert_stats(self.session, stats, period_start) try: result = (self.session.query(StatQueuePeriodic) .filter(StatQueuePeriodic.time == period_start)[0]) self.assertEqual(result.abandoned, 7) self.assertEqual(result.answered, 27) self.assertEqual(result.closed, 5) self.assertEqual(result.full, 4) self.assertEqual(result.joinempty, 2) self.assertEqual(result.leaveempty, 11) self.assertEqual(result.timeout, 5) self.assertEqual(result.divert_ca_ratio, 22) self.assertEqual(result.divert_waittime, 15) self.assertEqual(result.total, 98) except LookupError: self.fail('Should have found a row')
def test_create_missing_queues(self): confd_queues = { 'queue1': { 'id': 1, 'name': 'queue1', 'tenant_uuid': 'tenant' }, } new_queues = ['queue2', 'queue3'] master_tenant = str(uuid.uuid4()) self._insert_queue('queue3', 'tenant', deleted=True) with flush_session(self.session): stat_queue_dao._create_missing_queues(self.session, new_queues, confd_queues, master_tenant) result = self._fetch_stat_queues() assert_that( result, contains_inanyorder( ('queue1', 'tenant', 1, False), ('queue2', master_tenant, None, True), ('queue3', 'tenant', None, True), ))
def _insert_agent_callback_logins_logoffs(self, logins, logoffs): with flush_session(self.session): for login in logins: callback_login = QueueLog( time=login['time'], callid=login['callid'], queuename='NONE', agent=login['agent'], event='AGENTCALLBACKLOGIN', data1=login['chan_name'] ) self.session.add(callback_login) for logoff in logoffs: callback_logoff = QueueLog( time=logoff['time'], callid='NONE', queuename='NONE', agent=logoff['agent'], event='AGENTCALLBACKLOGOFF', data1=logoff['chan_name'], data2=logoff['talktime'].seconds, ) self.session.add(callback_logoff)
def test_remove_after(self): _, agent_id = self._insert_agent_to_stat_agent() stats = { dt(2012, 1, 1, tzinfo=UTC): { agent_id: { 'login_time': timedelta(minutes=15), 'pause_time': timedelta(minutes=13) }, }, dt(2012, 1, 2, tzinfo=UTC): { agent_id: { 'login_time': timedelta(minutes=20), 'pause_time': timedelta(minutes=13) }, }, dt(2012, 1, 3, tzinfo=UTC): { agent_id: { 'login_time': timedelta(minutes=25), 'pause_time': timedelta(minutes=13) }, }, } with flush_session(self.session): for period_start, agents_stats in six.iteritems(stats): stat_agent_periodic_dao.insert_stats(self.session, agents_stats, period_start) stat_agent_periodic_dao.remove_after(self.session, dt(2012, 1, 2, tzinfo=UTC)) res = self.session.query(StatAgentPeriodic.time) self.assertEqual(res.count(), 1) self.assertEqual(res[0].time, dt(2012, 1, 1, tzinfo=UTC))
def test_insert_periodic_stat(self): stats = self._get_stats_for_queue() period_start = dt(2012, 1, 1, 00, 00, 00, tzinfo=UTC) with flush_session(self.session): stat_queue_periodic_dao.insert_stats(self.session, stats, period_start) try: result = (self.session.query(StatQueuePeriodic).filter( StatQueuePeriodic.time == period_start)[0]) self.assertEqual(result.abandoned, 7) self.assertEqual(result.answered, 27) self.assertEqual(result.closed, 5) self.assertEqual(result.full, 4) self.assertEqual(result.joinempty, 2) self.assertEqual(result.leaveempty, 11) self.assertEqual(result.timeout, 5) self.assertEqual(result.divert_ca_ratio, 22) self.assertEqual(result.divert_waittime, 15) self.assertEqual(result.total, 98) except LookupError: self.fail('Should have found a row')
def create(session, iax): with flush_session(session): return IAXPersistor(session, iax_search).create(iax)
def set_live_reload_status(session, data): value = data['enabled'] with flush_session(session): session.query(Infos).update({'live_reload_enabled': value})
def edit(session, template): persistor = build_persistor(session) with flush_session(session): return persistor.edit(template)
def create(session, template): persistor = build_persistor(session) with flush_session(session): return persistor.create(template)
def dissociate(session, user, voicemail): with flush_session(session): if user.voicemail is voicemail: user.voicemailid = None user.enablevoicemail = 0 session.add(user)
def dissociate(session, user_voicemail): with flush_session(session): _dissociate_voicemail_from_user(session, user_voicemail.user_id)
def remove_user_from_all_schedules(session, userid): with flush_session(session): session.query(SchedulePath).filter(SchedulePath.path == 'user')\ .filter(SchedulePath.pathid == userid)\ .delete()
def create_from_list(session, call_logs): with flush_session(session): for call_log in call_logs: call_log_id = create_call_log(session, call_log) _link_call_log(session, call_log, call_log_id)
def delete_all(session): with flush_session(session): session.query(CallLogSchema).delete()
def update_talktime(session, uniqueid, calltime, talktime): with flush_session(session): qi = _find_by_uniqueid_calltime(session, uniqueid, calltime) qi.talk_time = talktime
def update_holdtime(session, uniqueid, calltime, holdtime, answerer=None): with flush_session(session): qi = _find_by_uniqueid_calltime(session, uniqueid, calltime) qi.hold_time = holdtime if answerer: qi.call_picker = answerer
def edit(session, iax): with flush_session(session): IAXPersistor(session, iax_search).edit(iax)
def delete(session, sip): with flush_session(session): return SipPersistor(session, sip_search).delete(sip)
def delete(session, iax): with flush_session(session): return IAXPersistor(session, iax_search).delete(iax)
def associate(session, user, voicemail): with flush_session(session): user.voicemailid = voicemail.id user.enablevoicemail = 1 session.add(user)
def associate(session, user_voicemail): with flush_session(session): _associate_voicemail_with_user(session, user_voicemail)