示例#1
0
def sms_dashboard(request, on_index=None):
    """SMS dashboard gives the following information

        * No of SMSCampaigns for logged in user
        * Total phonebook contacts
        * Total SMSCampaigns contacts
        * Amount of contact reached today
        * Disposition of sms via pie chart
        * SMS count shown on graph by days/hours

    **Attributes**:

        * ``template`` - mod_sms/sms_dashboard.html
        * ``form`` - SMSDashboardForm
    """
    # All sms_campaign for logged in User
    sms_campaign_id_list = SMSCampaign.objects.values_list('id', flat=True).filter(user=request.user).order_by('id')

    # Contacts count which are active and belong to those phonebook(s) which is
    # associated with all sms campaign
    pb_active_contact_count = Contact.objects.filter(
        phonebook__smscampaign__in=sms_campaign_id_list,
        status=CONTACT_STATUS.ACTIVE).count()

    form = SMSDashboardForm(request.user, request.POST or None)

    total_record = dict()
    total_sms_count = 0
    total_unsent = 0
    total_sent = 0
    total_delivered = 0
    total_failed = 0
    total_no_route = 0
    total_unauthorized = 0

    select_graph_for = 'sms count'  # default
    search_type = SEARCH_TYPE.D_Last_24_hours  # default Last 24 hours
    selected_sms_campaign = ''

    if sms_campaign_id_list:
        selected_sms_campaign = sms_campaign_id_list[0]  # default sms campaign id

    # selected_sms_campaign should not be empty
    if selected_sms_campaign:

        if form.is_valid():
            selected_sms_campaign = request.POST['smscampaign']
            search_type = request.POST['search_type']

        end_date = datetime.utcnow().replace(tzinfo=utc)
        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.utcnow().replace(tzinfo=utc)
                start_date = datetime(now.year, now.month, now.day, 0, 0, 0, 0).replace(tzinfo=utc) \
                    - relativedelta(days=1)
                end_date = datetime(now.year, now.month, now.day, 23, 59, 59, 999999).replace(tzinfo=utc) \
                    - 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 = {
            "send_date": "SUBSTR(CAST(send_date as CHAR(30)),1," + str(date_length) + ")"}

        # This calls list is used by pie chart
        list_sms = SMSMessage.objects.filter(
            sender=request.user,
            sms_campaign_id=selected_sms_campaign,
            send_date__range=(start_date, end_date))\
            .extra(select=select_data)\
            .values('send_date', 'status')\
            .annotate(Count('send_date'))\
            .order_by('send_date')

        for i in list_sms:
            # convert unicode date string into date
            if i['status'] == 'Unsent':
                total_unsent += i['send_date__count']
            elif i['status'] == 'Sent':
                total_sent += i['send_date__count']
            elif i['status'] == 'Delivered':
                total_delivered += i['send_date__count']
            elif i['status'] == 'Failed':
                total_failed += i['send_date__count']
            elif i['status'] == 'No_Route':
                total_no_route += i['send_date__count']
            else:
                total_unauthorized += i['send_date__count']  # Unauthorized

            total_sms_count += i['send_date__count']

        list_sms = SMSMessage.objects.filter(
            sender=request.user,
            sms_campaign_id=selected_sms_campaign,
            send_date__range=(start_date, end_date))\
            .extra(select=select_data).values('send_date')\
            .annotate(Count('send_date')).order_by('send_date')

        mintime = start_date
        maxtime = end_date
        sms_dict = {}
        sms_dict_with_min = {}

        for data in list_sms:
            if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
                ctime = datetime(int(data['send_date'][0:4]),
                                 int(data['send_date'][5:7]),
                                 int(data['send_date'][8:10]),
                                 int(data['send_date'][11:13]),
                                 0, 0, 0).replace(tzinfo=utc)
                if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
                    ctime = datetime(int(data['send_date'][0:4]),
                                     int(data['send_date'][5:7]),
                                     int(data['send_date'][8:10]),
                                     int(data['send_date'][11:13]),
                                     int(data['send_date'][14:16]),
                                     0, 0).replace(tzinfo=utc)
            else:
                ctime = datetime(int(data['send_date'][0:4]),
                                 int(data['send_date'][5:7]),
                                 int(data['send_date'][8:10]),
                                 0, 0, 0, 0).replace(tzinfo=utc)
            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:
                sms_dict[int(ctime.strftime("%Y%m%d%H"))] = {
                    'sms_count': data['send_date__count']
                }
                sms_dict_with_min[int(ctime.strftime("%Y%m%d%H%M"))] = {
                    'sms_count': data['send_date__count']
                }
            else:
                # Last 30 days option
                sms_dict[int(ctime.strftime("%Y%m%d"))] = {
                    'sms_count': data['send_date__count']
                }

        dateList = date_range(mintime, maxtime, q=search_type)

        i = 0
        total_record = {}
        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))).replace(tzinfo=utc)

                    dt = int(1000 * time.mktime(graph_day.timetuple()))
                    total_record[dt] = {'sms_count': 0}

                    if day_time in sms_dict.keys():
                        total_record[dt]['sms_count'] += sms_dict[day_time]['sms_count']

            # 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))).replace(tzinfo=utc)

                        dt = int(1000 * time.mktime(graph_day.timetuple()))
                        total_record[dt] = {'sms_count': 0}

                        if hr_time in sms_dict_with_min.keys():
                            total_record[dt]['sms_count'] += sms_dict_with_min[hr_time]['sms_count']

            else:
                # Last 30 days option
                graph_day = datetime(int(date.strftime("%Y")),
                                     int(date.strftime("%m")),
                                     int(date.strftime("%d"))).replace(tzinfo=utc)
                dt = int(1000 * time.mktime(graph_day.timetuple()))
                total_record[dt] = {'sms_count': 0}
                if inttime in sms_dict.keys():
                    total_record[dt]['sms_count'] += sms_dict[inttime]['sms_count']

    # 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 = []
    for i in total_record:
        xdata.append(i[0])
        ydata.append(i[1]['sms_count'])

    tooltip_date = "%d %b %y %H:%M %p"
    extra_serie1 = {
        "tooltip": {"y_start": "", "y_end": " SMS"},
        "date_format": tooltip_date
    }

    final_chartdata = {
        'x': xdata,
        'name1': 'SMS', 'y1': ydata, 'extra1': extra_serie1,
    }

    # Contacts which are successfully messaged for running sms campaign
    reached_contact = 0
    if sms_campaign_id_list:
        now = datetime.utcnow().replace(tzinfo=utc)
        start_date = datetime(now.year, now.month, now.day, 0, 0, 0, 0).replace(tzinfo=utc)
        end_date = datetime(now.year, now.month, now.day, 23, 59, 59, 999999).replace(tzinfo=utc)
        sms_campaign_subscriber = SMSCampaignSubscriber.objects.filter(
            sms_campaign_id__in=sms_campaign_id_list,
            status=SMS_SUBSCRIBER_STATUS.COMPLETE,
            updated_date__range=(start_date, end_date)).count()
        reached_contact += sms_campaign_subscriber

    # PieChart
    sms_analytic_charttype = "pieChart"
    xdata = []
    ydata = []
    sms_analytic_chartdata = {'x': xdata, 'y1': ydata}

    if total_sms_count != 0:
        for i in SMS_MESSAGE_STATUS:
            xdata.append(i[0].upper())

        # Y-axis order depend upon SMS_MESSAGE_STATUS
        # 'UNSENT', 'SENT', 'DELIVERED', 'FAILED', 'NO_ROUTE', 'UNAUTHORIZED'
        ydata = [
            percentage(total_unsent, total_sms_count),
            percentage(total_sent, total_sms_count),
            percentage(total_delivered, total_sms_count),
            percentage(total_failed, total_sms_count),
            percentage(total_no_route, total_sms_count),
            percentage(total_unauthorized, total_sms_count),
        ]

        color_list = [
            COLOR_SMS_DISPOSITION['UNSENT'],
            COLOR_SMS_DISPOSITION['SENT'],
            COLOR_SMS_DISPOSITION['DELIVERED'],
            COLOR_SMS_DISPOSITION['FAILED'],
            COLOR_SMS_DISPOSITION['NO_ROUTE'],
            COLOR_SMS_DISPOSITION['UNAUTHORIZED'],
        ]
        extra_serie = {
            "tooltip": {"y_start": "", "y_end": " %"},
            "color_list": color_list
        }
        kwargs1 = {}
        kwargs1['resize'] = True
        sms_analytic_chartdata = {
            'x': xdata, 'y1': ydata, 'extra1': extra_serie,
            'kwargs1': kwargs1,
        }

    data = {
        'form': form,
        'SEARCH_TYPE': SEARCH_TYPE,
        'pb_active_contact_count': pb_active_contact_count,
        'reached_contact': reached_contact,
        'total_record': total_record,
        'select_graph_for': select_graph_for,
        'total_sms_count': total_sms_count,
        'total_unsent': total_unsent,
        'total_sent': total_sent,
        'total_delivered': total_delivered,
        'total_failed': total_failed,
        'total_no_route': total_no_route,
        'total_unauthorized': total_unauthorized,
        'unsent_color': COLOR_SMS_DISPOSITION['UNSENT'],
        'sent_color': COLOR_SMS_DISPOSITION['SENT'],
        'delivered_color': COLOR_SMS_DISPOSITION['DELIVERED'],
        'failed_color': COLOR_SMS_DISPOSITION['FAILED'],
        'no_route_color': COLOR_SMS_DISPOSITION['NO_ROUTE'],
        'unauthorized_color': COLOR_SMS_DISPOSITION['UNAUTHORIZED'],
        'final_chartcontainer': 'lineplusbarwithfocuschart_container',
        'final_chartdata': final_chartdata,
        'final_charttype': final_charttype,
        'final_extra': {
            'x_is_date': True,
            'x_axis_format': '%d %b %Y',
            'tag_script_js': True,
            'jquery_on_ready': False,
        },
        'sms_analytic_chartcontainer': 'piechart_container',
        'sms_analytic_charttype': sms_analytic_charttype,
        'sms_analytic_chartdata': sms_analytic_chartdata,
        'sms_analytic_extra': {
            'x_is_date': False,
            'x_axis_format': '',
            'tag_script_js': True,
            'jquery_on_ready': False,
        },
    }
    if on_index == 'yes':
        return data
    return render_to_response('mod_sms/sms_dashboard.html', data, context_instance=RequestContext(request))
