def overview(request):
    """The Reports app landing page."""
    company = get_company_or_404(request)

    success = 'success' in request.POST
    reports = Report.objects.filter(owner=company).order_by("-created_on")
    report_count = reports.count()
    past_reports = reports[:10]
    states = OrderedDict(
        sorted((v, k) for k, v in location_data.states.inv.iteritems()))

    ctx = {
        "company": company,
        "success": success,
        "states": json.dumps(states),
        "past_reports": past_reports,
        "report_count": report_count
    }

    if request.is_ajax():
        response = HttpResponse()
        html = render_to_response('myreports/includes/report_overview.html',
                                  ctx, RequestContext(request)).content
        response.content = html
        return response

    return render_to_response('myreports/reports.html', ctx,
                              RequestContext(request))

def partner_library(request):
    company = get_company_or_404(request)

    if request.is_ajax():
        partners = filter_partners(request, True)
        paginator = add_pagination(request, partners)
        ctx = {
            'partners': paginator,
            'on_page': 'partner_library'
        }
        response = HttpResponse()
        html = render_to_response('mypartners/includes/partner_column.html',
                                  ctx, RequestContext(request))
        response.content = html.content
        return response

    partners = filter_partners(request, True)
    paginator = add_pagination(request, partners)

    ctx = {
        'company': company,
        'view_name': 'PRM',
        'partners': paginator
    }

    return render_to_response('mypartners/partner_library.html', ctx,
                              RequestContext(request))

    def get(self, *args, **kwargs):
        company = get_company_or_404(self.request)
        if not can_modify(self.request.user, company, kwargs,
                          "update product", "create product"):
            return MissingActivity()

        return super(ProductFormView, self).get(*args, **kwargs)

def view_invoice(request, purchased_product):
    company = get_company_or_404(request)
    kwargs = {
        'pk': purchased_product,
    }
    if 'posting/admin' in request.get_full_path():
        kwargs['product__owner'] = company
    else:
        kwargs['owner'] = company
    product = get_object_or_404(PurchasedProduct, **kwargs)
    invoice = product.invoice
    data = {
        'company': company,
        'purchased_product': product,
        'invoice': invoice,
        'purchases': invoice.invoiced_products.all()
    }
    # m is used to render success message. Also, 'm' for shorter url query set.
    if 'm' in request.GET:
        data.update({'alert': 'success',
                     'alert_message': '<b>Success!</b>  You should receive '
                                      'this invoice shortly.'
                     })
    return render_to_response('postajob/view_invoice.html',
                              data, RequestContext(request))

    def post(self, *args, **kwargs):
        company = get_company_or_404(self.request)
        if not can_modify(self.request.user, company, kwargs,
                          "update job", "create job"):
            return MissingActivity()

        return super(JobFormView, self).post(*args, **kwargs)

        def wrap(request, *args, **kwargs):
            invalid_user = any([not request.user, not request.user.pk,
                                request.user.is_anonymous()])

            if invalid_user:
                path = request.path
                qs = request.META.get('QUERY_STRING')
                next_url = request.get_full_path()

                return HttpResponseRedirect(reverse('login')+'?next='+next_url)

            # get_company isn't reliable, see PD-2260 on JIRA
            company = get_company_or_404(request)

            # the app_access we need, determined by the activities passed in
            required_access = Activity.objects.filter(
                name__in=activities).required_access

            # company should have at least the access required by the view
            has_access = set(required_access).issubset(company.enabled_access)

            # the user should have at least the activities required by the view
            has_activities = compare(
                activities, request.user.get_activities(company))

            if not has_access:
                return access_callback(request)
            elif not has_activities:
                return activity_callback(request)
            else:
                return view_func(request, *args, **kwargs)

        def wrap(request, *args, **kwargs):
            #TODO: Remove this logic once feature is rolled out. for the
            #      moment, we only want this decorator factory to work in QC
            #      and Staging.
            if not settings.DEBUG:
                return view_func(request, *args, **kwargs)

            company = get_company_or_404(request)
            # the app_access we have, determined by the current company
            company_access = company.app_access.values_list('name', flat=True)
            user_activities = request.user.roles.values_list(
                'activities__name', flat=True)

            # the app_access we need, determined by the activities passed in
            required_access = AppAccess.objects.filter(
                activity__name__in=activities).values_list(
                    'name', flat=True)

            # company should have at least the access required by the view
            if not bool(company_access) or not set(required_access).issubset(
                    company_access):
                return access_callback()
            # the user should have at least the activities required by the view
            elif not bool(user_activities) or not set(activities).issubset(
                    user_activities):
                return activity_callback()
            else:
                return view_func(request, *args, **kwargs)

