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_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 _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_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 create(session, template):
persistor = build_persistor(session)
with flush_session(session):
return persistor.create(template)
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 edit(session, template):
persistor = build_persistor(session)
with flush_session(session):
return persistor.edit(template)
def associate(session, user_voicemail):
with flush_session(session):
_associate_voicemail_with_user(session, user_voicemail)