示例#2
0
def customer_dashboard(request, on_index=None):
    """Customer dashboard gives the following information

        * 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')

    # 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()

    form = DashboardForm(request.user, request.POST or None)
    logging.debug('Got Campaign list')

    total_record = dict()
    total_duration_sum = 0
    total_billsec_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 form.is_valid():
            selected_campaign = request.POST['campaign']
            search_type = request.POST['search_type']

        end_date = datetime.utcnow().replace(tzinfo=utc)
        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
                tday = datetime.utcnow().replace(tzinfo=utc)
                start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0)\
                    .replace(tzinfo=utc) - relativedelta(days=1)
                end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999)\
                    .replace(tzinfo=utc) - 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'] == CALL_DISPOSITION.ANSWER or i[
                    'disposition'] == 'NORMAL_CLEARING':
                total_answered += i['starting_date__count']
            elif i['disposition'] == CALL_DISPOSITION.BUSY or i[
                    'disposition'] == 'USER_BUSY':
                total_busy += i['starting_date__count']
            elif i['disposition'] == CALL_DISPOSITION.NOANSWER or i[
                    'disposition'] == 'NO_ANSWER':
                total_not_answered += i['starting_date__count']
            elif i['disposition'] == CALL_DISPOSITION.CANCEL or i[
                    'disposition'] == 'ORIGINATOR_CANCEL':
                total_cancel += i['starting_date__count']
            elif i['disposition'] == CALL_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(Sum('billsec'))\
            .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 call in calls:
            total_duration_sum += call['duration__sum']
            total_billsec_sum += call['billsec__sum']
            if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
                ctime = datetime(int(call['starting_date'][0:4]),
                                 int(call['starting_date'][5:7]),
                                 int(call['starting_date'][8:10]),
                                 int(call['starting_date'][11:13]), 0, 0,
                                 0).replace(tzinfo=utc)
                if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
                    ctime = datetime(int(call['starting_date'][0:4]),
                                     int(call['starting_date'][5:7]),
                                     int(call['starting_date'][8:10]),
                                     int(call['starting_date'][11:13]),
                                     int(call['starting_date'][14:16]), 0,
                                     0).replace(tzinfo=utc)
            else:
                ctime = datetime(int(call['starting_date'][0:4]),
                                 int(call['starting_date'][5:7]),
                                 int(call['starting_date'][8:10]), 0, 0, 0,
                                 0).replace(tzinfo=utc)
            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': call['starting_date__count'],
                        'duration_sum': call['duration__sum'],
                        'duration_avg': float(call['duration__avg']),
                }

                calls_dict_with_min[int(ctime.strftime("%Y%m%d%H%M"))] =\
                    {
                        'call_count': call['starting_date__count'],
                        'duration_sum': call['duration__sum'],
                        'duration_avg': float(call['duration__avg']),
                }
            else:
                # Last 30 days option
                calls_dict[int(ctime.strftime("%Y%m%d"))] =\
                    {
                        'call_count': call['starting_date__count'],
                        'duration_sum': call['duration__sum'],
                        'duration_avg': float(call['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))).replace(tzinfo=utc)

                    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 hr
            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))).replace(tzinfo=utc)

                        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:
                # Default: Last 30 days option
                graph_day = datetime(
                    int(date.strftime("%Y")), int(date.strftime("%m")),
                    int(date.strftime("%d"))).replace(tzinfo=utc)
                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])

    # lineplusbarwithfocuschart
    final_charttype = "linePlusBarChart"
    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"
    kwargs1 = {}
    kwargs1['bar'] = True
    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,
        'kwargs1': kwargs1,
        'name2': 'Duration',
        'y2': ydata2,
        'extra2': extra_serie2,
    }

    # Contacts which are successfully called for running campaign
    reached_contact = 0
    if campaign_id_list:
        tday = datetime.utcnow().replace(tzinfo=utc)
        start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0,
                              0).replace(tzinfo=utc)
        end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59,
                            999999).replace(tzinfo=utc)
        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, 'y1': ydata}
    if total_call_count != 0:
        for i in CALL_DISPOSITION:
            xdata.append(i[0])

        # Y-axis order depend upon CALL_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
        }

    data = {
        'form': form,
        'campaign_phonebook_active_contact_count': pb_active_contact_count,
        'reached_contact': reached_contact,
        'total_duration_sum': total_duration_sum,
        'total_billsec_sum': total_billsec_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'],
        'CALL_DISPOSITION': CALL_DISPOSITION,
        'hangup_analytic_chartdata': hangup_analytic_chartdata,
        'hangup_analytic_charttype': hangup_analytic_charttype,
        'hangup_chartcontainer': 'piechart_container',
        'hangup_extra': {
            'x_is_date': False,
            'x_axis_format': '',
            'tag_script_js': True,
            'jquery_on_ready': True,
        },
        'final_chartdata': final_chartdata,
        'final_charttype': final_charttype,
        'final_chartcontainer': 'lineplusbarwithfocuschart_container',
        'final_extra': {
            'x_is_date': True,
            'x_axis_format': '%d %b %Y',
            'tag_script_js': True,
            'jquery_on_ready': True,
            'resize': True,
            'focus_enable': True,
        }
    }
    if on_index == 'yes':
        return data
    return render_to_response('frontend/dashboard.html',
                              data,
                              context_instance=RequestContext(request))
示例#3
0
def customer_dashboard(request, on_index=None):
    """Customer dashboard gives the following information

        * 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')

    # 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()

    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.utcnow().replace(tzinfo=utc)
        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
                tday = datetime.utcnow().replace(tzinfo=utc)
                start_date = datetime(tday.year, tday.month, tday.day,
                    0, 0, 0, 0).replace(tzinfo=utc) - relativedelta(days=1)
                end_date = datetime(tday.year, tday.month, tday.day,
                    23, 59, 59, 999999).replace(tzinfo=utc) - 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).replace(tzinfo=utc)
                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).replace(tzinfo=utc)
            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).replace(tzinfo=utc)
            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))).replace(tzinfo=utc)

                    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))).replace(tzinfo=utc)

                        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"))).replace(tzinfo=utc)
                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])

    # lineplusbarwithfocuschart
    final_charttype = "linePlusBarWithFocusChart"
    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"
    kwargs1 = {}
    kwargs1['bar'] = True
    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, 'kwargs1': kwargs1,
        'name2': 'Duration', 'y2': ydata2, 'extra2': extra_serie2,
    }

    # Contacts which are successfully called for running campaign
    reached_contact = 0
    if campaign_id_list:
        tday = datetime.utcnow().replace(tzinfo=utc)
        start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0).replace(tzinfo=utc)
        end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999).replace(tzinfo=utc)
        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, 'y1': ydata}
    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 = {
        'form': form,
        'dialer_setting_msg': user_dialer_setting_msg(request.user),
        '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,
        'hangup_chartcontainer': 'piechart_container',
        'hangup_extra': {
            'x_is_date': False,
            'x_axis_format': '',
            'tag_script_js': True,
            'jquery_on_ready': True,
        },
        'final_chartdata': final_chartdata,
        'final_charttype': final_charttype,
        'final_chartcontainer': 'lineplusbarwithfocuschart_container',
        'final_extra': {
            'x_is_date': True,
            'x_axis_format': '%d %b %Y',
            'tag_script_js': True,
            'jquery_on_ready': True,
            'resize': True,
        }
    }
    if on_index == 'yes':
        return data
    return render_to_response(template, data,
                              context_instance=RequestContext(request))