def prm(request):
    """
    Partner Relationship Manager

    """
    company = get_company_or_404(request)

    partners = filter_partners(request)
    paginator = add_pagination(request, partners) if partners else None

    if request.is_ajax():
        ctx = {"partners": paginator, "on_page": "prm", "ajax": "true"}
        response = HttpResponse()
        html = render_to_response("mypartners/includes/partner_column.html", ctx, RequestContext(request))
        response.content = html.content
        return response

    ctx = {
        "has_partners": True if paginator else False,
        "partners": paginator,
        "company": company,
        "user": request.user,
        "partner_ct": ContentType.objects.get_for_model(Partner).id,
        "view_name": "PRM",
    }

    return render_to_response("mypartners/prm.html", ctx, RequestContext(request))

def edit_item(request):
    """ Contact/Partner Form.

        If the user reaches this form thorugh the `edit_contact` URL and a
        valid partner_id is provided, they are presented with the "Add Partner"
        form.

        Conversely, if the user reaches this form through the `create_partner`
        URL, they are presented with "Add Contact" form. If a valid `item_id`
        is passed, we preload the form with that contact's information.
    """
    try:
        partner_id = int(request.REQUEST.get("partner") or 0)
        item_id = int(request.REQUEST.get('id') or 0)
        content_id = int(request.REQUEST.get('ct') or 0)
    except ValueError:
        raise Http404

    company = get_company_or_404(request)
    partners = []
    contacts = []
    if partner_id and request.path == reverse('edit_contact'):
        partner = get_object_or_404(company.partner_set.all(), id=partner_id)
        if item_id:
            item = get_object_or_404(Contact, partner=partner, pk=item_id)
            form = ContactForm(instance=item, auto_id=False)
        else:
            contacts = list(partner.contact_set.filter(
                archived_on__isnull=True).values(
                    'pk', 'name', 'email', 'phone'))
            form = ContactForm()
            item = None
    elif request.path == reverse('create_partner'):
        partner = None
        if item_id:
            item = get_object_or_404(Partner, pk=item_id)
            form = PartnerForm(instance=item)
        else:
            partners = list(company.partner_set.values(
                'pk', 'name', 'uri'))
            item = None
            form = NewPartnerForm()
    else:
        raise Http404

    ctx = {
        'form': form,
        'partner': partner,
        'partners': json.dumps(partners),
        'company': company,
        'contact': item,
        'contacts': json.dumps(contacts),
        'content_id': content_id,
        'view_name': 'PRM',
    }
    if item_id:
        ctx['locations'] = Contact.objects.get(pk=item_id).locations.all()

    return render_to_response('mypartners/edit_item.html', ctx,
                              RequestContext(request))

def tag_color(request):
    if request.method == "GET":
        company = get_company_or_404(request)
        name = request.GET.get("name")
        data = {"name": name}
        tag_color = list(Tag.objects.from_search(company, data).values_list("hex_color", flat=True))
        return HttpResponse(json.dumps(tag_color))

def prm(request):
    """
    Partner Relationship Manager

    """
    company = get_company_or_404(request)

    partners = filter_partners(request)
    paginator = add_pagination(request, partners) if partners else None

    if request.is_ajax():
        ctx = {
            'partners': paginator,
            'on_page': 'prm',
            'ajax': 'true',
        }
        response = HttpResponse()
        html = render_to_response('mypartners/includes/partner_column.html',
                                  ctx, RequestContext(request))
        response.content = html.content
        return response

    ctx = {
        'has_partners': True if paginator else False,
        'partners': paginator,
        'company': company,
        'user': request.user,
        'partner_ct': ContentType.objects.get_for_model(Partner).id,
        'view_name': 'PRM',
    }

    return render_to_response('mypartners/prm.html', ctx,
                              RequestContext(request))

