def authenticate_admin(username, password):
auth_user = AdminUser.query.filter(AdminUser.username==username).first()
if not auth_user:
log.debug("No user named: '%s'", username)
return False
elif not auth_user.password:
log.error("Bad username/pass:'******'")
return False
elif password != auth_user.password:
log.debug("Database password for user '%s'", username)
return False
else:
request.environ["REMOTE_USER"] = auth_user.username
request.environ["HTTP_REMOTE_USER"] = auth_user.username
session["perms"]= auth_user.permissions
session["user"] = auth_user
session["name"] = auth_user.name
session['user_id'] = auth_user.id
auth_user.register_login(username, session, request)
db.commit()
db.flush()
session.save()
return True
def getUsers(self, sid):
users = []
ep_stats = []
user = User.query.filter_by(session_id=sid).first()
if user:
context = user.get_context()
else:
raise Exception("No session id in db matching the user calling this method.")
for r in db.execute("SELECT DISTINCT users.first_name, users.last_name, users.id, users.customer_id, "
"customers.context AS context, users.portal_extension, "
"users.tel, users.mobile, users.username, sip_dialogs.uuid AS uuid "
"FROM users "
"INNER JOIN customers ON users.customer_id = customers.id "
"LEFT JOIN sip_dialogs ON sip_dialogs.presence_id = users.portal_extension || '@' || customers.context "
"WHERE customers.context = :context ORDER BY users.id", {'context': context}):
for pbx_reg in PbxRegistration.query.filter(PbxRegistration.sip_realm==context).filter(PbxRegistration.sip_user==r[5]).all():
ep_stats.append({'ip': pbx_reg.network_ip, 'port':pbx_reg.network_port})
is_online = True if len(ep_stats) > 0 else False
ep_stats = []
# make_broker_user(name, id, customer_id, email, tel, mobile, ext, uuid, is_online):
users.append(make_broker_user(r[0]+' '+r[1], r[2], r[3], r[8], r[6], r[7], r[5], r[9], is_online))
db.remove()
return users
def getCallers(self, sid):
callers = []
user = User.query.filter_by(session_id=sid).first()
if user:
context = user.get_context()
for row in PbxDid.query.filter(PbxDid.context==context).all():
for cal in db.execute("SELECT * FROM channels WHERE dest like :did", {'did': "%"+row.did}).fetchall():
#PbxChannel.query.filter(PbxChannel.dest.like('%'+row.did).all():
l = PbxChannel.query.filter_by(uuid=cal.uuid).first()
if l:
to_user = l.dest
status = l.callstate
else:
to_user = ""
status = ""
direction = "inbound"
if len(cal.cid_num) > 10:
cid_num = cal.cid_num[len(cal.cid_num)-10:]
else:
cid_num = cal.cid_num
time_in_queue = db.execute("SELECT now() FROM channels WHERE uuid = :uuid", {'uuid': cal.uuid}).fetchone()
callers.append(make_caller(cal.dest, cal.cid_name,cid_num, direction, cal.created, time_in_queue[0], to_user, cal.uuid, status))
for cal in PbxChannel.query.filter_by(context=context).distinct(PbxChannel.call_uuid).all():
if len(cal.presence_id)>3:
if cal.presence_id.split("@")[1] == context:
time_in_queue = db.execute("SELECT now() FROM channels WHERE uuid = :uuid", {'uuid': cal.uuid}).fetchone()
callers.append(make_caller(cal.dest, cal.cid_name, cal.cid_num, "outbound", cal.created, "", cal.dest, cal.uuid, cal.callstate))
db.remove()
return callers
def account_by_id(self, id):
items = []
for account in (
CrmAccount.query.join(CrmCampaign)
.filter(CrmAccount.customer_id == session["customer_id"])
.filter(CrmAccount.user_id == session["user_id"])
.filter(CrmCampaign.name == id)
.all()
):
items.append(
{
"id": account.id,
"name": str(account.first_name) + " " + str(account.last_name),
"address": account.address,
"city": account.city,
"state": account.state,
"zip": account.zip,
"tel": account.tel,
"mobile": account.mobile,
"email": account.email,
"crm_campaign_id": account.crm_campaign_id,
}
)
db.remove()
out = dict({"identifier": "id", "label": "name", "items": items})
response = make_response(out)
response.headers = [("Content-type", "application/json")]
return response(request.environ, self.start_response)
def ad_audio(self):
items = []
dir = fs_vm_dir + session["context"] + "/recordings/"
try:
for i in os.listdir(dir):
fo = generateFileObject(i, "", dir)
items.append(
{
"id": "1," + fo["name"],
"name": "Recording: " + fo["name"],
"data": fo["path"],
"type": 1,
"real_id": "",
}
)
db.remove()
except:
pass
out = dict({"identifier": "id", "label": "name", "items": items})
response = make_response(out)
response.headers = [("Content-type", "application/json; charset=UTF-8")]
return response(request.environ, self.start_response)
def init_model(engine):
"""Call me before using any of the tables or classes in the model"""
Session.configure(bind=engine)
"""Call me before using any of the tables or classes in the model"""
Session.configure(bind=engine, expire_on_commit=False )
Base.query = Session.query_property()
metadata = Base.metadata
def queue_delete(q):
for queue in CallCenterQueue.query.filter(CallCenterQueue.id==q.id).filter(CallCenterQueue.context==session['context']).all():
PbxRoute.query.filter(PbxRoute.pbx_route_type_id==10).filter(PbxRoute.pbx_to_id==queue.id).delete()
CallCenterTier.query.filter(CallCenterTier.queue_id==queue.id).delete()
CallCenterQueue.query.filter(CallCenterQueue.id==q.id).filter(CallCenterQueue.context==session['context']).delete()
db.commit()
db.flush()
return True
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def get_talk_time(ext, context):
rows = db.execute("SELECT coalesce(sum(billsec)/60,0) AS mins FROM cdr "
"WHERE (caller_id_number=:ext OR destination_number=:ext) "
"AND start_stamp BETWEEN CURRENT_DATE AND CURRENT_TIMESTAMP "
"AND bleg_uuid IS NOT NULL AND context = :context",
{'ext':ext, 'context': context})
r = rows.fetchone()
db.remove()
return r.mins
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def delete_ivr(name):
for ivr in PbxIVR.query.filter_by(name=name).filter_by(context=session['context']).all():
r = PbxRoute.query.filter(PbxRoute.pbx_route_type_id==5).\
filter(PbxRoute.name==ivr.name).filter(PbxRoute.context==session['context']).first()
did = PbxDid.did.query.filter(PbxDid.pbx_route_id==r.id).first()
if did:
msg = "Error: IVR is in use by Inbound DID: "+str(did.did)+"!"
tod = db.execute("select * from pbx_tod_routes where match_route_id = :id or nomatch_route_id = :id", {'id': r.id}).first()
if tod:
msg = "Error: IVR is in a TOD route!"
ivr_opt = PbxIVROption.query.filter(PbxIVROption.pbx_route_id==r.id).first()
if ivr_opt:
msg = "Error: IVR belongs to another IVR Option."
if not did and not ivr_opt and not tod:
PbxRoute.query.filter(PbxRoute.pbx_route_type_id==5).\
filter(PbxRoute.name==ivr.name).filter(PbxRoute.context==session['context']).delete()
PbxIVROption.query.filter(PbxIVROption.pbx_ivr_id==ivr.id).delete()
PbxIVR.query.filter(PbxIVR.name==name).filter(PbxIVR.context==session['context']).delete()
db.commit()
db.flush()
db.remove()
else:
return msg
db.remove()
return "Successfully deleted IVR: "+name+"."
def get_volume(ext, context):
rows = db.execute("SELECT count(*) AS ct "
"FROM cdr "
"WHERE (caller_id_number=:ext OR destination_number=:ext) "
"AND start_stamp BETWEEN CURRENT_DATE "
"AND CURRENT_TIMESTAMP AND bleg_uuid IS NOT NULL "
"AND context = :context",
{'ext':ext, 'context': context})
r = rows.fetchone()
db.remove()
return r.ct
def account_lead_types(self):
items = []
for act in CrmLeadType.query.filter(context=session["context"]).all():
items.append({"id": act.id, "name": act.name, "desc": act.description})
db.remove()
out = dict({"identifier": "id", "label": "name", "items": items})
response = make_response(out)
response.headers = [("Content-type", "application/json")]
return response(request.environ, self.start_response)
def billing_service_types(self):
items=[]
for bs in BillingServiceType.query.all():
items.append({'id': bs.id, 'name': bs.name, 'description': bs.description})
db.remove()
out = dict({'identifier': 'id', 'label': 'name', 'items': items})
response = make_response(out)
response.headers = [("Content-type", 'application/json'),]
return response(request.environ, self.start_response)
def authenticate(username, password):
auth_user = User.query.filter(User.username==username).first()
if not auth_user:
log.debug("No user named: '%s'", username)
return False
elif not auth_user.password:
log.error("Bad user/pass:'******'")
return False
elif password != auth_user.password:
log.debug("database password for user '%s'", username)
return False
else:
session['username'] = auth_user.username
session['password'] = auth_user.password
session['customer_id'] = auth_user.customer_id
session['user_id'] = auth_user.id
session['name'] = auth_user.first_name+' '+auth_user.last_name
session["last_login"] = auth_user.last_login
session['has_crm'] = auth_user.has_crm
session['customer_name'] = auth_user.get_customer_name(auth_user.customer_id)
if auth_user.has_crm:
ea = auth_user.get_email_account()
session['email_server'] = ea.mail_server
session['email'] = ea.email
session['email_password'] = ea.password
if auth_user.has_call_center():
session['has_call_center'] = True
else:
session['has_call_center'] = False
session['is_agent'] = auth_user.is_agent()
session['context'] = auth_user.get_context()
session['ext'] = auth_user.get_extension()
request.environ["REMOTE_USER"] = auth_user.username
request.environ["HTTP_REMOTE_USER"] = auth_user.username
if auth_user and not auth_user.active:
return False
log.info("authenticated user %s", auth_user.username)
session["perms"] = auth_user.permissions
session['group_id'] = auth_user.group_id
session["user"] = auth_user
session.save()
auth_user.register_login(username, session, request)
db.commit()
db.flush()
return True
def get_route_labels_ids():
route_labels = []
route_ids = []
for row in db.execute("SELECT sr.id, srt.name|| ':' ||sr.name AS name "
"FROM pbx_routes sr "
"INNER JOIN pbx_route_types srt ON sr.pbx_route_type_id = srt.id "
"WHERE sr.context = :context", {'context': session['context']}):
route_labels.append(row.name)
route_ids.append(row.id)
db.remove()
return (route_labels,route_ids)
def campaigns_ids(self):
names = []
ids = []
for row in CrmCampaign.query.filter(context=session["context"]).all():
names.append(row.name)
ids.append(row.id)
db.remove()
headers = [("Content-type", "application/json")]
out = dict({"names": names, "ids": ids})
response = make_response(out)
return response(request.environ, self.start_response)
def get_talk_time(ext, context):
rows = db.execute(
"SELECT coalesce(sum(billsec)/60,0) AS mins FROM cdr "
"WHERE (caller_id_number=:ext OR destination_number=:ext) "
"AND start_stamp BETWEEN CURRENT_DATE AND CURRENT_TIMESTAMP "
"AND bleg_uuid IS NOT NULL AND context = :context", {
'ext': ext,
'context': context
})
r = rows.fetchone()
db.remove()
return r.mins
def queue_delete(q):
for queue in CallCenterQueue.query.filter(
CallCenterQueue.id == q.id).filter(
CallCenterQueue.context == session['context']).all():
PbxRoute.query.filter(PbxRoute.pbx_route_type_id == 10).filter(
PbxRoute.pbx_to_id == queue.id).delete()
CallCenterTier.query.filter(
CallCenterTier.queue_id == queue.id).delete()
CallCenterQueue.query.filter(CallCenterQueue.id == q.id).filter(
CallCenterQueue.context == session['context']).delete()
db.commit()
db.flush()
return True
def get_route_labels_ids():
route_labels = []
route_ids = []
for row in db.execute(
"SELECT sr.id, srt.name|| ':' ||sr.name AS name "
"FROM pbx_routes sr "
"INNER JOIN pbx_route_types srt ON sr.pbx_route_type_id = srt.id "
"WHERE sr.context = :context", {'context': session['context']}):
route_labels.append(row.name)
route_ids.append(row.id)
db.remove()
return (route_labels, route_ids)
def update_campaign_grid(self, **kw):
w = loads(urllib.unquote_plus(request.params.get("data")))
try:
for i in w['modified']:
sg = CrmCampaignGroup.query.filter(
CrmCampaignGroup.crm_campaign_id == i['id']).filter(
CrmCampaignGroup.context ==
session['context']).first()
CrmGroupMember.query.filter(
CrmGroupMember.crm_group_id == sg.crm_group_id).delete()
for gm in i['members'].split(","):
if not gm.strip().isdigit():
continue
sm = CrmGroupMember()
sm.crm_group_id = sg.crm_group_id
sm.extension = gm.strip()
sm.context = session['context']
db.add(sm)
db.commit()
db.flush()
except:
db.remove()
return "Error updating campaign."
return "Successfully updated campaign."
def campaigns_ids(self):
names = []
ids = []
for row in CrmCampaign.query.filter(context=session['context']).all():
names.append(row.name)
ids.append(row.id)
db.remove()
headers = [
("Content-type", 'application/json'),
]
out = dict({'names': names, 'ids': ids})
response = make_response(out)
return response(request.environ, self.start_response)
def get_volume(ext, context):
rows = db.execute(
"SELECT count(*) AS ct "
"FROM cdr "
"WHERE (caller_id_number=:ext OR destination_number=:ext) "
"AND start_stamp BETWEEN CURRENT_DATE "
"AND CURRENT_TIMESTAMP AND bleg_uuid IS NOT NULL "
"AND context = :context", {
'ext': ext,
'context': context
})
r = rows.fetchone()
db.remove()
return r.ct
def agent_add(self):
schema = AgentForm()
try:
form_result = schema.to_python(request.params)
cca = CallCenterAgent()
cca.extension = form_result.get('extension')
e = PbxEndpoint.query.filter_by(
user_context=session['context']).filter(
PbxEndpoint.auth_id == cca.extension).first()
cca.context = session['context']
cca.domain = session['context']
cca.type = 'callback'
cca.system = 'single_box'
cca.name = cca.extension + "@" + session['context']
cca.timeout = form_result.get('timeout', 30)
cca.contact = "[call_timeout=" + cca.timeout + "]user/" + cca.name
cca.max_no_answer = form_result.get('max_no_answer', 3)
cca.wrap_up_time = form_result.get('wrap_up_time', 30)
cca.reject_delay_time = form_result.get('reject_delay_time', 30)
cca.busy_delay_time = form_result.get('busy_delay_time', 0)
cca.no_answer_delay_time = form_result.get('no_answer_delay_time',
5)
cca.record_calls = form_result.get('record_calls', 0)
cca.status = 'Available'
cca.state = 'Waiting'
cca.user_id = e.user_id
cca.pbx_endpoint_id = e.id
db.add(cca)
db.commit()
db.flush()
except validators.Invalid, error:
db.remove()
return 'Error: %s.' % error
def update_campaign_grid(self, **kw):
w = loads(urllib.unquote_plus(request.params.get("data")))
try:
for i in w["modified"]:
sg = (
CrmCampaignGroup.query.filter(CrmCampaignGroup.crm_campaign_id == i["id"])
.filter(CrmCampaignGroup.context == session["context"])
.first()
)
CrmGroupMember.query.filter(CrmGroupMember.crm_group_id == sg.crm_group_id).delete()
for gm in i["members"].split(","):
if not gm.strip().isdigit():
continue
sm = CrmGroupMember()
sm.crm_group_id = sg.crm_group_id
sm.extension = gm.strip()
sm.context = session["context"]
db.add(sm)
db.commit()
db.flush()
except:
db.remove()
return "Error updating campaign."
return "Successfully updated campaign."
def getCallers(self, sid):
callers = []
user = User.query.filter_by(session_id=sid).first()
if user:
context = user.get_context()
for row in PbxDid.query.filter(PbxDid.context == context).all():
for cal in db.execute(
"SELECT * FROM channels WHERE dest like :did", {
'did': "%" + row.did
}).fetchall():
#PbxChannel.query.filter(PbxChannel.dest.like('%'+row.did).all():
l = PbxChannel.query.filter_by(uuid=cal.uuid).first()
if l:
to_user = l.dest
status = l.callstate
else:
to_user = ""
status = ""
direction = "inbound"
if len(cal.cid_num) > 10:
cid_num = cal.cid_num[len(cal.cid_num) - 10:]
else:
cid_num = cal.cid_num
time_in_queue = db.execute(
"SELECT now() FROM channels WHERE uuid = :uuid", {
'uuid': cal.uuid
}).fetchone()
callers.append(
make_caller(cal.dest, cal.cid_name, cid_num, direction,
cal.created, time_in_queue[0], to_user,
cal.uuid, status))
for cal in PbxChannel.query.filter_by(context=context).distinct(
PbxChannel.call_uuid).all():
if len(cal.presence_id) > 3:
if cal.presence_id.split("@")[1] == context:
time_in_queue = db.execute(
"SELECT now() FROM channels WHERE uuid = :uuid", {
'uuid': cal.uuid
}).fetchone()
callers.append(
make_caller(cal.dest, cal.cid_name, cal.cid_num, "outbound",
cal.created, "", cal.dest, cal.uuid,
cal.callstate))
db.remove()
return callers
def account_by_id(self, id):
items = []
for account in CrmAccount.query.join(CrmCampaign).filter(CrmAccount.customer_id==session['customer_id'])\
.filter(CrmAccount.user_id==session['user_id']).filter(CrmCampaign.name==id).all():
items.append({'id': account.id, 'name': str(account.first_name)+" "+str(account.last_name), 'address': account.address, \
'city': account.city, 'state': account.state, 'zip': account.zip, 'tel': account.tel, 'mobile': account.mobile, \
'email': account.email, 'crm_campaign_id': account.crm_campaign_id})
db.remove()
out = dict({'identifier': 'id', 'label': 'name', 'items': items})
response = make_response(out)
response.headers = [
("Content-type", 'application/json'),
]
return response(request.environ, self.start_response)
class Ticket(Base):
__tablename__ = 'tickets'
query = db.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
customer_id = Column(
Integer,
ForeignKey('customers.id', onupdate="CASCADE", ondelete="CASCADE"))
opened_by = Column(
Integer, ForeignKey('users.id', onupdate="CASCADE",
ondelete="CASCADE"))
ticket_status_id = Column(
Integer,
ForeignKey('ticket_statuses.id',
onupdate="CASCADE",
ondelete="CASCADE"))
ticket_priority_id = Column(
Integer,
ForeignKey('ticket_priorities.id',
onupdate="CASCADE",
ondelete="CASCADE"))
ticket_type_id = Column(
Integer,
ForeignKey('ticket_types.id', onupdate="CASCADE", ondelete="CASCADE"))
created = Column(DateTime, default=datetime.now())
expected_resolve_date = Column(DateTime, default=datetime.now())
subject = Column(Unicode(255), nullable=True)
description = Column(UnicodeText, nullable=False)
ticket_note = relationship('TicketNote', backref='ticket_notes')
ticket_type = relationship('TicketType', backref='ticket_types')
ticket_priority = relationship('TicketPriority',
backref='ticket_priorities')
ticket_status = relationship('TicketStatus', backref='ticket_statuses')
def callOutbound(self, sid, did):
user = User.query.filter_by(session_id=sid).first()
if user:
context = user.get_context()
else:
return
ep = db.execute(
"SELECT pbx_endpoints.outbound_caller_id_number AS pbx_endpoints_outbound_caller_id_number, customers.tel AS customers_tel "
"FROM pbx_endpoints "
"INNER JOIN customers on customers.context = pbx_endpoints.user_context "
"WHERE customers.context = :context AND customers.id = :customer_id AND pbx_endpoints.auth_id = :auth_id",
{
'context': context,
'customer_id': user.customer_id,
'auth_id': user.portal_extension
}).fetchone()
if len(ep[0]) == 10:
origination_caller_id_number = ep[0]
else:
origination_caller_id_number = ep[1]
con = ESLconnection(ESL_HOST, ESL_PORT, ESL_PASS)
if con.connected:
con.bgapi(
"originate",
"{ringback=\'%(2000,4000,440.0,480.0)\',origination_caller_id_name=Click-To-Call,effective_caller_id_number="
+ str(origination_caller_id_number) + "}user/" +
str(user.portal_extension) + "@" + str(context) +
" &bridge(sofia/gateway/" + str(user.get_gateway()) + "/" +
str(did) + ")")
class AdminGroup(Base):
__tablename__ = 'admin_groups'
query = db.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
name = Column(Unicode(64), unique=True, nullable=False)
description = Column(UnicodeText)
created_date = Column(DateTime, default=datetime.now)
admin_users = relationship("AdminUser",
secondary=admin_user_groups,
backref='admin_groups')
@property
def permissions(self):
perms = []
for perm in self.admin_permissions:
perms.append(perm.name)
return perms
def __init__(self, name, description):
self.name = name
self.description = description
self.created_date = datetime.now()
def __repr__(self):
return '<AdminGroup: name=%s>' % self.name
def __unicode__(self):
return self.name
def get_volume(ext):
rows = db.execute("select count(*) as ct "
"from cdr where (caller_id_number=:ext or destination_number=:ext) "
"and start_stamp between CURRENT_DATE "
"and CURRENT_TIMESTAMP and bleg_uuid is not null and context = :context",{'ext':ext, 'context': session['context']})
r = rows.fetchone()
return r.ct
def get_queue_calls(self):
log.debug(request.params.get("sid"))
user = User.query.filter_by(
session_id=request.params.get("sid")).first()
if user:
context = user.get_context()
else:
return ""
items = []
sql = "SELECT * FROM call_center_callers WHERE queue like '%@{0}'".format(
context)
for call in db.execute(sql):
items.append({
'queue': call.queue.split("@")[0],
'cid_name': call.cid_name,
'cid_number': call.cid_number,
'agent': call.serving_agent.split("@")[0],
'state': call.state,
'uuid': call.uuid
})
if not len(items) == 0:
return ""
out = items
response = make_response(out)
response.headers = [
("Content-type", 'application/json; charset=UTF-8'),
]
return response(request.environ, self.start_response)
class CallCenterQueue(Base):
__tablename__ = 'call_center_queues'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
domain = Column(Unicode(64), default=u"sip.vwna.com")
context = Column(Unicode(128), default=u"sip.vwna.com")
name = Column(Unicode(64))
audio_type = Column(Integer)
audio_name = Column(Unicode(255))
strategy = Column(Unicode(64), default=u'longest-idle-agent')
moh_sound = Column(Unicode(255), default=u'local_stream://moh')
time_base_score = Column(Unicode(32), default=u'system')
max_wait_time = Column(Integer, default=300)
max_wait_time_with_no_agent = Column(Integer, default=300)
max_wait_time_with_no_agent_reached = Column(Integer, default=90)
tier_rules_apply = Column(Boolean, default=False)
tier_rule_wait_second = Column(Integer, default=300)
tier_rule_wait_multiply_level = Column(Boolean, default=True)
tier_rule_agent_no_wait = Column(Boolean, default=True)
discard_abandoned_after = Column(Integer, default=300)
abandoned_resume_allowed = Column(Boolean, default=False)
failed_route_id = Column(
Integer,
ForeignKey('pbx_routes.id', onupdate="CASCADE", ondelete="CASCADE"))
record_calls = Column(Boolean, default=False)
announce_position = Column(Boolean, default=False)
announce_sound = Column(Unicode(1024))
announce_frequency = Column(Integer, default=60)
approx_hold_time = Column(Integer, default=300)
def __str__(self):
return self.id
class PbxDialog(Base):
__tablename__ = 'sip_dialogs'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
call_id = Column(Unicode(255))
uuid = Column(Unicode(255))
sip_to_user = Column(Unicode(255))
sip_to_host = Column(Unicode(255))
sip_from_user = Column(Unicode(255))
sip_from_host = Column(Unicode(255))
contact_user = Column(Unicode(255))
contact_host = Column(Unicode(255))
state = Column(Unicode(255))
direction = Column(Unicode(255))
user_agent = Column(Unicode(255))
profile_name = Column(Unicode(255))
hostname = Column(Unicode(255))
contact = Column(Unicode(255))
presence_id = Column(Unicode(255))
presence_data = Column(Unicode(255))
call_info = Column(Unicode(255))
call_info_state = Column(Unicode(255))
expires = Column(Integer, default=0)
status = Column(Unicode(255))
rpid = Column(Unicode(255))
sip_to_tag = Column(Unicode(255))
sip_from_tag = Column(Unicode(255))
rcd = Column(Integer, default=0)
class VoipPbxServiceProfile(Base):
__tablename__ = 'pbx_voip_service_profiles'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
voip_service_id = Column(
Integer,
ForeignKey('voip_services.id', onupdate='CASCADE', ondelete='CASCADE'))
voip_service_policy_id = Column(Integer, default=0)
name = Column(Unicode(64))
description = Column(UnicodeText)
amount = Column(Numeric)
max_extensions_enforced = Column(Boolean, default=False)
max_extensions = Column(Integer, default=0)
included_extension_minutes_enforced = Column(Boolean, default=False)
included_extension_minutes = Column(Integer, default=0)
included_pbx_minutes = Column(Integer, default=0)
included_pbx_minutes_enforced = Column(Boolean, default=False)
can_create_extensions = Column(Boolean, default=True)
can_delete_metered_extensions = Column(Boolean, default=True)
overage_fee = Column(Numeric)
billable_seconds_increment = Column(Integer, default=0)
max_virtual_extensions = Column(Integer, default=0)
enforce_max_virtual_extensions = Column(Boolean, default=False)
class PbxGateway(Base):
__tablename__ = 'pbx_gateways'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
name = Column(Unicode(64), nullable=True)
pbx_profile_id = Column(
Integer,
ForeignKey('pbx_profiles.id', onupdate="CASCADE", ondelete="CASCADE"))
username = Column(Unicode(64), nullable=True)
password = Column(Unicode(64), nullable=True)
proxy = Column(Unicode(64), nullable=True)
mask = Column(Unicode(15), default=u'32')
register = Column(Boolean, default=False)
register_proxy = Column(Unicode(128), nullable=True)
register_transport = Column(Unicode(64), default=u"udp")
extension = Column(Unicode(64), nullable=True)
realm = Column(Unicode(64), nullable=True)
from_domain = Column(Unicode(64), nullable=True)
from_user = Column(Unicode(32), nullable=True)
expire_seconds = Column(Integer, nullable=False, default=600)
retry_seconds = Column(Integer, nullable=False, default=30)
ping = Column(Unicode(4), default=u"60")
context = Column(Unicode(32), default=u"default")
caller_id_in_from = Column(Boolean, default=False)
contact_params = Column(Unicode(32), nullable=True)
rfc5626 = Column(Boolean, default=True)
reg_id = Column(Integer, nullable=True, default=1)
def __str__(self):
return self.name
def get_findme(name, context):
e = PbxEndpoint.query.filter_by(user_context=context).filter_by(auth_id=name).first()
fm = db.execute("SELECT default_gateway FROM Customers "
"INNER JOIN Users on Users.customer_id=Customers.id "
"WHERE Users.id = :user_id", {'user_id': e.user_id}).fetchone()
ds = []
if e.find_me:
if e.follow_me_1:
if len(e.follow_me_1) < 8:
ds.append(u"user/"+e.follow_me_1+"@"+str(context))
else:
ds.append(u"sofia/gateway/"+str(fm[0])+"/{0}".format(e.follow_me_1))
if e.follow_me_2:
if len(e.follow_me_2) < 8:
ds.append(u"user/"+e.follow_me_2+"@"+str(context))
else:
ds.append(u"sofia/gateway/"+str(fm[0])+"/{0}".format(e.follow_me_2))
if e.follow_me_3:
if len(e.follow_me_3) < 8:
ds.append(u"user/"+e.follow_me_3+"@"+str(context))
else:
ds.append(u"sofia/gateway/"+str(fm[0])+"/{0}".format(e.follow_me_3))
if e.follow_me_4:
if len(e.follow_me_4) < 8:
ds.append(u"user/"+e.follow_me_4+"@"+str(context))
else:
ds.append(u"sofia/gateway/"+str(fm[0])+"/{0}".format(e.follow_me_4))
return ds
class PbxContext(Base):
__tablename__ = 'pbx_contexts'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
customer_id = Column(
Integer,
ForeignKey('customers.id', onupdate="CASCADE", ondelete="CASCADE"))
domain = Column(Unicode(64), unique=True)
profile = Column(Unicode(64))
context = Column(Unicode(128))
caller_id_name = Column(Unicode(64))
caller_id_number = Column(Unicode(15))
gateway = Column(Unicode(64), default=u'default')
def __init__(self,
customer_id=None,
domain=None,
context=None,
gateway=None,
profile=None,
caller_id_name=None,
caller_id_number=None):
self.customer_id = customer_id
self.domain = domain
self.context = context
self.gateway = gateway
self.profile = profile
self.caller_id_name = caller_id_name
self.caller_id_number = caller_id_number
def by_domain(self, domain=None):
return Session.query(PbxContext).filter_by(domain=domain).first()
class PbxCallingRule(Base):
__tablename__ = 'pbx_calling_rules'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
name = Column(Unicode(64))
def get_queue_calls(self):
log.debug(request.params.get("sid"))
user = User.query.filter_by(session_id=request.params.get("sid")).first()
if user:
context = user.get_context()
else:
return ""
items = []
sql = "SELECT * FROM call_center_callers WHERE queue like '%@{0}'".format(context)
for call in db.execute(sql):
items.append(
{
"queue": call.queue.split("@")[0],
"cid_name": call.cid_name,
"cid_number": call.cid_number,
"agent": call.serving_agent.split("@")[0],
"state": call.state,
"uuid": call.uuid,
}
)
if not len(items) == 0:
return ""
out = items
response = make_response(out)
response.headers = [("Content-type", "application/json; charset=UTF-8")]
return response(request.environ, self.start_response)
class CallCenterTier(Base):
__tablename__ = 'call_center_tiers'
query = Session.query_property()
def __init__(self,
queue=None,
agent=None,
state='Waiting',
level=None,
position=None):
self.queue = queue
self.agent = agent
self.state = state
self.level = level
self.position = position
id = Column(Integer, autoincrement=True, primary_key=True)
queue_id = Column(
Integer,
ForeignKey('call_center_queues.id',
onupdate="CASCADE",
ondelete="CASCADE"))
agent_id = Column(
Integer,
ForeignKey('call_center_agents.id',
onupdate="CASCADE",
ondelete="CASCADE"))
extension = Column(Unicode(15), nullable=True)
queue = Column(Unicode(255))
agent = Column(Unicode(255))
state = Column(Unicode(255))
level = Column(Integer)
position = Column(Integer, nullable=False, default=0)
class PbxRegistration(Base):
__tablename__ = 'sip_registrations'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
call_id = Column(Unicode(255))
sip_user = Column(Unicode(255))
sip_host = Column(Unicode(255))
presence_hosts = Column(Unicode(255))
contact = Column(Unicode(1024))
status = Column(Unicode(255))
rpid = Column(Unicode(255))
expires = Column(Integer)
user_agent = Column(Unicode(255))
server_user = Column(Unicode(255))
server_host = Column(Unicode(255))
profile_name = Column(Unicode(255))
hostname = Column(Unicode(255))
network_ip = Column(Unicode(255))
network_port = Column(Unicode(255))
sip_username = Column(Unicode(255))
sip_realm = Column(Unicode(255))
mwi_user = Column(Unicode(255))
mwi_host = Column(Unicode(255))
orig_server_host = Column(Unicode(255))
orig_hostname = Column(Unicode(255))
sub_host = Column(Unicode(255))
class PbxCdr(Base):
__tablename__ = 'cdr'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
caller_id_name = Column(Unicode(64))
caller_id_number = Column(Unicode(64))
destination_number = Column(Unicode(64))
context = Column(Unicode(64))
start_stamp = Column(DateTime, default=datetime.now())
answer_stamp = Column(DateTime, default=datetime.now())
end_stamp = Column(DateTime, default=datetime.now())
duration = Column(Integer, default=0)
billsec = Column(Integer, default=0)
hangup_cause = Column(Unicode(128))
uuid = Column(Unicode(64))
bleg_uuid = Column(Unicode(64))
accountcode = Column(Unicode(16))
local_ip_v4 = Column(Unicode(15))
read_codec = Column(Unicode(128))
write_codec = Column(Unicode(128))
call_direction = Column(Unicode(16))
user_id = Column(Unicode(16))
customer_id = Column(Unicode(16))
extension = Column(Unicode(16))
def __repr__(self):
return "PbxCdr(%(id)s)" % self.__dict__
class e911StreetType(Base):
__tablename__ = 'e911_street_types'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
name = Column(Unicode(32))
def get_campaigns():
return db.execute(
"SELECT crm_campaigns.name FROM crm_campaigns "
"INNER JOIN crm_campaign_groups ON crm_campaigns.id = crm_campaign_groups.crm_campaign_id "
"INNER JOIN crm_group_members ON crm_group_members.crm_group_id = crm_campaign_groups.id "
"WHERE crm_group_members.extension = :ext", {
'ext': session['ext']
}).fetchall()
def account_lead_types(self):
items = []
for act in CrmLeadType.query.filter(context=session['context']).all():
items.append({
'id': act.id,
'name': act.name,
'desc': act.description
})
db.remove()
out = dict({'identifier': 'id', 'label': 'name', 'items': items})
response = make_response(out)
response.headers = [
("Content-type", 'application/json'),
]
return response(request.environ, self.start_response)
class TicketStatus(Base):
__tablename__ = 'ticket_statuses'
query = db.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
name = Column(Unicode(32), default=u'Unknown')
description = Column(Unicode(255), default=u'Unknown')
def account_notes_by_id(self, id, **kw):
items = []
for note in CrmNote.query.filter(CrmNote.crm_account_id == id).all():
items.append(
{
"id": note.id,
"created": note.created.strftime("%m/%d/%Y %I:%M:%S %p"),
"note": note.note,
"crm_account_id": note.crm_account_id,
}
)
db.remove()
out = dict({"identifier": "id", "label": "name", "items": items})
response = make_response(out)
response.headers = [("Content-type", "application/json")]
return response(request.environ, self.start_response)
class PbxFax(Base):
__tablename__ = 'pbx_faxes'
query = Session.query_property()
id = Column(Integer, autoincrement=True, primary_key=True)
context = Column(Unicode(64), default=u'sip.freepybx.org')
domain = Column(Unicode(128), default=u'sip.freepybx.org')
extension = Column(Unicode(128), nullable=False)
def getAgents(self, sid):
agents = []
user = User.query.filter_by(session_id=sid).first()
if user:
context = user.get_context()
else:
raise Exception("No user in session...")
for row in User.query.filter(User.customer_id==user.customer_id).all():
if not len(row.portal_extension):
continue
else:
extension = row.portal_extension
agent = make_agent(row.first_name+' '+row.last_name, get_volume(extension, context), get_talk_time(extension, context))
agents.append(agent)
db.remove()
return agents
def get_queue_recordings(self):
files = []
queue = request.params.get("queue_name")
dir = fs_vm_dir + session["context"] + "/queue-recordings/" + queue
for i in os.listdir(dir):
path = dir + "/" + i
id = i.split(".")[3].strip()
row = PbxCdr.query.filter(PbxCdr.uuid == id).first()
if row:
caller = row.caller_id_number[len(row.caller_id_number) - 10 :]
dest = row.destination_number
agent = PbxCdr.query.filter(PbxCdr.uuid == row.bleg_uuid).first()
agent_ext = agent.destination_number
else:
agent_ext = "No CDR"
dest = "No CDR"
caller = "No CDR"
tpath = "/vm/" + session["context"] + "/queue-recordings/" + queue + "/" + i
received = str(modification_date(path)).strip('"')
fsize = str(os.path.getsize(path))
files.append(
{
"name": caller,
"queue": queue,
"destination": dest,
"agent": agent_ext,
"path": tpath,
"received": received,
"size": fsize,
}
)
db.remove()
out = dict({"identifier": "path", "label": "name", "items": files})
response = make_response(out)
response.headers = [("Content-type", "application/json; charset=UTF-8")]
return response(request.environ, self.start_response)
def campaigns(self):
items = []
members = []
for campaign in CrmCampaign.query.filter(context=session["context"]).all():
for member in (
CrmGroupMember.query.join(CrmGroup)
.join(CrmCampaignGroup)
.filter(CrmCampaignGroup.crm_campaign_id == campaign.id)
.all()
):
members.append(member.extension)
items.append({"id": campaign.id, "name": campaign.name, "members": ",".join(members)})
members = []
db.remove()
out = dict({"identifier": "id", "label": "name", "items": items})
response = make_response(out)
response.headers = [("Content-type", "application/json")]
return response(request.environ, self.start_response)
def del_blacklist(cid_number):
PbxBlacklistedNumber.query.filter(PbxBlacklistedNumber.cid_number==cid_number)\
.filter(PbxBlacklistedNumber.context==session['context']).delete()
db.commit()
db.flush()
db.remove()
return True
def agent_edit(self):
schema = AgentEditForm()
try:
form_result = schema.to_python(request.params)
cca = (
CallCenterAgent.query.filter_by(context=session["context"])
.filter(CallCenterAgent.id == form_result.get("agent_id"))
.first()
)
cca.extension = form_result.get("extension")
e = (
PbxEndpoint.query.filter_by(user_context=session["context"])
.filter(PbxEndpoint.auth_id == cca.extension)
.first()
)
cca.context = session["context"]
cca.domain = session["context"]
cca.type = "callback"
cca.record_calls = form_result.get("record_calls", 0)
cca.timeout = form_result.get("timeout", 30)
cca.max_no_answer = form_result.get("max_no_answer", 3)
cca.wrap_up_time = form_result.get("wrap_up_time", 30)
cca.reject_delay_time = form_result.get("reject_delay_time", 30)
cca.busy_delay_time = form_result.get("busy_delay_time", 0)
cca.no_answer_delay_time = form_result.get("no_answer_delay_time", 5)
cca.user_id = e.user_id
cca.pbx_endpoint_id = e.id
db.commit()
db.flush()
except validators.Invalid, error:
db.remove()
return "Error: %s." % error
def delete_cid(cid_number):
PbxCallerIDRoute.query.filter(PbxCallerIDRoute.cid_number==cid_number)\
.filter(PbxCallerIDRoute.context==session['context']).delete()
db.commit()
db.flush()
db.remove()
return True
def edit_crm_account(self, **kw):
schema = CrmAccountForm()
try:
form_result = schema.to_python(request.params)
ca = CrmAccount.query.filter(id=form_result["id"]).filter(customer_id=session["customer_id"]).first()
ca.first_name = form_result.get("first_name", "Unknown")
ca.last_name = form_result.get("last_name", "Unknown")
ca.customer = form_result.get("customer")
ca.title = form_result.get("title")
ca.email = form_result.get("email")
ca.address = form_result.get("address")
ca.address_2 = form_result.get("address_2")
ca.city = form_result.get("city")
ca.state = form_result.get("state")
ca.zip = form_result.get("zip")
ca.tel = form_result.get("tel")
ca.tel_ext = form_result.get("tel_ext")
ca.mobile = form_result.get("mobile")
if request.params.has_key("active"):
ca.active = True
else:
ca.active = False
ca.customer_id = session["customer_id"]
ca.user_id = session["user_id"]
ca.crm_campaign_id = form_result.get("crm_campaign_name")
ca.crm_account_status_type_id = form_result.get("status_type_name")
ca.crm_lead_type_id = form_result.get("crm_lead_type_name")
db.add(ca)
db.commit()
db.flush()
except validators.Invalid, error:
return "Error: %s" % error
def register_login(class_, username, session, request):
user = db.query(AdminUser).filter(AdminUser.username==username).first()
if user:
now = datetime.now()
user.last_login = now
user.session_id = session.id
user.remote_addr = request.environ["HTTP_REMOTE_EU"]
db.commit()
db.flush()
db.remove()
def delete_conf(extension):
PbxRoute.query.filter(PbxRoute.pbx_route_type_id==7)\
.filter(PbxRoute.name==extension).filter(PbxRoute.context==session['context']).delete()
PbxConferenceBridge.query.filter(PbxConferenceBridge.extension==extension).delete()
db.commit()
db.flush()
db.remove()
return True
def add_crm_account_note(self, **kw):
try:
cn = CrmNote()
cn.note = request.params.get("crm_note")
cn.crm_account_id = request.params.get("crm_acct_id")
cn.created = datetime.now()
db.add(cn)
db.commit()
db.flush()
except validators.Invalid, error:
db.remove()
return "Error: %s" % error