示例#4
0
def customer_dashboard(request, on_index=None):
    """Customer dashboard gives the following information

        * 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")

    # 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()

    form = DashboardForm(request.user, request.POST or None)
    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 form.is_valid():
            selected_campaign = request.POST["campaign"]
            search_type = request.POST["search_type"]

        end_date = datetime.utcnow().replace(tzinfo=utc)
        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
                tday = datetime.utcnow().replace(tzinfo=utc)
                start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0).replace(tzinfo=utc) - relativedelta(
                    days=1
                )
                end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999).replace(
                    tzinfo=utc
                ) - 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,
                ).replace(tzinfo=utc)
                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,
                    ).replace(tzinfo=utc)
            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,
                ).replace(tzinfo=utc)
            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)),
                    ).replace(tzinfo=utc)

                    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)),
                        ).replace(tzinfo=utc)

                        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"))
                ).replace(tzinfo=utc)
                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])

    # lineplusbarwithfocuschart
    final_charttype = "linePlusBarWithFocusChart"
    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"
    kwargs1 = {}
    kwargs1["bar"] = True
    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,
        "kwargs1": kwargs1,
        "name2": "Duration",
        "y2": ydata2,
        "extra2": extra_serie2,
    }

    # Contacts which are successfully called for running campaign
    reached_contact = 0
    if campaign_id_list:
        tday = datetime.utcnow().replace(tzinfo=utc)
        start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0).replace(tzinfo=utc)
        end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999).replace(tzinfo=utc)
        reached_contact = Subscriber.objects.filter(
            campaign_id__in=campaign_id_list, updated_date__range=(start_date, end_date)  # status=5,
        ).count()

    # PieChart
    hangup_analytic_charttype = "pieChart"
    xdata = []
    ydata = []
    hangup_analytic_chartdata = {"x": xdata, "y1": ydata}
    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}

    data = {
        "form": form,
        "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,
        "hangup_chartcontainer": "piechart_container",
        "hangup_extra": {"x_is_date": False, "x_axis_format": "", "tag_script_js": True, "jquery_on_ready": True},
        "final_chartdata": final_chartdata,
        "final_charttype": final_charttype,
        "final_chartcontainer": "lineplusbarwithfocuschart_container",
        "final_extra": {
            "x_is_date": True,
            "x_axis_format": "%d %b %Y",
            "tag_script_js": True,
            "jquery_on_ready": True,
            "resize": True,
        },
    }
    if on_index == "yes":
        return data
    return render_to_response("frontend/dashboard.html", data, context_instance=RequestContext(request))
示例#5
0
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])

    # 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()

    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_record': total_record,
        '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_others': total_others,
        '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'],
        'SEARCH_TYPE': SEARCH_TYPE,
        'VOIPCALL_DISPOSITION': VOIPCALL_DISPOSITION,
    }
    if on_index == 'yes':
        return data
    return render_to_response(template, data,
        context_instance=RequestContext(request))
示例#6
0
def sms_dashboard(request, on_index=None):
    """SMS dashboard gives the following information

        * No of SMSCampaigns for logged in user
        * Total phonebook contacts
        * Total SMSCampaigns contacts
        * Amount of contact reached today
        * Disposition of sms via pie chart
        * SMS count shown on graph by days/hours

    **Attributes**:

        * ``template`` - mod_sms/sms_dashboard.html
        * ``form`` - SMSDashboardForm
    """
    # All sms_campaign for logged in User
    sms_campaign_id_list = SMSCampaign.objects.values_list(
        'id', flat=True).filter(user=request.user).order_by('id')

    # Contacts count which are active and belong to those phonebook(s) which is
    # associated with all sms campaign
    pb_active_contact_count = Contact.objects.filter(
        phonebook__smscampaign__in=sms_campaign_id_list,
        status=CONTACT_STATUS.ACTIVE).count()

    form = SMSDashboardForm(request.user, request.POST or None)

    total_record = dict()
    total_sms_count = 0
    total_unsent = 0
    total_sent = 0
    total_delivered = 0
    total_failed = 0
    total_no_route = 0
    total_unauthorized = 0

    select_graph_for = 'sms count'  # default
    search_type = SEARCH_TYPE.D_Last_24_hours  # default Last 24 hours
    selected_sms_campaign = ''

    if sms_campaign_id_list:
        selected_sms_campaign = sms_campaign_id_list[
            0]  # default sms campaign id

    # selected_sms_campaign should not be empty
    if selected_sms_campaign:

        if form.is_valid():
            selected_sms_campaign = request.POST['smscampaign']
            search_type = request.POST['search_type']

        end_date = datetime.utcnow().replace(tzinfo=utc)
        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.utcnow().replace(tzinfo=utc)
                start_date = datetime(now.year, now.month, now.day, 0, 0, 0, 0).replace(tzinfo=utc) \
                    - relativedelta(days=1)
                end_date = datetime(now.year, now.month, now.day, 23, 59, 59, 999999).replace(tzinfo=utc) \
                    - 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 = {
            "send_date":
            "SUBSTR(CAST(send_date as CHAR(30)),1," + str(date_length) + ")"
        }

        # This calls list is used by pie chart
        list_sms = SMSMessage.objects.filter(
            sender=request.user,
            sms_campaign_id=selected_sms_campaign,
            send_date__range=(start_date, end_date))\
            .extra(select=select_data)\
            .values('send_date', 'status')\
            .annotate(Count('send_date'))\
            .order_by('send_date')

        for i in list_sms:
            # convert unicode date string into date
            if i['status'] == 'Unsent':
                total_unsent += i['send_date__count']
            elif i['status'] == 'Sent':
                total_sent += i['send_date__count']
            elif i['status'] == 'Delivered':
                total_delivered += i['send_date__count']
            elif i['status'] == 'Failed':
                total_failed += i['send_date__count']
            elif i['status'] == 'No_Route':
                total_no_route += i['send_date__count']
            else:
                total_unauthorized += i['send_date__count']  # Unauthorized

            total_sms_count += i['send_date__count']

        list_sms = SMSMessage.objects.filter(
            sender=request.user,
            sms_campaign_id=selected_sms_campaign,
            send_date__range=(start_date, end_date))\
            .extra(select=select_data).values('send_date')\
            .annotate(Count('send_date')).order_by('send_date')

        mintime = start_date
        maxtime = end_date
        sms_dict = {}
        sms_dict_with_min = {}

        for data in list_sms:
            if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
                ctime = datetime(int(data['send_date'][0:4]),
                                 int(data['send_date'][5:7]),
                                 int(data['send_date'][8:10]),
                                 int(data['send_date'][11:13]), 0, 0,
                                 0).replace(tzinfo=utc)
                if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
                    ctime = datetime(int(data['send_date'][0:4]),
                                     int(data['send_date'][5:7]),
                                     int(data['send_date'][8:10]),
                                     int(data['send_date'][11:13]),
                                     int(data['send_date'][14:16]), 0,
                                     0).replace(tzinfo=utc)
            else:
                ctime = datetime(int(data['send_date'][0:4]),
                                 int(data['send_date'][5:7]),
                                 int(data['send_date'][8:10]), 0, 0, 0,
                                 0).replace(tzinfo=utc)
            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:
                sms_dict[int(ctime.strftime("%Y%m%d%H"))] = {
                    'sms_count': data['send_date__count']
                }
                sms_dict_with_min[int(ctime.strftime("%Y%m%d%H%M"))] = {
                    'sms_count': data['send_date__count']
                }
            else:
                # Last 30 days option
                sms_dict[int(ctime.strftime("%Y%m%d"))] = {
                    'sms_count': data['send_date__count']
                }

        dateList = date_range(mintime, maxtime, q=search_type)

        i = 0
        total_record = {}
        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))).replace(tzinfo=utc)

                    dt = int(1000 * time.mktime(graph_day.timetuple()))
                    total_record[dt] = {'sms_count': 0}

                    if day_time in sms_dict.keys():
                        total_record[dt]['sms_count'] += sms_dict[day_time][
                            'sms_count']

            # 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))).replace(tzinfo=utc)

                        dt = int(1000 * time.mktime(graph_day.timetuple()))
                        total_record[dt] = {'sms_count': 0}

                        if hr_time in sms_dict_with_min.keys():
                            total_record[dt]['sms_count'] += sms_dict_with_min[
                                hr_time]['sms_count']

            else:
                # Last 30 days option
                graph_day = datetime(
                    int(date.strftime("%Y")), int(date.strftime("%m")),
                    int(date.strftime("%d"))).replace(tzinfo=utc)
                dt = int(1000 * time.mktime(graph_day.timetuple()))
                total_record[dt] = {'sms_count': 0}
                if inttime in sms_dict.keys():
                    total_record[dt]['sms_count'] += sms_dict[inttime][
                        'sms_count']

    # 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 = []
    for i in total_record:
        xdata.append(i[0])
        ydata.append(i[1]['sms_count'])

    tooltip_date = "%d %b %y %H:%M %p"
    extra_serie1 = {
        "tooltip": {
            "y_start": "",
            "y_end": " SMS"
        },
        "date_format": tooltip_date
    }

    final_chartdata = {
        'x': xdata,
        'name1': 'SMS',
        'y1': ydata,
        'extra1': extra_serie1,
    }

    # Contacts which are successfully messaged for running sms campaign
    reached_contact = 0
    if sms_campaign_id_list:
        now = datetime.utcnow().replace(tzinfo=utc)
        start_date = datetime(now.year, now.month, now.day, 0, 0, 0,
                              0).replace(tzinfo=utc)
        end_date = datetime(now.year, now.month, now.day, 23, 59, 59,
                            999999).replace(tzinfo=utc)
        sms_campaign_subscriber = SMSCampaignSubscriber.objects.filter(
            sms_campaign_id__in=sms_campaign_id_list,
            status=SMS_SUBSCRIBER_STATUS.COMPLETE,
            updated_date__range=(start_date, end_date)).count()
        reached_contact += sms_campaign_subscriber

    # PieChart
    sms_analytic_charttype = "pieChart"
    xdata = []
    ydata = []
    sms_analytic_chartdata = {'x': xdata, 'y1': ydata}

    if total_sms_count != 0:
        for i in SMS_MESSAGE_STATUS:
            xdata.append(i[0].upper())

        # Y-axis order depend upon SMS_MESSAGE_STATUS
        # 'UNSENT', 'SENT', 'DELIVERED', 'FAILED', 'NO_ROUTE', 'UNAUTHORIZED'
        ydata = [
            percentage(total_unsent, total_sms_count),
            percentage(total_sent, total_sms_count),
            percentage(total_delivered, total_sms_count),
            percentage(total_failed, total_sms_count),
            percentage(total_no_route, total_sms_count),
            percentage(total_unauthorized, total_sms_count),
        ]

        color_list = [
            COLOR_SMS_DISPOSITION['UNSENT'],
            COLOR_SMS_DISPOSITION['SENT'],
            COLOR_SMS_DISPOSITION['DELIVERED'],
            COLOR_SMS_DISPOSITION['FAILED'],
            COLOR_SMS_DISPOSITION['NO_ROUTE'],
            COLOR_SMS_DISPOSITION['UNAUTHORIZED'],
        ]
        extra_serie = {
            "tooltip": {
                "y_start": "",
                "y_end": " %"
            },
            "color_list": color_list
        }
        kwargs1 = {}
        kwargs1['resize'] = True
        sms_analytic_chartdata = {
            'x': xdata,
            'y1': ydata,
            'extra1': extra_serie,
            'kwargs1': kwargs1,
        }

    data = {
        'form': form,
        'SEARCH_TYPE': SEARCH_TYPE,
        'pb_active_contact_count': pb_active_contact_count,
        'reached_contact': reached_contact,
        'total_record': total_record,
        'select_graph_for': select_graph_for,
        'total_sms_count': total_sms_count,
        'total_unsent': total_unsent,
        'total_sent': total_sent,
        'total_delivered': total_delivered,
        'total_failed': total_failed,
        'total_no_route': total_no_route,
        'total_unauthorized': total_unauthorized,
        'unsent_color': COLOR_SMS_DISPOSITION['UNSENT'],
        'sent_color': COLOR_SMS_DISPOSITION['SENT'],
        'delivered_color': COLOR_SMS_DISPOSITION['DELIVERED'],
        'failed_color': COLOR_SMS_DISPOSITION['FAILED'],
        'no_route_color': COLOR_SMS_DISPOSITION['NO_ROUTE'],
        'unauthorized_color': COLOR_SMS_DISPOSITION['UNAUTHORIZED'],
        'final_chartcontainer': 'lineplusbarwithfocuschart_container',
        'final_chartdata': final_chartdata,
        'final_charttype': final_charttype,
        'final_extra': {
            'x_is_date': True,
            'x_axis_format': '%d %b %Y',
            'tag_script_js': True,
            'jquery_on_ready': False,
        },
        'sms_analytic_chartcontainer': 'piechart_container',
        'sms_analytic_charttype': sms_analytic_charttype,
        'sms_analytic_chartdata': sms_analytic_chartdata,
        'sms_analytic_extra': {
            'x_is_date': False,
            'x_axis_format': '',
            'tag_script_js': True,
            'jquery_on_ready': False,
        },
    }
    if on_index == 'yes':
        return data
    return render_to_response('mod_sms/sms_dashboard.html',
                              data,
                              context_instance=RequestContext(request))