def edit_partner_tag(request):
    company = get_company_or_404(request)

    if request.POST:
        data = {'id': request.GET.get('id')}
        tag = Tag.objects.from_search(company, data).first()
        form = TagForm(instance=tag, auto_id=False, data=request.POST)

        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('partner_tagging'))
        else:
            ctx = {
                'company': company,
                'form': form,
                'tag': tag
            }
            return render_to_response('mypartners/edit_tag.html', ctx,
                                      RequestContext(request))
    else:
        data = {'id': request.GET.get('id')}
        tag = Tag.objects.from_search(company, data).first()
        form = TagForm(instance=tag, auto_id=False)

        ctx = {
            'company': company,
            'tag': tag,
            'form': form
        }
        return render_to_response('mypartners/edit_tag.html', ctx,
                                  RequestContext(request))

def refresh_report(request):
    company = get_company_or_404(request)
    report_id = request.POST['report_id']
    report = get_object_or_404(DynamicReport, owner=company, pk=report_id)
    report.regenerate()
    return HttpResponse(content_type='application/json',
                        content='{}')

def delete_prm_item(request):
    """
    Deletes Partners and Contacts

    """
    company = get_company_or_404(request)
    partner_id = request.REQUEST.get('partner')
    partner_id = get_int_or_none(partner_id)

    item_id = request.REQUEST.get('id')
    contact_id = get_int_or_none(item_id)

    content_id = request.REQUEST.get('ct')
    content_id = get_int_or_none(content_id)

    if content_id == ContentType.objects.get_for_model(Partner).id:
        partner = get_object_or_404(Partner, id=partner_id, owner=company)
        log_change(partner, None, request.user, partner, partner.name,
                   action_type=DELETION)
        partner.archive()
        return HttpResponseRedirect(reverse('prm') + '?company=' +
                                    str(company.id))
    elif content_id == ContentType.objects.get_for_model(ContactRecord).id:
        contact_record = get_object_or_404(ContactRecord, partner=partner_id,
                                           id=item_id)
        partner = get_object_or_404(Partner, id=partner_id, owner=company)
        # At one point, contacts could be deleted. The previous functionality
        # at this location couldn't handle that, accessing
        # contact_record.contact.name directly. Chaining getattr may not be
        # pretty but it ensures that we will never be accessing nonexistent
        # attributes.
        contact_name = getattr(getattr(contact_record,
                                       'contact',
                                       None),
                               'name',
                               '')
        log_change(contact_record, None, request.user, partner,
                   contact_name, action_type=DELETION)
        contact_record.archive()
        return HttpResponseRedirect(reverse('partner_records')+'?company=' +
                                    str(company.id)+'&partner=' +
                                    str(partner_id))
    elif content_id == ContentType.objects.get_for_model(PartnerSavedSearch).id:
        saved_search = get_object_or_404(PartnerSavedSearch, id=item_id)
        partner = get_object_or_404(Partner, id=partner_id, owner=company)
        log_change(saved_search, None, request.user, partner,
                   saved_search.email, action_type=DELETION)
        saved_search.delete()
        return HttpResponseRedirect(reverse('partner_searches')+'?company=' +
                                    str(company.id)+'&partner=' +
                                    str(partner_id))
    else:
        partner = get_object_or_404(Partner, id=partner_id, owner=company)
        contact = get_object_or_404(Contact, id=contact_id)
        log_change(contact, None, request.user, partner, contact.name,
                   action_type=DELETION)
        contact.archive()
        return HttpResponseRedirect(reverse('partner_details')+'?company=' +
                                    str(company.id)+'&partner=' +
                                    str(partner_id))

