def phonebook_list(request):
"""Phonebook list for the logged in user
**Attributes**:
* ``template`` - frontend/phonebook/list.html
**Logic Description**:
* List all phonebooks which belong to the logged in user.
"""
sort_col_field_list = ["id", "name", "updated_date"]
default_sort_field = "id"
pagination_data = get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data["PAGE_SIZE"]
sort_order = pagination_data["sort_order"]
phonebook_list = (
Phonebook.objects.annotate(contact_count=Count("contact")).filter(user=request.user).order_by(sort_order)
)
template = "frontend/phonebook/list.html"
data = {
"msg": request.session.get("msg"),
"phonebook_list": phonebook_list,
"total_phonebook": phonebook_list.count(),
"PAGE_SIZE": PAGE_SIZE,
"PHONEBOOK_COLUMN_NAME": PHONEBOOK_COLUMN_NAME,
"col_name_with_order": pagination_data["col_name_with_order"],
"dialer_setting_msg": user_dialer_setting_msg(request.user),
}
request.session["msg"] = ""
request.session["error_msg"] = ""
return render_to_response(template, data, context_instance=RequestContext(request))
def contact_change(request, object_id):
"""Update/Delete contact for the logged in user
**Attributes**:
* ``object_id`` - Selected contact object
* ``form`` - ContactForm
* ``template`` - frontend/contact/change.html
**Logic Description**:
* Update/delete selected contact from the contact list
via ContactForm & get redirected to the contact list
"""
contact = get_object_or_404(Contact, pk=object_id, phonebook__user=request.user)
form = ContactForm(request.user, instance=contact)
if request.method == "POST":
# Delete contact
if request.POST.get("delete"):
return HttpResponseRedirect("/contact/del/%s/" % object_id)
else:
# Update contact
form = ContactForm(request.user, request.POST, instance=contact)
if form.is_valid():
form.save()
request.session["msg"] = _('"%s" is updated.') % request.POST["contact"]
return HttpResponseRedirect("/contact/")
template = "frontend/contact/change.html"
data = {"form": form, "action": "update", "dialer_setting_msg": user_dialer_setting_msg(request.user)}
return render_to_response(template, data, context_instance=RequestContext(request))
def alarm_add(request):
"""Add a new alarm for the logged in user
**Attributes**:
* ``form`` - AlarmForm
* ``template`` - frontend/appointment/alarm/change.html
**Logic Description**:
* Add new alarm belonging to the logged in user
via AlarmForm & get redirected to the alarm list
"""
form = AlarmForm(request.user)
error_msg = False
# Add alarm
if request.method == 'POST':
form = AlarmForm(request.user, request.POST)
if form.is_valid():
obj = form.save()
request.session["msg"] = _('"%s" is added.') % obj
return HttpResponseRedirect(redirect_url_to_alarm_list)
template = 'frontend/appointment/alarm/change.html'
data = {
'form': form,
'action': 'add',
'error_msg': error_msg,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def calendar_setting_add(request):
"""Add a new calendar setting for the logged in user
**Attributes**:
* ``form`` - CalendarSettingForm
* ``template`` - frontend/appointment/calendar_setting/change.html
**Logic Description**:
* Add new calendar_setting belonging to the logged in user
via ContactSettingForm & get redirected to the calendar_setting list
"""
form = CalendarSettingForm(request.user)
error_msg = False
# Add calendar_setting
if request.method == 'POST':
form = CalendarSettingForm(request.user, request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.user = request.user
obj.save()
request.session["msg"] = _('"%s" is added.') % obj
return HttpResponseRedirect(redirect_url_to_calendar_setting_list)
template = 'frontend/appointment/calendar_setting/change.html'
data = {
'form': form,
'action': 'add',
'error_msg': error_msg,
'AMD': settings.AMD,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def phonebook_add(request):
"""Add new Phonebook for the logged in user
**Attributes**:
* ``form`` - PhonebookForm
* ``template`` - frontend/phonebook/change.html
**Logic Description**:
* Add a new phonebook which will belong to the logged in user
via the phonebookForm & get redirected to the phonebook list
"""
form = PhonebookForm()
if request.method == "POST":
form = PhonebookForm(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.user = request.user
obj.save()
request.session["msg"] = _('"%(name)s" added.') % {"name": request.POST["name"]}
return HttpResponseRedirect("/phonebook/")
template = "frontend/phonebook/change.html"
data = {"form": form, "action": "add", "dialer_setting_msg": user_dialer_setting_msg(request.user)}
return render_to_response(template, data, context_instance=RequestContext(request))
def voipapp_add(request):
"""Add new VoIP App for logged in user
**Attributes**:
* ``form`` - VoipAppForm
* ``template`` - frontend/voipapp/change.html
**Logic Description**:
* Add new voip app which will belong to logged in user
via VoipAppForm form & get redirect to voipapp list
"""
form = VoipAppForm()
if request.method == 'POST':
form = VoipAppForm(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.user = User.objects.get(username=request.user)
obj.save()
request.session["msg"] = _('"%(name)s" is added successfully.') %\
request.POST
return HttpResponseRedirect('/voipapp/')
template = 'frontend/voipapp/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'add',
'notice_count': notice_count(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def tier_list(request):
"""Tier list for the logged in Manager
**Attributes**:
* ``template`` - frontend/tier/list.html
**Logic Description**:
* List all tier which belong to the logged in manager.
"""
sort_col_field_list = ['agent', 'queue', 'level', 'position', 'updated_date']
default_sort_field = 'id'
pagination_data = get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
tier_list = Tier.objects\
.filter(manager=request.user).order_by(sort_order)
template = 'frontend/tier/list.html'
data = {
'msg': request.session.get('msg'),
'tier_list': tier_list,
'total_tier': tier_list.count(),
'PAGE_SIZE': PAGE_SIZE,
'TIER_COLUMN_NAME': TIER_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
request.session['msg'] = ''
request.session['error_msg'] = ''
return render_to_response(template, data,
context_instance=RequestContext(request))
def dnc_contact_export_view(request):
"""Export CSV file of dnc contact form view
**Attributes**:
* ``form`` - DNCContact_fileExport
* ``template`` - frontend/dnc_contact/export_dnc_contact.html
**Logic Description**:
* DNC contacts export form will be redirected to ``/dnc_contact/export/`` view
with format & dnc_list_id parameters
"""
form = DNCContact_fileExport(request.user, initial={'export_to': EXPORT_CHOICE.CSV})
if request.method == 'POST':
dnc_list_id = request.POST['dnc_list']
export_to = request.POST['export_to']
return HttpResponseRedirect('/dnc_contact/export/?format=' + export_to + '&dnc_list_id=' + dnc_list_id)
template = 'frontend/dnc_contact/export_dnc_contact.html'
data = {
'module': current_view(request),
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def dnc_list(request):
"""DNC list for the logged in user
**Attributes**:
* ``template`` - frontend/dnc_list/list.html
**Logic Description**:
* List all dnc which belong to the logged in user.
"""
sort_col_field_list = ['id', 'name', 'updated_date']
default_sort_field = 'id'
pagination_data = get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
dnc_list = DNC.objects.filter(user=request.user).order_by(sort_order)
template = 'frontend/dnc_list/list.html'
data = {
'msg': request.session.get('msg'),
'dnc_list': dnc_list,
'total_dnc': dnc_list.count(),
'PAGE_SIZE': PAGE_SIZE,
'DNC_COLUMN_NAME': DNC_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
request.session['msg'] = ''
request.session['error_msg'] = ''
return render_to_response(template, data,
context_instance=RequestContext(request))
def dnc_add(request):
"""Add new DNC for the logged in user
**Attributes**:
* ``form`` - DNCForm
* ``template`` - frontend/dnc_list/change.html
**Logic Description**:
* Add a new DNC which will belong to the logged in user
via the DNCForm & get redirected to the dnc list
"""
form = DNCForm()
if request.method == 'POST':
form = DNCForm(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.user = request.user
obj.save()
request.session["msg"] = _('"%(name)s" added.') %\
{'name': request.POST['name']}
return HttpResponseRedirect('/dnc_list/')
template = 'frontend/dnc_list/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'add',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def dnc_contact_export_view(request):
"""Export CSV file of dnc contact form view
**Attributes**:
* ``form`` - DNCContact_fileExport
* ``template`` - frontend/dnc_contact/export_dnc_contact.html
**Logic Description**:
* DNC contacts export form will be redirected to ``/dnc_contact/export/`` view
with format & dnc_list_id parameters
"""
form = DNCContact_fileExport(request.user,
initial={'export_to': EXPORT_CHOICE.CSV})
if request.method == 'POST':
dnc_list_id = request.POST['dnc_list']
export_to = request.POST['export_to']
return HttpResponseRedirect('/dnc_contact/export/?format=' +
export_to + '&dnc_list_id=' + dnc_list_id)
template = 'frontend/dnc_contact/export_dnc_contact.html'
data = {
'module': current_view(request),
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def dnc_add(request):
"""Add new DNC for the logged in user
**Attributes**:
* ``form`` - DNCForm
* ``template`` - frontend/dnc_list/change.html
**Logic Description**:
* Add a new DNC which will belong to the logged in user
via the DNCForm & get redirected to the dnc list
"""
form = DNCForm()
if request.method == 'POST':
form = DNCForm(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.user = request.user
obj.save()
request.session["msg"] = _('"%(name)s" added.') %\
{'name': request.POST['name']}
return HttpResponseRedirect('/dnc_list/')
template = 'frontend/dnc_list/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'add',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def voiceapp_add(request):
"""Add new Voice App for logged in user
**Attributes**:
* ``form`` - VoiceAppForm
* ``template`` - frontend/voiceapp/change.html
**Logic Description**:
* Add new voice app which will belong to logged in user
via VoiceAppForm form & get redirect to voiceapp list
"""
form = VoiceAppForm()
if request.method == 'POST':
form = VoiceAppForm(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.user = User.objects.get(username=request.user)
obj.save()
request.session["msg"] = _('"%(name)s" is added.') %\
request.POST
return HttpResponseRedirect('/voiceapp/')
template = 'frontend/voiceapp/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'add',
'notice_count': notice_count(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def queue_add(request):
"""Add new queue for the logged in manager
**Attributes**:
* ``form`` - QueueFrontEndForm
* ``template`` - frontend/queue/change.html
**Logic Description**:
* Add a new queue which will belong to the logged in manager
via the UserCreationForm & get redirected to the queue list
"""
form = QueueFrontEndForm()
if request.method == 'POST':
form = QueueFrontEndForm(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.manager = Manager.objects.get(username=request.user)
obj.save()
request.session["msg"] = _('"%(name)s" queue is added.') %\
{'name': obj.name}
return HttpResponseRedirect(redirect_url_to_queue_list)
template = 'frontend/queue/change.html'
data = {
'form': form,
'action': 'add',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def phonebook_change(request, object_id):
"""Update/Delete Phonebook for the logged in user
**Attributes**:
* ``object_id`` - Selected phonebook object
* ``form`` - PhonebookForm
* ``template`` - frontend/phonebook/change.html
**Logic Description**:
* Update/delete selected phonebook from the phonebook list
via PhonebookForm & get redirected to phonebook list
"""
phonebook = get_object_or_404(Phonebook, pk=object_id, user=request.user)
form = PhonebookForm(instance=phonebook)
if request.method == "POST":
if request.POST.get("delete"):
return HttpResponseRedirect("/phonebook/del/%s/" % object_id)
else:
form = PhonebookForm(request.POST, instance=phonebook)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" is updated.') % {"name": request.POST["name"]}
return HttpResponseRedirect("/phonebook/")
template = "frontend/phonebook/change.html"
data = {"form": form, "action": "update", "dialer_setting_msg": user_dialer_setting_msg(request.user)}
return render_to_response(template, data, context_instance=RequestContext(request))
def newfies_common_template_variable(request):
"""Return common_template_variable"""
newfies_page_size = settings.PAGE_SIZE if settings.PAGE_SIZE else 10
return {
'newfies_page_size': newfies_page_size,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'AUDIO_DEBUG': settings.AUDIO_DEBUG,
'AMD': settings.AMD
}
def sms_campaign_add(request):
"""Add a new sms campaign for the logged in user
**Attributes**:
* ``form`` - SMSCampaignForm
* ``template`` - frontend/sms_campaign/change.html
**Logic Description**:
* Before adding a sms campaign, check dialer setting limit if
applicable to the user.
* Add the new sms campaign which will belong to the logged in user
via SMSCampaignForm & get redirected to sms campaign list
"""
# If dialer setting is not attached with user, redirect to sms campaign list
if not user_dialer_setting(request.user):
request.session['error_msg'] = \
_("in order to add a sms campaign, you need to have your \
settings configured properly, please contact the admin.")
return HttpResponseRedirect(redirect_url_to_smscampaign_list)
# Check dialer setting limit
if request.user and request.method != 'POST':
# check Max Number of running campaign
if check_sms_dialer_setting(request, check_for="smscampaign"):
msg = _("you have too many sms campaigns. Max allowed %(limit)s")\
% {'limit': dialer_setting_limit(request, limit_for="smscampaign")}
request.session['msg'] = msg
# sms campaign limit reached
frontend_send_notification(
request, SMS_NOTIFICATION_NAME.sms_campaign_limit_reached)
return HttpResponseRedirect(redirect_url_to_smscampaign_list)
form = SMSCampaignForm(request.user)
# Add sms campaign
if request.method == 'POST':
form = SMSCampaignForm(request.user, request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.user = User.objects.get(username=request.user)
obj.save()
form.save_m2m()
request.session["msg"] = _('"%(name)s" is added.') %\
{'name': request.POST['name']}
return HttpResponseRedirect(redirect_url_to_smscampaign_list)
template = 'frontend/sms_campaign/change.html'
data = {
'form': form,
'action': 'add',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(
template, data, context_instance=RequestContext(request))
def contact_add(request):
"""Add a new contact into the selected phonebook for the logged in user
**Attributes**:
* ``form`` - ContactForm
* ``template`` - frontend/contact/change.html
**Logic Description**:
* Before adding a contact, check dialer setting limit if applicable
to the user.
* Add new contact belonging to the logged in user
via ContactForm & get redirected to the contact list
"""
# Check dialer setting limit
if request.user and request.method == 'POST':
# check Max Number of subscriber per campaign
if check_dialer_setting(request, check_for="contact"):
request.session['msg'] = \
_("you have too many contacts per campaign. you are allowed a maximum of %(limit)s") % \
{'limit': dialer_setting_limit(request, limit_for="contact")}
# contact limit reached
frontend_send_notification(request,
NOTIFICATION_NAME.contact_limit_reached)
return HttpResponseRedirect("/contact/")
form = ContactForm(request.user)
error_msg = False
# Add contact
if request.method == 'POST':
form = ContactForm(request.user, request.POST)
if form.is_valid():
form.save()
request.session["msg"] = _(
'"%s" is added.') % request.POST['contact']
return HttpResponseRedirect('/contact/')
else:
if len(request.POST['contact']) > 0:
error_msg = _(
'"%s" cannot be added.') % request.POST['contact']
phonebook_count = Phonebook.objects.filter(user=request.user).count()
template = 'frontend/contact/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'add',
'error_msg': error_msg,
'phonebook_count': phonebook_count,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def contact_add(request):
"""Add a new contact into the selected phonebook for the logged in user
**Attributes**:
* ``form`` - ContactForm
* ``template`` - frontend/contact/change.html
**Logic Description**:
* Before adding a contact, check dialer setting limit if applicable
to the user.
* Add new contact belonging to the logged in user
via ContactForm & get redirected to the contact list
"""
# Check dialer setting limit
if request.user and request.method == 'POST':
# check Max Number of subscriber per campaign
if check_dialer_setting(request, check_for="contact"):
request.session['msg'] = \
_("you have too many contacts per campaign. you are allowed a maximum of %(limit)s") % \
{'limit': dialer_setting_limit(request, limit_for="contact")}
# contact limit reached
frontend_send_notification(request, NOTIFICATION_NAME.contact_limit_reached)
return HttpResponseRedirect("/contact/")
form = ContactForm(request.user)
error_msg = False
# Add contact
if request.method == 'POST':
form = ContactForm(request.user, request.POST)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" added.') %\
{'name': request.POST['contact']}
return HttpResponseRedirect('/contact/')
else:
if len(request.POST['contact']) > 0:
error_msg = _('"%(name)s" cannot be added.') %\
{'name': request.POST['contact']}
phonebook_count = Phonebook.objects.filter(user=request.user).count()
template = 'frontend/contact/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'add',
'error_msg': error_msg,
'phonebook_count': phonebook_count,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def agent_change(request, object_id):
"""Update/Delete Agent for the logged in manager
**Attributes**:
* ``object_id`` - Selected agent object
* ``form`` - AgentChangeDetailExtendForm, AgentNameChangeForm
* ``template`` - frontend/agent/change.html
**Logic Description**:
* Update/delete selected agent from the agent list
via AgentChangeDetailExtendForm & get redirected to agent list
"""
agent_profile = get_object_or_404(AgentProfile, pk=object_id, manager_id=request.user.id)
agent_userdetail = get_object_or_404(Agent, pk=agent_profile.user_id)
form = AgentChangeDetailExtendForm(request.user, instance=agent_profile)
agent_username_form = AgentNameChangeForm(initial={
'username': agent_userdetail.username,
'password': agent_userdetail.password})
if request.method == 'POST':
if request.POST.get('delete'):
agent_del(request, object_id)
return HttpResponseRedirect(redirect_url_to_agent_list)
else:
form = AgentChangeDetailExtendForm(request.user, request.POST,
instance=agent_profile)
agent_username_form = AgentNameChangeForm(
request.POST, initial={'password': agent_userdetail.password},
instance=agent_userdetail)
# Save agent username
if agent_username_form.is_valid():
agent_username_form.save()
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" is updated.') \
% {'name': agent_profile.user}
return HttpResponseRedirect(redirect_url_to_agent_list)
template = 'frontend/agent/change.html'
data = {
'form': form,
'agent_username_form': agent_username_form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def calendar_user_change(request, object_id):
"""Update/Delete calendar user for the logged in manager
**Attributes**:
* ``object_id`` - Selected calendar_user object
* ``form`` - CalendarUserChangeDetailExtendForm, CalendarUserNameChangeForm
* ``template`` - frontend/appointment/calendar_user/change.html
**Logic Description**:
* Update/delete selected calendar user from the calendar_user list
via CalendarUserChangeDetailExtendForm & get redirected to calendar_user list
"""
calendar_user_profile = get_object_or_404(CalendarUserProfile, pk=object_id, manager_id=request.user.id)
calendar_user_userdetail = get_object_or_404(CalendarUser, pk=calendar_user_profile.user_id)
form = CalendarUserChangeDetailExtendForm(request.user, instance=calendar_user_profile)
calendar_user_username_form = CalendarUserNameChangeForm(
initial={'username': calendar_user_userdetail.username,
'password': calendar_user_userdetail.password})
if request.method == 'POST':
if request.POST.get('delete'):
calendar_user_del(request, object_id)
return HttpResponseRedirect(redirect_url_to_calendar_user_list)
else:
form = CalendarUserChangeDetailExtendForm(request.user, request.POST, instance=calendar_user_profile)
calendar_user_username_form = CalendarUserNameChangeForm(request.POST,
initial={'password': calendar_user_userdetail.password},
instance=calendar_user_userdetail)
# Save calendar_user username
if calendar_user_username_form.is_valid():
calendar_user_username_form.save()
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" is updated.') \
% {'name': calendar_user_profile.user}
return HttpResponseRedirect(redirect_url_to_calendar_user_list)
template = 'frontend/appointment/calendar_user/change.html'
data = {
'form': form,
'calendar_user_username_form': calendar_user_username_form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def login_view(request):
"""Check User credentials
**Attributes**:
* ``form`` - LoginForm
* ``template`` - frontend/index.html
**Logic Description**:
* Submitted user credentials need to be checked. If it is not valid
then the system will redirect to the login page.
* If submitted user credentials are valid then system will redirect to
the dashboard.
"""
template = 'frontend/index.html'
errorlogin = ''
if request.method == 'POST':
loginform = LoginForm(request.POST)
if loginform.is_valid():
cd = loginform.cleaned_data
user = authenticate(username=cd['user'],
password=cd['password'])
if user is not None:
if user.is_active:
login(request, user)
request.session['has_notified'] = False
# Redirect to a success page (dashboard).
return HttpResponseRedirect('/dashboard/')
else:
# Return a 'disabled account' error message
errorlogin = _('disabled account')
else:
# Return an 'invalid login' error message.
errorlogin = _('invalid login.')
else:
# Return an 'Valid User Credentials' error message.
errorlogin = _('enter valid user credentials.')
else:
loginform = LoginForm()
data = {
'module': current_view(request),
'loginform': loginform,
'errorlogin': errorlogin,
'is_authenticated': request.user.is_authenticated(),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def login_view(request):
"""Check User credentials
**Attributes**:
* ``form`` - LoginForm
* ``template`` - frontend/index.html
**Logic Description**:
* Submitted user credentials need to be checked. If it is not valid
then the system will redirect to the login page.
* If submitted user credentials are valid then system will redirect to
the dashboard.
"""
template = 'frontend/index.html'
errorlogin = ''
if request.method == 'POST':
loginform = LoginForm(request.POST)
if loginform.is_valid():
cd = loginform.cleaned_data
user = authenticate(username=cd['user'], password=cd['password'])
if user is not None:
if user.is_active:
login(request, user)
request.session['has_notified'] = False
# Redirect to a success page (dashboard).
return HttpResponseRedirect('/dashboard/')
else:
# Return a 'disabled account' error message
errorlogin = _('disabled account')
else:
# Return an 'invalid login' error message.
errorlogin = _('invalid login.')
else:
# Return an 'Valid User Credentials' error message.
errorlogin = _('enter valid user credentials.')
else:
loginform = LoginForm()
data = {
'module': current_view(request),
'loginform': loginform,
'errorlogin': errorlogin,
'is_authenticated': request.user.is_authenticated(),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def contact_add(request):
"""Add a new contact into the selected phonebook for the logged in user
**Attributes**:
* ``form`` - ContactForm
* ``template`` - frontend/contact/change.html
**Logic Description**:
* Before adding a contact, check dialer setting limit if applicable
to the user.
* Add new contact belonging to the logged in user
via ContactForm & get redirected to the contact list
"""
# Check dialer setting limit
if request.user and request.method == "POST":
if check_dialer_setting(request, check_for="contact"):
request.session["msg"] = _("you have too many contacts. you are allowed a maximum of %(limit)s") % {
"limit": dialer_setting_limit(request, limit_for="contact")
}
# contact limit reached
frontend_send_notification(request, NOTIFICATION_NAME.contact_limit_reached)
return HttpResponseRedirect("/contact/")
form = ContactForm(request.user)
error_msg = False
# Add contact
if request.method == "POST":
form = ContactForm(request.user, request.POST)
if form.is_valid():
form.save()
request.session["msg"] = _('"%s" is added.') % request.POST["contact"]
return HttpResponseRedirect("/contact/")
else:
if len(request.POST["contact"]) > 0:
error_msg = _('"%s" cannot be added.') % request.POST["contact"]
phonebook_count = Phonebook.objects.filter(user=request.user).count()
template = "frontend/contact/change.html"
data = {
"form": form,
"action": "add",
"error_msg": error_msg,
"phonebook_count": phonebook_count,
"dialer_setting_msg": user_dialer_setting_msg(request.user),
}
return render_to_response(template, data, context_instance=RequestContext(request))
def campaign_list(request):
"""List all campaigns for the logged in user
**Attributes**:
* ``template`` - frontend/campaign/list.html
**Logic Description**:
* List all campaigns belonging to the logged in user
"""
request.session['pagination_path'] = request.META[
'PATH_INFO'] + '?' + request.META['QUERY_STRING']
sort_col_field_list = [
'id', 'name', 'startingdate', 'status', 'totalcontact'
]
default_sort_field = 'id'
pagination_data =\
get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
campaign_list = Campaign.objects.filter(
user=request.user).order_by(sort_order)
template = 'frontend/campaign/list.html'
data = {
'module': current_view(request),
'campaign_list': campaign_list,
'total_campaign': campaign_list.count(),
'PAGE_SIZE': PAGE_SIZE,
'CAMPAIGN_COLUMN_NAME': CAMPAIGN_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'msg': request.session.get('msg'),
'error_msg': request.session.get('error_msg'),
'info_msg': request.session.get('info_msg'),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
request.session['msg'] = ''
request.session['error_msg'] = ''
request.session['info_msg'] = ''
return render_to_response(template,
data,
context_instance=RequestContext(request))
def sms_campaign_change(request, object_id):
"""Update/Delete sms campaign for the logged in user
**Attributes**:
* ``object_id`` - Selected campaign object
* ``form`` - SMSCampaignForm
* ``template`` - frontend/sms_campaign/change.html
**Logic Description**:
* Update/delete selected sms campaign from the sms campaign list
via SMSCampaignForm & get redirected to the sms campaign list
"""
# If dialer setting is not attached with user, redirect to sms campaign list
if not user_dialer_setting(request.user):
return HttpResponseRedirect(redirect_url_to_smscampaign_list)
sms_campaign = get_object_or_404(SMSCampaign, pk=object_id, user=request.user)
form = SMSCampaignForm(request.user, instance=sms_campaign)
if request.method == 'POST':
# Delete sms campaign
if request.POST.get('delete'):
sms_campaign_del(request, object_id)
return HttpResponseRedirect(redirect_url_to_smscampaign_list)
else:
# Update sms campaign
form = SMSCampaignForm(
request.user, request.POST, instance=sms_campaign)
if form.is_valid():
obj = form.save()
obj.save()
request.session["msg"] = _('"%(name)s" is updated.') \
% {'name': request.POST['name']}
return HttpResponseRedirect(redirect_url_to_smscampaign_list)
template = 'frontend/sms_campaign/change.html'
data = {
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(
template, data, context_instance=RequestContext(request))
def dnc_contact_change(request, object_id):
"""Update/Delete dnc contact for the logged in user
**Attributes**:
* ``object_id`` - Selected dnc contact object
* ``form`` - DNCContactForm
* ``template`` - frontend/dnc_contact/change.html
**Logic Description**:
* Update/delete selected dnc contact from the dnc contact list
via DNCContactForm & get redirected to the dnc contact list
"""
dnc_contact = get_object_or_404(DNCContact,
pk=object_id,
dnc__user=request.user)
form = DNCContactForm(request.user, instance=dnc_contact)
if request.method == 'POST':
# Delete dnc contact
if request.POST.get('delete'):
return HttpResponseRedirect('/dnc_contact/del/%s/' % object_id)
else:
# Update dnc contact
form = DNCContactForm(request.user,
request.POST,
instance=dnc_contact)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" is updated.') \
% {'name': request.POST['phone_number']}
return HttpResponseRedirect('/dnc_contact/')
template = 'frontend/dnc_contact/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def index(request):
"""Index view of the Customer Interface
**Attributes**:
* ``form`` - LoginForm
* ``template`` - frontend/index.html
"""
template = 'frontend/index.html'
errorlogin = ''
data = {
'user': request.user,
'loginform': LoginForm(),
'errorlogin': errorlogin,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def contact_change(request, object_id):
"""Update/Delete contact for the logged in user
**Attributes**:
* ``object_id`` - Selected contact object
* ``form`` - ContactForm
* ``template`` - frontend/contact/change.html
**Logic Description**:
* Update/delete selected contact from the contact list
via ContactForm & get redirected to the contact list
"""
contact = get_object_or_404(
Contact, pk=object_id, phonebook__user=request.user)
form = ContactForm(request.user, instance=contact)
if request.method == 'POST':
# Delete contact
if request.POST.get('delete'):
contact_del(request, object_id)
return HttpResponseRedirect('/contact/')
else:
# Update contact
form = ContactForm(request.user, request.POST, instance=contact)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" is updated.') \
% {'name': request.POST['contact']}
return HttpResponseRedirect('/contact/')
template = 'frontend/contact/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def index(request):
"""Index view of the Customer Interface
**Attributes**:
* ``form`` - LoginForm
* ``template`` - frontend/index.html
"""
template = 'frontend/index.html'
errorlogin = ''
data = {
'module': current_view(request),
'user': request.user,
'loginform': LoginForm(),
'errorlogin': errorlogin,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def voiceapp_list(request):
"""Voce App list for logged in user
**Attributes**:
* ``template`` - frontend/voiceapp/list.html
**Logic Description**:
* List all voice app which are belong to logged in user
"""
template = 'frontend/voiceapp/list.html'
data = {
'module': current_view(request),
'msg': request.session.get('msg'),
'notice_count': notice_count(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
request.session['msg'] = ''
return render_to_response(template, data,
context_instance=RequestContext(request))
def voipapp_list(request):
"""VoIP App list for logged in user
**Attributes**:
* ``template`` - frontend/voipapp/list.html
**Logic Description**:
* List all voip app which are belong to logged in user
"""
template = 'frontend/voipapp/list.html'
data = {
'module': current_view(request),
'msg': request.session.get('msg'),
'notice_count': notice_count(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
request.session['msg'] = ''
return render_to_response(template, data,
context_instance=RequestContext(request))
def tier_change(request, object_id):
"""Update/Delete tier for the logged in manager
**Attributes**:
* ``object_id`` - Selected tier object
* ``form`` - TierFrontEndForm
* ``template`` - frontend/tier/change.html
**Logic Description**:
* Update/delete selected tier from the tier list
via TierFrontEndForm & get redirected to the tier list
"""
tier = get_object_or_404(
Tier, pk=object_id, manager=request.user)
form = TierFrontEndForm(request.user.id, instance=tier)
if request.method == 'POST':
# Delete tier
if request.POST.get('delete'):
tier_del(request, object_id)
return HttpResponseRedirect(redirect_url_to_tier_list)
else:
# Update tier
form = TierFrontEndForm(request.user.id, request.POST, instance=tier)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(id)s" tier is updated.') \
% {'id': tier.id}
return HttpResponseRedirect(redirect_url_to_tier_list)
template = 'frontend/tier/change.html'
data = {
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def dnc_contact_add(request):
"""Add a new dnc contact into the selected dnc for the logged in user
**Attributes**:
* ``form`` - DNCContactForm
* ``template`` - frontend/dnc_contact/change.html
**Logic Description**:
* Add new dnc contact belonging to the logged in user
via DNCContactForm & get redirected to the contact list
"""
form = DNCContactForm(request.user)
error_msg = False
# Add dnc contact
if request.method == 'POST':
form = DNCContactForm(request.user, request.POST)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" added.') %\
{'name': request.POST['phone_number']}
return HttpResponseRedirect('/dnc_contact/')
else:
if len(request.POST['phone_number']) > 0:
error_msg = _('"%(name)s" cannot be added.') %\
{'name': request.POST['phone_number']}
#FIXME: dnc_count not used
dnc_count = DNC.objects.filter(user=request.user).count()
template = 'frontend/dnc_contact/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'add',
'error_msg': error_msg,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def dnc_contact_change(request, object_id):
"""Update/Delete dnc contact for the logged in user
**Attributes**:
* ``object_id`` - Selected dnc contact object
* ``form`` - DNCContactForm
* ``template`` - frontend/dnc_contact/change.html
**Logic Description**:
* Update/delete selected dnc contact from the dnc contact list
via DNCContactForm & get redirected to the dnc contact list
"""
dnc_contact = get_object_or_404(
DNCContact, pk=object_id, dnc__user=request.user)
form = DNCContactForm(request.user, instance=dnc_contact)
if request.method == 'POST':
# Delete dnc contact
if request.POST.get('delete'):
dnc_contact_del(request, object_id)
return HttpResponseRedirect(dnc_contact_redirect_url)
else:
# Update dnc contact
form = DNCContactForm(request.user, request.POST, instance=dnc_contact)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" is updated.') \
% {'name': request.POST['phone_number']}
return HttpResponseRedirect(dnc_contact_redirect_url)
template = 'frontend/dnc_contact/change.html'
data = {
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def queue_change(request, object_id):
"""Update/Delete queue for the logged in manager
**Attributes**:
* ``object_id`` - Selected queue object
* ``form`` - QueueFrontEndForm
* ``template`` - frontend/queue/change.html
**Logic Description**:
* Update/delete selected queue from the queue list
via QueueFrontEndForm & get redirected to the queue list
"""
queue = get_object_or_404(
Queue, pk=object_id, manager=request.user)
form = QueueFrontEndForm(instance=queue)
if request.method == 'POST':
# Delete queue
if request.POST.get('delete'):
queue_del(request, object_id)
return HttpResponseRedirect(redirect_url_to_queue_list)
else:
# Update queue
form = QueueFrontEndForm(request.POST, instance=queue)
if form.is_valid():
obj = form.save()
request.session["msg"] = _('"%(name)s" is updated.') \
% {'name': obj.name}
return HttpResponseRedirect(redirect_url_to_queue_list)
template = 'frontend/queue/change.html'
data = {
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def campaign_list(request):
"""List all campaigns for the logged in user
**Attributes**:
* ``template`` - frontend/campaign/list.html
**Logic Description**:
* List all campaigns belonging to the logged in user
"""
request.session['pagination_path'] = request.META['PATH_INFO'] + '?' + request.META['QUERY_STRING']
sort_col_field_list = ['id', 'name', 'startingdate', 'status', 'totalcontact']
default_sort_field = 'id'
pagination_data =\
get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
campaign_list = Campaign.objects.filter(user=request.user).order_by(sort_order)
template = 'frontend/campaign/list.html'
data = {
'module': current_view(request),
'campaign_list': campaign_list,
'total_campaign': campaign_list.count(),
'PAGE_SIZE': PAGE_SIZE,
'CAMPAIGN_COLUMN_NAME': CAMPAIGN_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'msg': request.session.get('msg'),
'error_msg': request.session.get('error_msg'),
'info_msg': request.session.get('info_msg'),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
request.session['msg'] = ''
request.session['error_msg'] = ''
request.session['info_msg'] = ''
return render_to_response(template, data,
context_instance=RequestContext(request))
def voiceapp_change(request, object_id):
"""Update/Delete Voice app for logged in user
**Attributes**:
* ``object_id`` - Selected voiceapp object
* ``form`` - VoiceAppForm
* ``template`` - frontend/voiceapp/change.html
**Logic Description**:
* Update/delete selected voiceapp from voiceapp list
via VoiceAppForm form & get redirect to voice list
"""
voiceapp = VoiceApp.objects.get(pk=object_id)
form = VoiceAppForm(instance=voiceapp)
if request.method == 'POST':
if request.POST.get('delete'):
voiceapp_del(request, object_id)
return HttpResponseRedirect('/voiceapp/')
else:
form = VoiceAppForm(request.POST, instance=voiceapp)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" is updated.' \
% {'name': request.POST['name']})
return HttpResponseRedirect('/voiceapp/')
template = 'frontend/voiceapp/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'update',
'notice_count': notice_count(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def phonebook_list(request):
"""Phonebook list for the logged in user
**Attributes**:
* ``template`` - frontend/phonebook/list.html
**Logic Description**:
* List all phonebooks which belong to the logged in user.
"""
sort_col_field_list = ['id', 'name', 'updated_date']
default_sort_field = 'id'
pagination_data = \
get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
phonebook_list = Phonebook.objects\
.annotate(contact_count=Count('contact'))\
.filter(user=request.user).order_by(sort_order)
template = 'frontend/phonebook/list.html'
data = {
'module': current_view(request),
'msg': request.session.get('msg'),
'phonebook_list': phonebook_list,
'total_phonebook': phonebook_list.count(),
'PAGE_SIZE': PAGE_SIZE,
'PHONEBOOK_COLUMN_NAME': PHONEBOOK_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
request.session['msg'] = ''
request.session['error_msg'] = ''
return render_to_response(template,
data,
context_instance=RequestContext(request))
def calendar_setting_change(request, object_id):
"""Update/Delete calendar_setting for the logged in user
**Attributes**:
* ``object_id`` - Selected calendar_setting object
* ``form`` - CalendarSettingForm
* ``template`` - frontend/appointment/calendar_setting/change.html
**Logic Description**:
* Update/delete selected calendar_setting from the calendar_setting list
via CalendarSettingForm & get redirected to the calendar_setting list
"""
calendar_setting = get_object_or_404(CalendarSetting, pk=object_id)
form = CalendarSettingForm(request.user, instance=calendar_setting)
if request.method == 'POST':
# Delete calendar_setting
if request.POST.get('delete'):
calendar_setting_del(request, object_id)
return HttpResponseRedirect(redirect_url_to_calendar_setting_list)
else:
# Update calendar_setting
form = CalendarSettingForm(request.user, request.POST, instance=calendar_setting)
if form.is_valid():
obj = form.save()
request.session["msg"] = _('"%s" is updated.') % obj
return HttpResponseRedirect(redirect_url_to_calendar_setting_list)
template = 'frontend/appointment/calendar_setting/change.html'
data = {
'form': form,
'action': 'update',
'AMD': settings.AMD,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def dnc_contact_add(request):
"""Add a new dnc contact into the selected dnc for the logged in user
**Attributes**:
* ``form`` - DNCContactForm
* ``template`` - frontend/dnc_contact/change.html
**Logic Description**:
* Add new dnc contact belonging to the logged in user
via DNCContactForm & get redirected to the contact list
"""
form = DNCContactForm(request.user)
error_msg = False
# Add dnc contact
if request.method == 'POST':
form = DNCContactForm(request.user, request.POST)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" added.') %\
{'name': request.POST['phone_number']}
return HttpResponseRedirect('/dnc_contact/')
else:
if len(request.POST['phone_number']) > 0:
error_msg = _('"%(name)s" cannot be added.') %\
{'name': request.POST['phone_number']}
template = 'frontend/dnc_contact/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'add',
'error_msg': error_msg,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def agent_add(request):
"""Add new Agent for the logged in manager
**Attributes**:
* ``form`` - AgentCreationForm
* ``template`` - frontend/agent/change.html
**Logic Description**:
* Add a new agent which will belong to the logged in manager
via the AgentCreationForm & get redirected to the agent list
"""
form = AgentCreationForm()
if request.method == 'POST':
form = AgentCreationForm(request.POST)
if form.is_valid():
new_agent = form.save()
new_agent_profile = AgentProfile.objects.create(
user=new_agent,
manager=Manager.objects.get(username=request.user),
is_agent=True
)
permission = Permission.objects.get(codename='view_agent_dashboard')
new_agent.user_permissions.add(permission)
request.session["msg"] = _('"%(name)s" added as agent.') % \
{'name': request.POST['username']}
return HttpResponseRedirect(redirect_url_to_agent_list + '%s/' % str(new_agent_profile.id))
template = 'frontend/agent/change.html'
data = {
'form': form,
'action': 'add',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def alarm_list(request):
"""Alarm list for the logged in user
**Attributes**:
* ``template`` - frontend/appointment/alarm/list.html
**Logic Description**:
* List all alarms which belong to the logged in user.
"""
sort_col_field_list = ['id', 'alarm_phonenumber', 'alarm_email', 'daily_start',
'daily_stop', 'method', 'survey', 'event',
'date_start_notice', 'status']
default_sort_field = 'id'
pagination_data = get_pagination_vars(
request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
calendar_user_id_list = get_calendar_user_id_list(request.user)
alarm_list = Alarm.objects.filter(
event__calendar__user_id__in=calendar_user_id_list).order_by(sort_order)
template = 'frontend/appointment/alarm/list.html'
data = {
'msg': request.session.get('msg'),
'alarm_list': alarm_list,
'total_alarm': alarm_list.count(),
'PAGE_SIZE': PAGE_SIZE,
'ALARM_COLUMN_NAME': ALARM_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
request.session['msg'] = ''
request.session['error_msg'] = ''
return render_to_response(template, data,
context_instance=RequestContext(request))
def phonebook_change(request, object_id):
"""Update/Delete Phonebook for the logged in user
**Attributes**:
* ``object_id`` - Selected phonebook object
* ``form`` - PhonebookForm
* ``template`` - frontend/phonebook/change.html
**Logic Description**:
* Update/delete selected phonebook from the phonebook list
via PhonebookForm & get redirected to phonebook list
"""
phonebook = get_object_or_404(Phonebook, pk=object_id, user=request.user)
form = PhonebookForm(instance=phonebook)
if request.method == 'POST':
if request.POST.get('delete'):
return HttpResponseRedirect('/phonebook/del/%s/' % object_id)
else:
form = PhonebookForm(request.POST, instance=phonebook)
if form.is_valid():
form.save()
request.session["msg"] = _('"%(name)s" is updated.') \
% {'name': request.POST['name']}
return HttpResponseRedirect('/phonebook/')
template = 'frontend/phonebook/change.html'
data = {
'module': current_view(request),
'form': form,
'action': 'update',
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def contact_list(request):
"""Contact list for the logged in user
**Attributes**:
* ``template`` - frontend/contact/list.html
* ``form`` - ContactSearchForm
**Logic Description**:
* List all contacts from phonebooks belonging to the logged in user
"""
sort_col_field_list = [
'id', 'phonebook', 'contact', 'status', 'first_name', 'last_name',
'updated_date'
]
default_sort_field = 'id'
pagination_data =\
get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
start_page = pagination_data['start_page']
end_page = pagination_data['end_page']
form = ContactSearchForm(request.user)
phonebook_id_list = Phonebook.objects.values_list('id', flat=True)\
.filter(user=request.user)
search_tag = 1
contact_no = ''
contact_name = ''
phonebook = ''
contact_status = STATUS_CHOICE.ALL
if request.method == 'POST':
form = ContactSearchForm(request.user, request.POST)
if form.is_valid():
field_list = [
'contact_no', 'contact_name', 'contact_status', 'phonebook'
]
unset_session_var(request, field_list)
contact_no = getvar(request, 'contact_no', setsession=True)
contact_name = getvar(request, 'contact_name', setsession=True)
contact_status = getvar(request, 'contact_status', setsession=True)
phonebook = getvar(request, 'phonebook', setsession=True)
post_var_with_page = 0
try:
if request.GET.get('page') or request.GET.get('sort_by'):
post_var_with_page = 1
contact_no = request.session.get('session_contact_no')
contact_name = request.session.get('session_contact_name')
contact_status = request.session.get('session_contact_status')
phonebook = request.session.get('session_phonebook')
form = ContactSearchForm(request.user,
initial={
'contact_no': contact_no,
'contact_name': contact_name,
'status': contact_status,
'phonebook': phonebook
})
else:
post_var_with_page = 1
if request.method == 'GET':
post_var_with_page = 0
except:
pass
if post_var_with_page == 0:
# default
# unset session var
field_list = [
'contact_no', 'contact_name', 'contact_status', 'phonebook'
]
unset_session_var(request, field_list)
kwargs = {}
if phonebook and phonebook != '0':
kwargs['phonebook'] = phonebook
if contact_status and int(contact_status) != STATUS_CHOICE.ALL:
kwargs['status'] = contact_status
contact_no_type = '1'
contact_no = type_field_chk(contact_no, contact_no_type, 'contact')
for i in contact_no:
kwargs[i] = contact_no[i]
contact_list = []
all_contact_list = []
contact_count = 0
if phonebook_id_list:
contact_list = Contact.objects.values('id', 'phonebook__name', 'contact',
'last_name', 'first_name', 'status', 'updated_date')\
.filter(phonebook__in=phonebook_id_list)
if kwargs:
contact_list = contact_list.filter(**kwargs)
if contact_name:
# Search on contact name
q = (Q(last_name__icontains=contact_name)
| Q(first_name__icontains=contact_name))
if q:
contact_list = contact_list.filter(q)
all_contact_list = contact_list.order_by(sort_order)
contact_list = all_contact_list[start_page:end_page]
contact_count = all_contact_list.count()
template = 'frontend/contact/list.html'
data = {
'module': current_view(request),
'contact_list': contact_list,
'all_contact_list': all_contact_list,
'total_contacts': contact_count,
'PAGE_SIZE': PAGE_SIZE,
'CONTACT_COLUMN_NAME': CONTACT_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'msg': request.session.get('msg'),
'error_msg': request.session.get('error_msg'),
'form': form,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'search_tag': search_tag,
}
request.session['msg'] = ''
request.session['error_msg'] = ''
return render_to_response(template,
data,
context_instance=RequestContext(request))
def dnc_contact_import(request):
"""Import CSV file of DNC Contacts for the logged in user
**Attributes**:
* ``form`` - DNCContact_fileImport
* ``template`` - frontend/dnc/import_contact.html
**Logic Description**:
* Add new dnc contacts which will belong to the logged in user
via csv file & get the result (upload success and failure
statistics)
**Important variable**:
* total_rows - Total no. of records in the CSV file
* retail_record_count - No. of records imported from the CSV file
"""
form = DNCContact_fileImport(request.user)
csv_data = ''
msg = ''
error_msg = ''
success_import_list = []
type_error_import_list = []
contact_cnt = 0
dup_contact_cnt = 0
bulk_record = []
if request.method == 'POST':
form = DNCContact_fileImport(request.user, request.POST, request.FILES)
if form.is_valid():
# col_no - field name
# 0 - contact
# To count total rows of CSV file
#Get DNC Obj
dnc = get_object_or_404(DNC,
pk=request.POST['dnc_list'],
user=request.user)
records = csv.reader(request.FILES['csv_file'])
total_rows = len(list(records))
BULK_SIZE = 1000
csv_data = csv.reader(request.FILES['csv_file'])
#Read each Row
for row in csv_data:
row = striplist(row)
if not row or str(row[0]) == 0:
continue
#Check field type
try:
int(row[0])
except ValueError:
error_msg = _("Some of the imported data were invalid!")
type_error_import_list.append(row)
continue
bulk_record.append(
DNCContact(dnc_id=dnc.id, phone_number=row[0]))
contact_cnt = contact_cnt + 1
if contact_cnt < 100:
#We want to display only 100 lines of the success import
success_import_list.append(row)
if contact_cnt % BULK_SIZE == 0:
#Bulk insert
DNCContact.objects.bulk_create(bulk_record)
bulk_record = []
if bulk_record:
#Remaining record
DNCContact.objects.bulk_create(bulk_record)
bulk_record = []
#check if there is contact imported
if contact_cnt > 0:
msg = _('%(contact_cnt)s dnc contact(s) are uploaded successfully out of %(total_rows)s row(s) !!') \
% {'contact_cnt': contact_cnt,
'total_rows': total_rows}
if dup_contact_cnt > 0:
error_msg = _('Duplicate dnc contact(s) %(dup_contact_cnt)s are not inserted!!') \
% {'dup_contact_cnt': dup_contact_cnt}
data = RequestContext(
request, {
'form': form,
'msg': msg,
'error_msg': error_msg,
'success_import_list': success_import_list,
'type_error_import_list': type_error_import_list,
'module': current_view(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
})
template = 'frontend/dnc_contact/import_dnc_contact.html'
return render_to_response(template,
data,
context_instance=RequestContext(request))
def voipcall_report(request):
"""VoIP Call Report
**Attributes**:
* ``form`` - VoipSearchForm
* ``template`` - frontend/report/voipcall_report.html
**Logic Description**:
* Get VoIP call list according to search parameters for loggedin user
**Important variable**:
* ``request.session['voipcall_record_kwargs']`` - stores voipcall kwargs
"""
sort_col_field_list = ['starting_date', 'leg_type', 'disposition',
'used_gateway', 'callerid', 'callid', 'phone_number',
'duration', 'billsec', 'amd_status']
default_sort_field = 'starting_date'
pagination_data =\
get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
start_page = pagination_data['start_page']
end_page = pagination_data['end_page']
search_tag = 1
action = 'tabs-1'
if request.method == 'POST':
form = VoipSearchForm(request.user, request.POST)
if form.is_valid():
field_list = ['start_date', 'end_date',
'disposition', 'campaign_id', 'leg_type']
unset_session_var(request, field_list)
if request.POST.get('from_date'):
# From
from_date = request.POST['from_date']
start_date = ceil_strdate(from_date, 'start')
request.session['session_start_date'] = start_date
if request.POST.get('to_date'):
# To
to_date = request.POST['to_date']
end_date = ceil_strdate(to_date, 'end')
request.session['session_end_date'] = end_date
disposition = request.POST.get('status')
if disposition != 'all':
request.session['session_disposition'] = disposition
campaign_id = request.POST.get('campaign_id')
if campaign_id and int(campaign_id) != 0:
request.session['session_campaign_id'] = int(campaign_id)
leg_type = request.POST.get('leg_type')
if leg_type and leg_type != '':
request.session['session_leg_type'] = leg_type
post_var_with_page = 0
try:
if request.GET.get('page') or request.GET.get('sort_by'):
post_var_with_page = 1
start_date = request.session.get('session_start_date')
end_date = request.session.get('session_end_date')
disposition = request.session.get('session_disposition')
campaign_id = request.session.get('session_campaign_id')
leg_type = request.session.get('session_leg_type')
form = VoipSearchForm(request.user,
initial={'from_date': start_date.strftime('%Y-%m-%d'),
'to_date': end_date.strftime('%Y-%m-%d'),
'status': disposition,
'campaign_id': campaign_id,
'leg_type': leg_type})
else:
post_var_with_page = 1
if request.method == 'GET':
post_var_with_page = 0
except:
pass
if post_var_with_page == 0:
# default
tday = datetime.today()
from_date = tday.strftime('%Y-%m-%d')
to_date = tday.strftime('%Y-%m-%d')
start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0)
end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999)
disposition = 'all'
campaign_id = 0
leg_type = ''
form = VoipSearchForm(request.user,
initial={'from_date': from_date,
'to_date': to_date,
'status': disposition,
'campaign_id': campaign_id,
'leg_type': leg_type})
# unset session var
request.session['session_start_date'] = start_date
request.session['session_end_date'] = end_date
request.session['session_disposition'] = disposition
request.session['session_campaign_id'] = ''
request.session['session_leg_type'] = ''
kwargs = {}
if start_date and end_date:
kwargs['starting_date__range'] = (start_date, end_date)
if start_date and end_date == '':
kwargs['starting_date__gte'] = start_date
if start_date == '' and end_date:
kwargs['starting_date__lte'] = end_date
if disposition and disposition != 'all':
kwargs['disposition__exact'] = disposition
if campaign_id and int(campaign_id) != 0:
kwargs['callrequest__campaign_id'] = campaign_id
if leg_type and leg_type != '':
kwargs['leg_type__exact'] = leg_type
if not request.user.is_superuser:
kwargs['user'] = request.user
voipcall_list = VoIPCall.objects.filter(**kwargs)
all_voipcall_list = voipcall_list.values_list('id', flat=True)
# Session variable is used to get record set with searched option
# into export file
request.session['voipcall_record_kwargs'] = kwargs
if request.GET.get('page') or request.GET.get('sort_by'):
daily_data = request.session['voipcall_daily_data']
else:
if not voipcall_list:
request.session['voipcall_daily_data'] = ''
daily_data = get_voipcall_daily_data(voipcall_list)
request.session['voipcall_daily_data'] = daily_data
voipcall_list = voipcall_list.order_by(sort_order)[start_page:end_page]
template = 'frontend/report/voipcall_report.html'
data = {
'form': form,
'total_data': daily_data['total_data'],
'total_duration': daily_data['total_duration'],
'total_calls': daily_data['total_calls'],
'total_avg_duration': daily_data['total_avg_duration'],
'max_duration': daily_data['max_duration'],
'module': current_view(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'all_voipcall_list': all_voipcall_list,
'voipcall_list': voipcall_list,
'PAGE_SIZE': PAGE_SIZE,
'CDR_REPORT_COLUMN_NAME': CDR_REPORT_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'search_tag': search_tag,
'start_date': start_date,
'end_date': end_date,
'action': action,
'AMD': settings.AMD,
}
request.session['msg'] = ''
request.session['error_msg'] = ''
return render_to_response(template, data,
context_instance=RequestContext(request))
def dnc_contact_list(request):
"""DNC Contact list for the logged in user
**Attributes**:
* ``template`` - frontend/dnc_contact/list.html
* ``form`` - ContactSearchForm
**Logic Description**:
* List all dnc contacts from dnc lists belonging to the logged in user
"""
sort_col_field_list = ['id', 'dnc', 'phone_number', 'updated_date']
default_sort_field = 'id'
pagination_data =\
get_pagination_vars(request, sort_col_field_list, default_sort_field)
PAGE_SIZE = pagination_data['PAGE_SIZE']
sort_order = pagination_data['sort_order']
start_page = pagination_data['start_page']
end_page = pagination_data['end_page']
form = DNCContactSearchForm(request.user)
dnc_id_list = DNC.objects.values_list('id', flat=True)\
.filter(user=request.user)
search_tag = 1
phone_number = ''
dnc = ''
if request.method == 'POST':
form = DNCContactSearchForm(request.user, request.POST)
if form.is_valid():
request.session['session_phone_number'] = ''
request.session['session_dnc'] = ''
if request.POST.get('phone_number'):
phone_number = request.POST.get('phone_number')
request.session['session_phone_number'] = phone_number
if request.POST.get('dnc'):
dnc = request.POST.get('dnc')
request.session['session_dnc'] = dnc
post_var_with_page = 0
try:
if request.GET.get('page') or request.GET.get('sort_by'):
post_var_with_page = 1
phone_number = request.session.get('session_phone_number')
dnc = request.session.get('session_dnc')
form = DNCContactSearchForm(request.user,
initial={
'phone_number': phone_number,
'dnc': dnc
})
else:
post_var_with_page = 1
if request.method == 'GET':
post_var_with_page = 0
except:
pass
if post_var_with_page == 0:
# default
# unset session var
request.session['session_phone_number'] = ''
request.session['session_dnc'] = ''
kwargs = {}
if dnc and dnc != '0':
kwargs['dnc_id'] = dnc
phone_number_type = '1'
phone_number = type_field_chk(phone_number, phone_number_type,
'phone_number')
for i in phone_number:
kwargs[i] = phone_number[i]
phone_number_list = []
all_phone_number_list = []
phone_number_count = 0
if dnc_id_list:
phone_number_list = DNCContact.objects.values('id', 'dnc__name',
'phone_number', 'updated_date')\
.filter(dnc__in=dnc_id_list)
if kwargs:
phone_number_list = phone_number_list.filter(**kwargs)
all_phone_number_list = phone_number_list.order_by(sort_order)
phone_number_list = all_phone_number_list[start_page:end_page]
phone_number_count = all_phone_number_list.count()
template = 'frontend/dnc_contact/list.html'
data = {
'module': current_view(request),
'phone_number_list': phone_number_list,
'all_phone_number_list': all_phone_number_list,
'total_phone_numbers': phone_number_count,
'PAGE_SIZE': PAGE_SIZE,
'DNC_CONTACT_COLUMN_NAME': DNC_CONTACT_COLUMN_NAME,
'col_name_with_order': pagination_data['col_name_with_order'],
'msg': request.session.get('msg'),
'error_msg': request.session.get('error_msg'),
'form': form,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'search_tag': search_tag,
}
request.session['msg'] = ''
request.session['error_msg'] = ''
return render_to_response(template,
data,
context_instance=RequestContext(request))
def contact_import(request):
"""Import CSV file of Contacts for the logged in user
**Attributes**:
* ``form`` - Contact_fileImport
* ``template`` - frontend/contact/import_contact.html
**Logic Description**:
* Before adding contacts, check dialer setting limit if applicable
to the user.
* Add new contacts which will belong to the logged in user
via csv file & get the result (upload success and failure
statistics)
**Important variable**:
* total_rows - Total no. of records in the CSV file
* retail_record_count - No. of records imported from the CSV file
"""
# Check dialer setting limit
if request.user and request.method == 'POST':
# check Max Number of contacts
if check_dialer_setting(request, check_for="contact"):
request.session['msg'] = \
_("you have too many contacts. you are allowed a maximum of %(limit)s") % \
{'limit': dialer_setting_limit(request, limit_for="contact")}
# contact limit reached
frontend_send_notification(request,
NOTIFICATION_NAME.contact_limit_reached)
return HttpResponseRedirect("/contact/")
form = Contact_fileImport(request.user)
csv_data = ''
msg = ''
error_msg = ''
success_import_list = []
type_error_import_list = []
contact_cnt = 0
bulk_record = []
if request.method == 'POST':
form = Contact_fileImport(request.user, request.POST, request.FILES)
if form.is_valid():
# col_no - field name
# 0 - contact
# 1 - last_name
# 2 - first_name
# 3 - email
# 4 - description
# 5 - status
# 6 - address
# 7 - city
# 8 - country
# 9 - country
# 10 - unit_number
# 11 - additional_vars
# To count total rows of CSV file
records = csv.reader(request.FILES['csv_file'],
delimiter='|',
quotechar='"')
total_rows = len(list(records))
BULK_SIZE = 1000
csv_data = csv.reader(request.FILES['csv_file'],
delimiter='|',
quotechar='"')
#Get Phonebook Obj
phonebook = get_object_or_404(Phonebook,
pk=request.POST['phonebook'],
user=request.user)
#Read each Row
for row in csv_data:
row = striplist(row)
if not row or str(row[0]) == 0:
continue
#Check field type
if not int(row[5]):
error_msg = _(
"invalid value for import! please check the import samples or phonebook is not valid"
)
type_error_import_list.append(row)
break
if len(row[9]) > 2:
error_msg = _(
"invalid value for country code, it needs to be a valid ISO 3166-1 alpha-2 codes (http://en.wikipedia.org/wiki/ISO_3166-1)"
)
type_error_import_list.append(row)
break
row_11 = ''
if row[11]:
try:
row_11 = json.loads(row[11])
except:
row_11 = ''
bulk_record.append(
Contact(
phonebook=phonebook,
contact=row[0],
last_name=row[1],
first_name=row[2],
email=row[3],
description=row[4],
status=int(row[5]),
address=row[6],
city=row[7],
state=row[8],
country=row[
9], # Note: country needs to be a country code (CA, ES)
unit_number=row[10],
additional_vars=row_11))
contact_cnt = contact_cnt + 1
if contact_cnt < 100:
#We want to display only 100 lines of the success import
success_import_list.append(row)
if contact_cnt % BULK_SIZE == 0:
#Bulk insert
Contact.objects.bulk_create(bulk_record)
bulk_record = []
# remaining record
Contact.objects.bulk_create(bulk_record)
bulk_record = []
#check if there is contact imported
if contact_cnt > 0:
msg = _('%(contact_cnt)s contact(s) are uploaded successfully out of %(total_rows)s row(s) !!') \
% {'contact_cnt': contact_cnt,
'total_rows': total_rows}
data = RequestContext(
request, {
'form': form,
'csv_data': csv_data,
'msg': msg,
'error_msg': error_msg,
'success_import_list': success_import_list,
'type_error_import_list': type_error_import_list,
'module': current_view(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
})
template = 'frontend/contact/import_contact.html'
return render_to_response(template,
data,
context_instance=RequestContext(request))
def customer_detail_change(request):
"""User Detail change on Customer UI
**Attributes**:
* ``form`` - UserChangeDetailForm, UserChangeDetailExtendForm,
PasswordChangeForm, CheckPhoneNumberForm
* ``template`` - 'frontend/registration/user_detail_change.html'
**Logic Description**:
* User is able to change his/her detail.
"""
user_detail = get_object_or_404(User, username=request.user)
try:
user_detail_extened = UserProfile.objects.get(user=user_detail)
except UserProfile.DoesNotExist:
#create UserProfile
user_detail_extened = UserProfile(user=user_detail)
#DEMO / Disable
if not settings.DEMO_MODE:
user_detail_extened.save()
user_detail_form = UserChangeDetailForm(request.user,
instance=user_detail)
user_detail_extened_form = \
UserChangeDetailExtendForm(request.user,
instance=user_detail_extened)
user_password_form = PasswordChangeForm(user=request.user)
check_phone_no_form = CheckPhoneNumberForm()
try:
dialer_set = DialerSetting.objects.get(id=request.user.get_profile().dialersetting_id)
except:
dialer_set = ''
msg_detail = ''
msg_pass = ''
msg_number = ''
error_detail = ''
error_pass = ''
error_number = ''
action = ''
if 'action' in request.GET:
action = request.GET['action']
if request.method == 'POST':
if request.POST['form-type'] == "change-detail":
user_detail_form = UserChangeDetailForm(
request.user, request.POST, instance=user_detail)
user_detail_extened_form = \
UserChangeDetailExtendForm(
request.user, request.POST, instance=user_detail_extened)
action = 'tabs-1'
if (user_detail_form.is_valid()
and user_detail_extened_form.is_valid()):
#DEMO / Disable
if not settings.DEMO_MODE:
user_detail_form.save()
user_detail_extened_form.save()
msg_detail = _('detail has been changed.')
else:
error_detail = _('please correct the errors below.')
elif request.POST['form-type'] == "check-number": # check phone no
action = 'tabs-4'
check_phone_no_form = CheckPhoneNumberForm(data=request.POST)
if check_phone_no_form.is_valid():
if not common_contact_authorization(request.user, request.POST['phone_number']):
error_number = _('this phone number is not authorized.')
else:
msg_number = _('this phone number is authorized.')
else:
error_number = _('please correct the errors below.')
else: # "change-password"
user_password_form = PasswordChangeForm(user=request.user,
data=request.POST)
action = 'tabs-2'
if user_password_form.is_valid():
#DEMO / Disable
if not settings.DEMO_MODE:
user_password_form.save()
msg_pass = _('your password has been changed.')
else:
error_pass = _('please correct the errors below.')
template = 'frontend/registration/user_detail_change.html'
data = {
'module': current_view(request),
'user_detail_form': user_detail_form,
'user_detail_extened_form': user_detail_extened_form,
'user_password_form': user_password_form,
'check_phone_no_form': check_phone_no_form,
'msg_detail': msg_detail,
'msg_pass': msg_pass,
'msg_number': msg_number,
'error_detail': error_detail,
'error_pass': error_pass,
'error_number': error_number,
'dialer_set': dialer_set,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'action': action,
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def customer_detail_change(request):
"""User Detail change on Customer UI
**Attributes**:
* ``form`` - UserChangeDetailForm, UserChangeDetailExtendForm,
PasswordChangeForm, CheckPhoneNumberForm
* ``template`` - 'frontend/registration/user_detail_change.html'
**Logic Description**:
* User is able to change his/her detail.
"""
user_detail = User.objects.get(username=request.user)
try:
user_detail_extened = UserProfile.objects.get(user=user_detail)
except UserProfile.DoesNotExist:
#create UserProfile
user_detail_extened = UserProfile(user=user_detail)
#DEMO / Disable
user_detail_extened.save()
user_detail_form = UserChangeDetailForm(request.user, instance=user_detail)
user_detail_extened_form = \
UserChangeDetailExtendForm(request.user,
instance=user_detail_extened)
user_password_form = PasswordChangeForm(user=request.user)
check_phone_no_form = CheckPhoneNumberForm()
try:
user_ds = UserProfile.objects.get(user=request.user)
dialer_set = DialerSetting.objects.get(id=user_ds.dialersetting.id)
except:
dialer_set = ''
user_notification = \
notification.Notice.objects.filter(recipient=request.user)
# Search on sender name
q = (Q(sender=request.user))
if q:
user_notification = user_notification.filter(q)
msg_detail = ''
msg_pass = ''
msg_number = ''
msg_note = ''
error_detail = ''
error_pass = ''
error_number = ''
action = ''
if 'action' in request.GET:
action = request.GET['action']
if request.GET.get('msg_note') == 'true':
msg_note = request.session['msg_note']
# Mark all notification as read
if request.GET.get('notification') == 'mark_read_all':
notification_list = \
notification.Notice.objects.filter(unseen=1,
recipient=request.user)
notification_list.update(unseen=0)
msg_note = _('All notifications are marked as read.')
if request.method == 'POST':
if request.POST['form-type'] == "change-detail":
user_detail_form = UserChangeDetailForm(request.user,
request.POST,
instance=user_detail)
user_detail_extened_form = \
UserChangeDetailExtendForm(request.user, request.POST,
instance=user_detail_extened)
action = 'tabs-1'
if user_detail_form.is_valid() \
and user_detail_extened_form.is_valid():
#DEMO / Disable
user_detail_form.save()
user_detail_extened_form.save()
msg_detail = _('Detail has been changed.')
else:
error_detail = _('Please correct the errors below.')
elif request.POST['form-type'] == "check-number": # check phone no
action = 'tabs-5'
check_phone_no_form = CheckPhoneNumberForm(data=request.POST)
if check_phone_no_form.is_valid():
if not common_contact_authorization(
request.user, request.POST['phone_number']):
error_number = _('This phone number is not authorized.')
else:
msg_number = _('This phone number is authorized.')
else:
error_number = _('Please correct the errors below.')
else: # "change-password"
user_password_form = PasswordChangeForm(user=request.user,
data=request.POST)
action = 'tabs-2'
if user_password_form.is_valid():
#DEMO / Disable
user_password_form.save()
msg_pass = _('Your password has been changed.')
else:
error_pass = _('Please correct the errors below.')
template = 'frontend/registration/user_detail_change.html'
data = {
'module': current_view(request),
'user_detail_form': user_detail_form,
'user_detail_extened_form': user_detail_extened_form,
'user_password_form': user_password_form,
'check_phone_no_form': check_phone_no_form,
'user_notification': user_notification,
'msg_detail': msg_detail,
'msg_pass': msg_pass,
'msg_number': msg_number,
'msg_note': msg_note,
'error_detail': error_detail,
'error_pass': error_pass,
'error_number': error_number,
'notice_count': notice_count(request),
'dialer_set': dialer_set,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'action': action,
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def voipcall_report(request):
"""VoIP Call Report
**Attributes**:
* ``form`` - VoipSearchForm
* ``template`` - frontend/report/voipcall_report.html
**Logic Description**:
* Get VoIP call list according to search parameters for loggedin user
**Important variable**:
* ``request.session['voipcall_record_qs']`` - stores voipcall query set
"""
kwargs = {}
kwargs['user'] = request.user
from_date = ''
to_date = ''
disposition = variable_value(request, 'status')
form = VoipSearchForm()
if request.method == 'POST':
if request.POST['from_date'] != "":
from_date = request.POST['from_date']
if request.POST['to_date'] != "":
to_date = request.POST['to_date']
form = VoipSearchForm(request.POST)
kwargs = voipcall_record_common_fun(request)
else:
tday = datetime.today()
kwargs['starting_date__gte'] = datetime(tday.year, tday.month,
tday.day, 0, 0, 0, 0)
voipcall_list = \
VoIPCall.objects.values('user', 'callid', 'callerid', 'phone_number',
'starting_date', 'duration', 'billsec',
'disposition', 'hangup_cause', 'hangup_cause_q850',
'used_gateway').filter(**kwargs).order_by('-starting_date')
# Session variable is used to get record set with searched option
# into export file
request.session['voipcall_record_qs'] = voipcall_list
select_data = \
{"starting_date": "SUBSTR(CAST(starting_date as CHAR(30)),1,10)"}
total_data = ''
# Get Total Rrecords from VoIPCall Report table for Daily Call Report
total_data = VoIPCall.objects.extra(select=select_data)\
.values('starting_date')\
.filter(**kwargs).annotate(Count('starting_date'))\
.annotate(Sum('duration'))\
.annotate(Avg('duration'))\
.order_by('-starting_date')
# Following code will count total voip calls, duration
if total_data.count() != 0:
max_duration = \
max([x['duration__sum'] for x in total_data])
total_duration = \
sum([x['duration__sum'] for x in total_data])
total_calls = sum([x['starting_date__count'] for x in total_data])
total_avg_duration = \
(sum([x['duration__avg']\
for x in total_data])) / total_data.count()
else:
max_duration = 0
total_duration = 0
total_calls = 0
total_avg_duration = 0
template = 'frontend/report/voipcall_report.html'
data = {
'form': form,
'from_date': from_date,
'to_date': to_date,
'disposition': disposition,
'total_data': total_data.reverse(),
'total_duration': total_duration,
'total_calls': total_calls,
'total_avg_duration': total_avg_duration,
'max_duration': max_duration,
'module': current_view(request),
'notice_count': notice_count(request),
'dialer_setting_msg': user_dialer_setting_msg(request.user),
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def customer_dashboard(request, on_index=None):
"""Customer dashboard gives the following information
* No of Campaigns for logged in user
* Total phonebook contacts
* Total Campaigns contacts
* Amount of contact reached today
* Disposition of calls via pie chart
* Call records & Duration of calls are shown on graph by days/hours
**Attributes**:
* ``template`` - frontend/dashboard.html
* ``form`` - DashboardForm
"""
logging.debug('Start Dashboard')
# All campaign for logged in User
campaign_id_list = Campaign.objects.values_list('id', flat=True)\
.filter(user=request.user).order_by('id')
campaign_count = campaign_id_list.count()
# Contacts count which are active and belong to those phonebook(s) which is
# associated with all campaign
pb_active_contact_count = Contact.objects\
.filter(phonebook__campaign__in=campaign_id_list, status=CONTACT_STATUS.ACTIVE)\
.count()
total_of_phonebook_contacts =\
Contact.objects.filter(phonebook__user=request.user).count()
form = DashboardForm(request.user)
logging.debug('Got Campaign list')
total_record = dict()
total_duration_sum = 0
total_call_count = 0
total_answered = 0
total_not_answered = 0
total_busy = 0
total_cancel = 0
total_congestion = 0
total_failed = 0
search_type = SEARCH_TYPE.D_Last_24_hours # default Last 24 hours
selected_campaign = ''
if campaign_id_list:
selected_campaign = campaign_id_list[0] # default campaign id
# selected_campaign should not be empty
if selected_campaign:
if request.method == 'POST':
form = DashboardForm(request.user, request.POST)
selected_campaign = request.POST['campaign']
search_type = request.POST['search_type']
end_date = datetime.today()
start_date = calculate_date(search_type)
# date_length is used to do group by starting_date
if int(search_type
) >= SEARCH_TYPE.B_Last_7_days: # all options except 30 days
date_length = 13
if int(search_type) == SEARCH_TYPE.C_Yesterday: # yesterday
now = datetime.now()
start_date = datetime(now.year, now.month, now.day, 0, 0, 0,
0) - relativedelta(days=1)
end_date = datetime(now.year, now.month, now.day, 23, 59, 59,
999999) - relativedelta(days=1)
if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
date_length = 16
else:
date_length = 10 # Last 30 days option
select_data = {
"starting_date":
"SUBSTR(CAST(starting_date as CHAR(30)),1,%s)" % str(date_length)
}
# This calls list is used by pie chart
calls = VoIPCall.objects\
.filter(callrequest__campaign=selected_campaign,
duration__isnull=False,
user=request.user,
starting_date__range=(start_date, end_date))\
.extra(select=select_data)\
.values('starting_date', 'disposition')\
.annotate(Count('starting_date'))\
.order_by('starting_date')
logging.debug('Aggregate VoIPCall')
for i in calls:
total_call_count += i['starting_date__count']
if (i['disposition'] == VOIPCALL_DISPOSITION.ANSWER
or i['disposition'] == 'NORMAL_CLEARING'):
total_answered += i['starting_date__count']
elif (i['disposition'] == VOIPCALL_DISPOSITION.BUSY
or i['disposition'] == 'USER_BUSY'):
total_busy += i['starting_date__count']
elif (i['disposition'] == VOIPCALL_DISPOSITION.NOANSWER
or i['disposition'] == 'NO_ANSWER'):
total_not_answered += i['starting_date__count']
elif (i['disposition'] == VOIPCALL_DISPOSITION.CANCEL
or i['disposition'] == 'ORIGINATOR_CANCEL'):
total_cancel += i['starting_date__count']
elif (i['disposition'] == VOIPCALL_DISPOSITION.CONGESTION
or i['disposition'] == 'NORMAL_CIRCUIT_CONGESTION'):
total_congestion += i['starting_date__count']
else:
#VOIP CALL FAILED
total_failed += i['starting_date__count']
# following calls list is without disposition & group by call date
calls = VoIPCall.objects\
.filter(callrequest__campaign=selected_campaign,
duration__isnull=False,
user=request.user,
starting_date__range=(start_date, end_date))\
.extra(select=select_data)\
.values('starting_date').annotate(Sum('duration'))\
.annotate(Avg('duration'))\
.annotate(Count('starting_date'))\
.order_by('starting_date')
logging.debug('Aggregate VoIPCall (2)')
mintime = start_date
maxtime = end_date
calls_dict = {}
calls_dict_with_min = {}
for data in calls:
if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
ctime = datetime(int(data['starting_date'][0:4]),
int(data['starting_date'][5:7]),
int(data['starting_date'][8:10]),
int(data['starting_date'][11:13]), 0, 0, 0)
if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
ctime = datetime(int(data['starting_date'][0:4]),
int(data['starting_date'][5:7]),
int(data['starting_date'][8:10]),
int(data['starting_date'][11:13]),
int(data['starting_date'][14:16]), 0, 0)
else:
ctime = datetime(int(data['starting_date'][0:4]),
int(data['starting_date'][5:7]),
int(data['starting_date'][8:10]), 0, 0, 0, 0)
if ctime > maxtime:
maxtime = ctime
elif ctime < mintime:
mintime = ctime
# all options except 30 days
if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
calls_dict[int(ctime.strftime("%Y%m%d%H"))] =\
{
'call_count': data['starting_date__count'],
'duration_sum': data['duration__sum'],
'duration_avg': float(data['duration__avg']),
}
calls_dict_with_min[int(ctime.strftime("%Y%m%d%H%M"))] =\
{
'call_count': data['starting_date__count'],
'duration_sum': data['duration__sum'],
'duration_avg': float(data['duration__avg']),
}
else:
# Last 30 days option
calls_dict[int(ctime.strftime("%Y%m%d"))] =\
{
'call_count': data['starting_date__count'],
'duration_sum': data['duration__sum'],
'duration_avg': float(data['duration__avg']),
}
logging.debug('After Call Loops')
dateList = date_range(mintime, maxtime, q=search_type)
for date in dateList:
inttime = int(date.strftime("%Y%m%d"))
# last 7 days | yesterday | last 24 hrs
if int(search_type) == SEARCH_TYPE.B_Last_7_days \
or int(search_type) == SEARCH_TYPE.C_Yesterday \
or int(search_type) == SEARCH_TYPE.D_Last_24_hours:
for option in range(0, 24):
day_time = int(str(inttime) + str(option).zfill(2))
graph_day = datetime(int(date.strftime("%Y")),
int(date.strftime("%m")),
int(date.strftime("%d")),
int(str(option).zfill(2)))
dt = int(1000 * time.mktime(graph_day.timetuple()))
total_record[dt] = {
'call_count': 0,
'duration_sum': 0,
'duration_avg': 0.0,
}
if day_time in calls_dict.keys():
total_record[dt]['call_count'] += calls_dict[day_time][
'call_count']
total_record[dt]['duration_sum'] += calls_dict[
day_time]['duration_sum']
total_record[dt]['duration_avg'] += float(
calls_dict[day_time]['duration_avg'])
# last 12 hrs | last 6 hrs | last 1 hrs
elif (int(search_type) == SEARCH_TYPE.E_Last_12_hours
or int(search_type) == SEARCH_TYPE.F_Last_6_hours
or int(search_type) == SEARCH_TYPE.G_Last_hour):
for hour in range(0, 24):
for minute in range(0, 60):
hr_time = int(
str(inttime) + str(hour).zfill(2) +
str(minute).zfill(2))
graph_day = datetime(int(date.strftime("%Y")),
int(date.strftime("%m")),
int(date.strftime("%d")),
int(str(hour).zfill(2)),
int(str(minute).zfill(2)))
dt = int(1000 * time.mktime(graph_day.timetuple()))
total_record[dt] = {
'call_count': 0,
'duration_sum': 0,
'duration_avg': 0.0,
}
if hr_time in calls_dict_with_min.keys():
total_record[dt][
'call_count'] += calls_dict_with_min[hr_time][
'call_count']
total_record[dt][
'duration_sum'] += calls_dict_with_min[
hr_time]['duration_sum']
total_record[dt]['duration_avg'] += float(
calls_dict_with_min[hr_time]['duration_avg'])
else:
# Last 30 days option
graph_day = datetime(int(date.strftime("%Y")),
int(date.strftime("%m")),
int(date.strftime("%d")))
dt = int(1000 * time.mktime(graph_day.timetuple()))
total_record[dt] = {
'call_count': 0,
'duration_sum': 0,
'duration_avg': 0,
}
if inttime in calls_dict.keys():
total_record[dt]['call_count'] += calls_dict[inttime][
'call_count']
total_record[dt]['duration_sum'] += calls_dict[inttime][
'duration_sum']
total_record[dt]['duration_avg'] += float(
calls_dict[inttime]['duration_avg'])
logging.debug('After dateList Loops')
# sorting on date col
total_record = total_record.items()
total_record = sorted(total_record, key=lambda k: k[0])
# lineWithFocusChart
final_charttype = "lineWithFocusChart"
xdata = []
ydata = []
ydata2 = []
for i in total_record:
xdata.append(i[0])
ydata.append(i[1]['call_count'])
ydata2.append(i[1]['duration_sum'])
tooltip_date = "%d %b %y %H:%M %p"
extra_serie1 = {
"tooltip": {
"y_start": "",
"y_end": " calls"
},
"date_format": tooltip_date
}
extra_serie2 = {
"tooltip": {
"y_start": "",
"y_end": " sec"
},
"date_format": tooltip_date
}
final_chartdata = {
'x': xdata,
'name1': 'Calls',
'y1': ydata,
'extra1': extra_serie1,
'name2': 'Duration',
'y2': ydata2,
'extra2': extra_serie2,
}
# Contacts which are successfully called for running campaign
reached_contact = 0
if campaign_id_list:
now = datetime.now()
start_date = datetime(now.year, now.month, now.day, 0, 0, 0, 0)
end_date = datetime(now.year, now.month, now.day, 23, 59, 59, 999999)
reached_contact = Subscriber.objects\
.filter(campaign_id__in=campaign_id_list, # status=5,
updated_date__range=(start_date, end_date))\
.count()
# PieChart
hangup_analytic_charttype = "pieChart"
xdata = []
ydata = []
hangup_analytic_chartdata = {'x': xdata}
if total_call_count != 0:
for i in VOIPCALL_DISPOSITION:
xdata.append(i[0])
# Y-axis order depend upon VOIPCALL_DISPOSITION
# 'ANSWER', 'BUSY', 'CANCEL', 'CONGESTION', 'FAILED', 'NOANSWER'
ydata = [
percentage(total_answered, total_call_count),
percentage(total_busy, total_call_count),
percentage(total_cancel, total_call_count),
percentage(total_congestion, total_call_count),
percentage(total_failed, total_call_count),
percentage(total_not_answered, total_call_count),
]
color_list = [
COLOR_DISPOSITION['ANSWER'],
COLOR_DISPOSITION['BUSY'],
COLOR_DISPOSITION['CANCEL'],
COLOR_DISPOSITION['CONGESTION'],
COLOR_DISPOSITION['FAILED'],
COLOR_DISPOSITION['NOANSWER'],
]
extra_serie = {
"tooltip": {
"y_start": "",
"y_end": " %"
},
"color_list": color_list
}
hangup_analytic_chartdata = {
'x': xdata,
'y1': ydata,
'extra1': extra_serie
}
template = 'frontend/dashboard.html'
data = {
'module': current_view(request),
'form': form,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'campaign_count': campaign_count,
'total_of_phonebook_contacts': total_of_phonebook_contacts,
'campaign_phonebook_active_contact_count': pb_active_contact_count,
'reached_contact': reached_contact,
'total_duration_sum': total_duration_sum,
'total_call_count': total_call_count,
'total_answered': total_answered,
'total_not_answered': total_not_answered,
'total_busy': total_busy,
'total_cancel': total_cancel,
'total_congestion': total_congestion,
'total_failed': total_failed,
'answered_color': COLOR_DISPOSITION['ANSWER'],
'busy_color': COLOR_DISPOSITION['BUSY'],
'not_answered_color': COLOR_DISPOSITION['NOANSWER'],
'cancel_color': COLOR_DISPOSITION['CANCEL'],
'congestion_color': COLOR_DISPOSITION['CONGESTION'],
'failed_color': COLOR_DISPOSITION['FAILED'],
'VOIPCALL_DISPOSITION': VOIPCALL_DISPOSITION,
'hangup_analytic_chartdata': hangup_analytic_chartdata,
'hangup_analytic_charttype': hangup_analytic_charttype,
'final_chartdata': final_chartdata,
'final_charttype': final_charttype,
}
if on_index == 'yes':
return data
return render_to_response(template,
data,
context_instance=RequestContext(request))