def run_dynamic_report(request):
    """Run a dynamic report.

    report_data_id: Report Presentation ID
    name: name of report
    filter_spec: JSON string with user filter to use

    response: {'id': new dynamic report id}
    """
    validator = ApiValidator()
    company = get_company_or_404(request)
    report_data_id = request.POST['report_data_id']
    name = request.POST.get('name', '')
    if not name:
        validator.note_field_error("name", "Report name must not be empty.")
    filter_spec = request.POST.get('filter', '{}')
    report_data = ReportTypeDataTypes.objects.get(id=report_data_id)

    if validator.has_errors():
        return validator.build_error_response()

    report = DynamicReport.objects.create(
        report_data=report_data,
        filters=filter_spec,
        name=name,
        owner=company)

    report.regenerate()

    data = {'id': report.id}
    return HttpResponse(content_type='application/json',
                        content=json.dumps(data))

def old_report_preview(request):
    company = get_company_or_404(request)
    report_id = request.GET.get('id', 0)
    report = get_object_or_404(DynamicReport, pk=report_id)
    report_type = report.report_data.report_type.report_type

    if report_type == 'communication-records':
        driver = ds_json_drivers['comm_records']
        ds_filter = driver.build_filter(report.filters)
        records = driver.ds.filtered_query_set(company, ds_filter)

        ctx = {
            'emails': records.emails,
            'calls': records.calls,
            'searches': records.searches,
            'meetings': records.meetings,
            'applications': records.applications,
            'interviews': records.interviews,
            'hires': records.hires,
            'communications': records.communication_activity.count(),
            'referrals': records.referrals,
            'contacts': list(records.contacts),
        }
        return HttpResponse(content_type='application/json',
                            content=json.dumps(ctx))
    elif report_type in ['contacts', 'partners']:
        return HttpResponse(content_type='application/json',
                            content=report.json)

def help_api(request):
    """Get help for a partially filled out field.

    report_data_id: Report Data ID
    filter: JSON string with user filter to use
    field: Name of field to get help for
    partial: Data entered so far

    response: [{'value': data, 'display': data to display}]
    """
    company = get_company_or_404(request)
    request_data = request.POST
    report_data_id = request_data['report_data_id']
    filter_spec = request_data['filter']
    field = request_data['field']
    partial = request_data['partial']

    report_data = ReportTypeDataTypes.objects.get(id=report_data_id)
    datasource = report_data.report_type.datasource
    driver = ds_json_drivers[datasource]

    result = driver.help(company, filter_spec, field, partial)

    return HttpResponse(content_type="application/json",
                        content=json.dumps(result))

def api_get_users(request):
    """
    GET /manage-users/api/users/
    Retrieves all users associated with a company

    """
    company = get_company_or_404(request)
    users = User.objects.select_related('roles').filter(roles__company=company)
    ctx = {}
    for user in users:
        last_invitation = ""
        if not user.is_verified:
            invitations = Invitation.objects.filter(
                invitee_email=user.email).order_by("-invited")
            if invitations:
                last_invitation = invitations.first().invited.strftime(
                    "%Y-%m-%d")

        ctx[user.pk] = {
            'email': user.email,
            'isVerified': user.is_verified,
            'lastInvitation': last_invitation,
            'roles': list(user.roles.filter(company=company).values_list(
                'name', flat=True))
        }

    return HttpResponse(json.dumps(ctx), content_type="application/json")

def tag_color(request):
    if request.method == 'GET':
        company = get_company_or_404(request)
        name = request.GET.get('name')
        colors = list(Tag.objects.filter(
            company=company, name=name).values_list('hex_color', flat=True))
        return HttpResponse(json.dumps(colors))

def tag_names(request):
    if request.method == "GET":
        company = get_company_or_404(request)
        value = request.GET.get("value")
        data = {"name": value}
        tag_names = list(Tag.objects.from_search(company, data).values_list("name", flat=True))
        tag_names = sorted(tag_names, key=lambda x: x if not x.startswith(value) else "-" + x)
        return HttpResponse(json.dumps(tag_names))