def get_context_data(self, **kwargs): context = super(CompanyProfileFormView, self).get_context_data( **kwargs) company = get_company(self.request) context.setdefault('company', company) return context
def view_request(request, pk, model=None): template = 'postajob/request/{model}.html' company = get_company(request) model = model or Request request_kwargs = { 'pk': pk, 'owner': company } request_made = get_object_or_404(model, **request_kwargs) if model == Request: activity = "read request" request_object = request_made.request_object() else: activity = "read offline purchase" request_object = request_made content_type = ContentType.objects.get_for_model(type(request_object)) data = { 'company': company, 'content_type': content_type, 'object': request_object, 'request_obj': request_made, } if not request.user.can(company, activity): return MissingActivity() return render_to_response(template.format(model=content_type.model), data, RequestContext(request))
def product_listing(request): site = settings.SITE company = get_company(request) # Get all site packages and products for a site. site_packages = site.sitepackage_set.all() products = Product.objects.filter(package__sitepackage__in=site_packages) # Group products by the site package they belong to. groupings = set() for product in products: profile = get_object_or_none(CompanyProfile, company=product.owner) if product.cost < 0.01 or (profile and profile.authorize_net_login and profile.authorize_net_transaction_key): groupings = groupings.union( set(product.productgrouping_set.filter(is_displayed=True, products__isnull=False))) # Sort the grouped packages by the specified display order. groupings = sorted(groupings, key=lambda grouping: grouping.display_order) return render_to_response('postajob/%s/package_list.html' % settings.PROJECT, {'product_groupings': groupings, 'company': company}, RequestContext(request))
def has_access(feature): """ Decorator that signifies which feature permissions are required in order to access the view. Inputs: :feature: Name of feature to check permissiosn for. Returns: A decorator that raises a 404 if the supplied feature's permission requirements are not met. If no permissions are specified for the given feature, it is assumed that the feature should never be available. """ # mapping from feature name to a list of conditions to be met. conditions = { 'prm': [ # not a member company lambda req: not getattr(get_company(req), 'prm_access', False) ] } return not_found_when( condition=lambda req: all(c(req) for c in conditions.get(feature, [])), message="Must have %s access to proceed." % feature, feature=feature, enabled=False)
def view_request(request, pk, model=None): template = 'postajob/{project}/request/{model}.html' company = get_company(request) model = model or Request request_kwargs = { 'pk': pk, 'owner': company } request_made = get_object_or_404(model, **request_kwargs) if model == Request: request_object = request_made.request_object() else: request_object = request_made content_type = ContentType.objects.get_for_model(type(request_object)) data = { 'company': company, 'content_type': content_type, 'object': request_object, 'request_obj': request_made, } if not data['object'].user_has_access(request.user): raise Http404 return render_to_response(template.format(project=settings.PROJECT, model=content_type.model), data, RequestContext(request))
def purchasedmicrosite_admin_overview(request): company = get_company(request) if settings.SITE: sites = settings.SITE.postajob_site_list() products = Product.objects.filter_by_sites(sites) purchased = PurchasedProduct.objects.filter_by_sites(sites) groupings = ProductGrouping.objects.filter_by_sites(sites) offline_purchases = OfflinePurchase.objects.filter_by_sites(sites) requests = Request.objects.filter_by_sites(sites) else: products = Product.objects.all() purchased = PurchasedProduct.objects.all() groupings = ProductGrouping.objects.all() offline_purchases = OfflinePurchase.objects.all() requests = Request.objects.all() data = { 'products': products.filter(owner=company)[:3], 'product_groupings': groupings.filter(owner=company)[:3], 'purchased_products': purchased.filter(product__owner=company)[:3], 'offline_purchases': offline_purchases.filter(owner=company)[:3], 'requests': requests.filter(owner=company)[:3], 'company': company } return render_to_response('postajob/%s/admin_overview.html' % settings.PROJECT, data, RequestContext(request))
def view_request(request, pk, model=None): template = 'postajob/request/{model}.html' company = get_company(request) model = model or Request request_kwargs = {'pk': pk, 'owner': company} request_made = get_object_or_404(model, **request_kwargs) if model == Request: activity = "read request" request_object = request_made.request_object() else: activity = "read offline purchase" request_object = request_made content_type = ContentType.objects.get_for_model(type(request_object)) data = { 'company': company, 'content_type': content_type, 'object': request_object, 'request_obj': request_made, } if not request.user.can(company, activity): return MissingActivity() return render_to_response(template.format(model=content_type.model), data, RequestContext(request))
def get_context_data(self, **kwargs): context = super(CompanyProfileFormView, self).get_context_data(**kwargs) company = get_company(self.request) context.setdefault('company', company) return context
def candidate_information(request): """ Sends user info, primary name, and searches to candidate_information.html. Gathers the employer's (request.user) companies and microsites and puts the microsites' domains in a list for further checking and logic, see helpers.py. """ user_id = get_int_or_none(request.REQUEST.get('user')) company = get_company(request) if not user_id or not company: raise Http404 # user gets pulled out from id try: candidate = User.objects.get(id=user_id) except User.DoesNotExist: raise Http404 if not candidate.opt_in_employers: raise Http404 urls = saved_searches(request.user, company, candidate) actions = analytics(request.user, company, candidate) actions = get_analytics_counts(actions) if not urls and not actions: raise Http404 manager = PrimaryNameProfileUnitManager(order=['employmenthistory', 'education', 'militaryservice']) models = manager.displayed_units(candidate.profileunits_set.all()) primary_name = getattr(manager, 'primary_name', 'Name not given') coming_from = {'path': 'view'} searches = candidate.savedsearch_set.all() searches = [search for search in searches if get_domain(search.feed).lower() in urls] modified_url = remove_param_from_url(request.build_absolute_uri(), 'user') query_string = "?%s" % urlparse(modified_url).query data_dict = { 'user_info': models, 'company_id': company.pk, 'primary_name': primary_name, 'the_user': candidate, 'searches': searches, 'coming_from': coming_from, 'query_string': query_string, 'actions': actions, } return render_to_response('mydashboard/candidate_information.html', data_dict, RequestContext(request))
def access_callback(request): """ Default callback used when appropriate app-level access isn't found. """ company = get_company(request) raise Http404("%s doesn't have sufficient app-level access." % ( company.name))
def resend_invoice(request, pk): company = get_company(request) product = PurchasedProduct.objects.get(pk=pk, product__owner=company) product.invoice.send_invoice_email(send_to_admins=False, other_recipients=[request.user.email]) data = {'purchased_product': pk} redirect_url = reverse('admin_view_invoice', kwargs=data) + '?m=success' return HttpResponseRedirect(redirect_url)
def access_callback(request): """ Default callback used when appropriate app-level access isn't found. """ company = get_company(request) raise MissingAppLevelAccess( "%s doesn't have sufficient app-level access." % (company.name))
def admin_offlinepurchase(request): company = get_company(request) sites = settings.SITE.postajob_site_list() purchases = OfflinePurchase.objects.filter_by_sites(sites) data = { 'offline_purchases': purchases.filter(owner=company), 'company': company, } return render_to_response('postajob/offlinepurchase.html', data, RequestContext(request))
def activities(request): """ Returns the activities a user can perform for the currently selected company. """ company = get_company(request) if not request.user.is_anonymous() and request.user.pk: return {"activities": request.user.get_activities(company)} return {"activities": []}
def admin_purchasedproduct(request): company = get_company(request) sites = settings.SITE.postajob_site_list() purchases = PurchasedProduct.objects.filter_by_sites(sites).filter( product__owner=company) data = { 'company': company, 'active_products': purchases.filter(expiration_date__gte=date.today()), 'expired_products': purchases.filter(expiration_date__lt=date.today()), } return render_to_response('postajob/purchasedproduct.html', data, RequestContext(request))
def admin_request(request): company = get_company(request) sites = settings.SITE.postajob_site_list() requests = Request.objects.filter_by_sites(sites) data = { 'company': company, 'pending_requests': requests.filter(owner=company, action_taken=False), 'processed_requests': requests.filter(owner=company, action_taken=True) } return render_to_response('postajob/request.html', data, RequestContext(request))
def admin_groupings(request): company = get_company(request) if settings.SITE: sites = settings.SITE.postajob_site_list() grouping = ProductGrouping.objects.filter_by_sites(sites) else: grouping = ProductGrouping.objects.all() data = { 'product_groupings': grouping.filter(owner=company), 'company': company, } return render_to_response('postajob/productgrouping.html', data, RequestContext(request))
def prm_worthy(request): """ Makes sure the User is worthy enough to use PRM. """ company = get_company(request) if company is None: raise Http404("mypartners.helpers.prm_worthy: no company") partner_id = get_int_or_none(request.REQUEST.get('partner')) partner = get_object_or_404(company.partner_set, id=partner_id) return company, partner, request.user
def prm_worthy(request): """ Makes sure the User is worthy enough to use PRM. """ company = get_company(request) if company is None: raise Http404 partner_id = get_int_or_none(request.REQUEST.get('partner')) partner = get_object_or_404(company.partner_set, id=partner_id) return company, partner, request.user
def jobs_overview(request): if settings.SITE: sites = settings.SITE.postajob_site_list() jobs = Job.objects.filter_by_sites(sites) else: jobs = Job.objects.all() company = get_company(request) data = { 'company' : company, 'jobs': jobs.filter(owner=company, purchasedjob__isnull=True), } return render_to_response('postajob/%s/jobs_overview.html' % settings.PROJECT, data, RequestContext(request))
def process_admin_request(request, pk, approve=True, block=False): """ Marks a Request as action taken on it and sets the corresponding object's approval status. Assumes the object has an is_approved field. Adds the requesting user (if one exists) to the company's block list if the block parameter is True. """ company = get_company(request) request_made = get_object_or_404(Request, pk=pk, owner=company) content_type = request_made.content_type request_object = request_made.request_object() if request_object and request_object.user_has_access(request.user): if block and request_object.created_by: # Block the user that initiated this request # and deny all of that user's outstanding requests profile, _ = CompanyProfile.objects.get_or_create( company=company) profile.blocked_users.add(request_object.created_by) # Since Requests and the objects associated with them are related # using a fake foreign key, we have to do multiple queries. We # could potentially get away with only the first two, but the last # one is included just to be safe. request_objects = content_type.model_class().objects.filter( created_by=request_object.created_by, owner=request_object.owner, is_approved=False) requests = Request.objects.filter( object_id__in=request_objects.values_list('pk', flat=True), action_taken=False).values_list('object_id', flat=True) request_objects = request_objects.filter( pk__in=requests) reason = request.REQUEST.get('block-reason', '') requests.update(action_taken=True, deny_reason=reason) request_objects.update(is_approved=False) else: request_object.is_approved = approve request_object.save() if not approve: request_made.deny_reason = request.REQUEST.get('deny-reason', '') request_made.action_taken = True request_made.save() return redirect('request')
def admin_products(request): company = get_company(request) if settings.SITE: sites = settings.SITE.postajob_site_list() products = Product.objects.filter_by_sites(sites) else: products = Product.objects.all() data = { 'products': products.filter(owner=company), 'company': company, } return render_to_response('postajob/%s/products.html' % settings.PROJECT, data, RequestContext(request))
def __init__(self, *args, **kwargs): request = kwargs.pop("request") super(EventFieldForm, self).__init__(*args, **kwargs) setattr(self, "request", request) initial = self.initial.get("field") choices = [("", "---------")] if initial: # It doesn't matter that we aren't actually retrieving the full # choice list at this point in time. This is just to preserve the # current value - the full list is retrieved via ajax on load. choices.append((initial, initial)) self.fields["field"] = NoValidationChoiceField(choices=choices) if not request.user.is_superuser: company = get_company(request) queryset = EmailTemplate.objects.filter(Q(owner=company) | Q(owner__isnull=True)) self.fields["email_template"].queryset = queryset
def set_object(self, *args, **kwargs): if resolve(self.request.path).url_name == self.add_name: if not self.product.can_post_more(): # If more jobs can't be posted to the project, don't allow # the user to access the add view. raise Http404 else: company = get_company(self.request) if company and hasattr(company, 'companyprofile'): if self.request.user in company.companyprofile.blocked_users.all(): # If the current user has been blocked by the company # that we are trying to post a job to, don't allow # the user to access the add view. raise Http404 return super(PurchasedJobFormView, self).set_object(*args, **kwargs)
def process_admin_request(request, pk, approve=True, block=False): """ Marks a Request as action taken on it and sets the corresponding object's approval status. Assumes the object has an is_approved field. Adds the requesting user (if one exists) to the company's block list if the block parameter is True. """ company = get_company(request) request_made = get_object_or_404(Request, pk=pk, owner=company) content_type = request_made.content_type request_object = request_made.request_object() if request_object and request_object.user_has_access(request.user): if block and request_object.created_by: # Block the user that initiated this request # and deny all of that user's outstanding requests profile, _ = CompanyProfile.objects.get_or_create(company=company) profile.blocked_users.add(request_object.created_by) # Since Requests and the objects associated with them are related # using a fake foreign key, we have to do multiple queries. We # could potentially get away with only the first two, but the last # one is included just to be safe. request_objects = content_type.model_class().objects.filter( created_by=request_object.created_by, owner=request_object.owner, is_approved=False) requests = Request.objects.filter( object_id__in=request_objects.values_list('pk', flat=True), action_taken=False).values_list('object_id', flat=True) request_objects = request_objects.filter(pk__in=requests) reason = request.REQUEST.get('block-reason', '') requests.update(action_taken=True, deny_reason=reason) request_objects.update(is_approved=False) else: request_object.is_approved = approve request_object.save() if not approve: request_made.deny_reason = request.REQUEST.get( 'deny-reason', '') request_made.action_taken = True request_made.save() return redirect('request')
def dispatch(self, *args, **kwargs): """ Determine and set which product is attempting to be purchased. """ # The add url also has the pk for the product they're attempting # to purchase. self.product = get_object_or_404(self.purchase_model, pk=kwargs.get('product')) # Set the display name based on the model self.display_name = self.display_name.format(product=self.product) # If the product is free but the current user has no companies or an # un-filled-out profile, use the product form that only gets company # information. if self.product.cost < 0.01: company = get_company(self.request) profile = get_object_or_none(CompanyProfile, company=company) if company and profile and profile.address_line_one: invoice = Invoice.objects.create( transaction_type=Invoice.FREE, first_name=self.request.user.first_name, last_name=self.request.user.last_name, address_line_one=profile.address_line_one, address_line_two=profile.address_line_two, city=profile.city, state=profile.state, country=profile.country, zipcode=profile.zipcode, owner=self.product.owner, ) purchase_kwargs = { 'product': self.product, 'invoice': invoice, 'owner': company, 'paid': True, } PurchasedProduct.objects.create(**purchase_kwargs) return redirect(self.success_url) else: self.display_name = self.product self.form_class = PurchasedProductNoPurchaseForm return super(PurchasedProductFormView, self).dispatch(*args, **kwargs)
def blocked_user_management(request): """ Displays blocked users (if any) for the current company as well as an unblock link. """ company = get_company(request) if not company: raise Http404 profile = CompanyProfile.objects.get_or_create(company=company)[0] blocked_users = profile.blocked_users.all() data = { 'company': company, 'blocked_users': blocked_users } return render_to_response('postajob/%s/blocked_user_management.html' % settings.PROJECT, data, RequestContext(request))
def purchasedproducts_overview(request): company = get_company(request) if settings.SITE: sites = settings.SITE.postajob_site_list() products = PurchasedProduct.objects.filter_by_sites(sites) jobs = PurchasedJob.objects.filter_by_sites(sites) else: products = Product.objects.all() jobs = PurchasedJob.objects.all() products = products.filter(owner=company) data = { 'company': company, 'jobs': jobs.filter(owner=company), 'active_products': products.filter(expiration_date__gte=date.today()), 'expired_products': products.filter(expiration_date__lt=date.today()), } return render_to_response('postajob/%s/purchasedproducts_overview.html' % settings.PROJECT, data, RequestContext(request))
def wrap(request, *args, **kwargs): # If the user is not logged in, redirect them to the login page # with this url as the next url. if request.user.is_anonymous(): params = {'next': request.get_full_path()} next_url = build_url(reverse('login'), params) return HttpResponseRedirect(next_url) # If the user is logged in, but they aren't a CompanyUser or they # are a CompanyUser, but their current Company doesn't have # perm_field access, return a 404. company = get_company(request) if not company or (perm_field and not getattr(company, perm_field, False)): raise Http404 return view_func(request, *args, **kwargs)
def unblock_user(request, pk): """ Unblocks a given user that has previously been blocked from posting jobs. Inputs: :pk: ID of user that has been blocked """ company = get_company(request) if not company: raise Http404 profile = company.companyprofile if profile: try: user = User.objects.get(pk=pk) except User.DoesNotExist: pass else: profile.blocked_users.remove(user) return redirect(reverse('blocked_user_management'))
def wrap(request, *args, **kwargs): # If the user is not logged in, redirect them to the login page # with this url as the next url. if request.user.is_anonymous(): params = {'next': request.get_full_path()} next_url = build_url(reverse('login'), params) return HttpResponseRedirect(next_url) # If the user is logged in, but they aren't an admin or they # are an admin , but their current Company doesn't have # perm_field access, return a 404. company = get_company(request) if not company or (perm_field and not getattr(company, perm_field, False)): raise Http404("universal.decorators.company_has_access: " "company doesn't exist or doesn't have " "{perm} permissions".format(perm=perm_field)) return view_func(request, *args, **kwargs)
def get_purchasedjob_add_link(context): """ Generates add links for creating PurchasedJobs. If the user is blocked, the link is replaced with a modal telling them so. """ request = context['request'] company = get_company(request) # Add 'blocked' context variable; determines if we are going to add a real # link or a modal when rendering the template. context['blocked'] = request.user in company.companyprofile.blocked_users.all() if 'purchased_product' not in context: # This is called from both the company owner side and the job poster # side. The context variable for the current purchased product is # different between the two. context['purchased_product'] = context['product'] link = render_to_string('postajob/includes/purchasedjob_add_link.html', context) return mark_safe(link)
def get_context_data(self, **kwargs): kwargs['company'] = get_company(self.request) kwargs['prevent_delete'] = self.prevent_delete return super(PostajobModelFormMixin, self).get_context_data(**kwargs)
def get_menus(context): """ Returns menu items used in the topbar. Each top-level item is a 'menu' (eg. "Employers"), where as everything below those is a submenu (eg. "PRM"). """ # have to use hard coded urls since the named views don't exist on # microsites. url = lambda path: settings.ABSOLUTE_URL + path request = context.get("request") company = get_company(request) user = context.get("user") new_messages = context.get("new_messages") impersonating = context.get("impersonating") # menu item cant be generated for a user who isn't logged in if not user or not user.pk or user.is_anonymous(): return [] if new_messages: message_submenus = [{ "id": info.message.pk, "href": url("message/inbox?message=%s" % info.message.pk), "label": "%s - %s" % (info.message.start_on.date(), info.message.subject[:10]) } for info in context["new_messages"][:3]] else: message_submenus = [{ "id": "no-messages", "href": url("message/inbox"), "label": "No new unread messages" }] message_menu = { "label": "Messages", "id": "menu-inbox", "icon": "icon-envelope icon-white", "mobile_icon_v2": "glyphicon glyphicon-envelope", "iconLabel": str(new_messages.count() if new_messages else 0), "mobile_submenuId": "mobile-messages", "submenus": [{ "id": "menu-inbox-all", "href": url("message/inbox"), "label": "Inbox (See All)", }] + message_submenus } beta_menu = {} if user.is_superuser and 'apps.directemployers.org' in user.email: beta_menu.update({ "label": "Beta", "id": "beta-menu", "mobile_icon_v2": "glyphicon glyphicon-flag", "submenus": [], "mobile_submenuId": "mobile-beta", }) try: can_read_outreach_email_address = user.can( company, "read outreach email address") except MissingAppLevelAccess: can_read_outreach_email_address = False if can_read_outreach_email_address: beta_menu["submenus"].append({ "id": "nonuseroutreach", "href": url("prm/view/nonuseroutreach"), "label": "Non-User Outreach", }) try: can_view_analytics_info = user.can(company, "view analytics") except MissingAppLevelAccess: can_view_analytics_info = False if can_view_analytics_info: beta_menu["submenus"].append({ "id": "analytics", "href": url("analytics/view/main"), "label": "Analytics", }) employer_menu = { "label": "Employers", "id": "employers", "mobile_icon_v2": "glyphicon glyphicon-briefcase", "submenuId": "employer-apps", "mobile_submenuId": "mobile-employer-apps", "submenus": [] } if user.roles.exists() else {} try: can_read_partner = user.can(company, "read partner") except MissingAppLevelAccess: can_read_partner = False if employer_menu and can_read_partner: employer_menu["submenus"] += [ { "id": "partner-tab", "href": url("prm/view"), "label": "PRM" }, ] version_urls = { 'dynamic': url("reports/view/dynamicoverview"), 'classic': url("reports/view/overview"), } reporting_version = request.COOKIES.get('reporting_version', 'classic') employer_menu["submenus"].append({ "id": "reports-tab", "href": version_urls.get(reporting_version, "classic"), "label": "Reports", }) try: can_read_role = user.can(company, "read role") except MissingAppLevelAccess: can_read_role = False if employer_menu and can_read_role: employer_menu["submenus"].append({ "id": "manage-users-tab", "href": url("manage-users"), "label": "Manage Users", }) profile_menu = { "label": user.email, "id": "profile_mobile_v2", "mobile_icon_v2": "glyphicon glyphicon-user", "label_mobile_v2": "Profile", "mobile_submenuId": "mobile-profile", "submenus": [{ "id": "profile-tab", "href": url("profile/view"), "label": "My Profile" }, { "id": "searches-tab", "href": url("saved-search/view"), "label": "My Saved Searches" }, { "id": "account-tab", "href": url("account/edit"), "label": "Account Settings" }, { "id": "search-tab", "href": get_ms_url(context), "label": "Search Jobs" }, { "id": "logout-tab", "href": url("accounts/logout"), "label": "Log Out" }] } # If the topbar request is coming from a microsite, we've got the wrong # user. This can't simply be a request.user check. if impersonating or getattr(request.user, 'is_impersonate', False): profile_menu["submenus"].append({ "id": "impersonate-tab", "href": reverse("impersonate-stop"), "label": "Stop Impersonating" }) # only return menus we've populated return [ menu for menu in beta_menu, message_menu, employer_menu, profile_menu if menu ]
def get_company_from_cookie(context): request = context.get('request') if request: return get_company(request) return None
def __init__(self, *args, **kwargs): self.request = kwargs.pop('request', None) self.company = get_company(self.request) super(RequestForm, self).__init__(*args, **kwargs)
def get_menus(context): """ Returns menu items used in the topbar. Each top-level item is a 'menu' (eg. "Employers"), where as everything below those is a submenu (eg. "PRM"). """ # have to use hard coded urls since the named views don't exist on # microsites. url = lambda path: settings.ABSOLUTE_URL + path company = get_company(context.get("request")) user = context.get("user") new_messages = context.get("new_messages") # menu item cant be generated for a user who isn't logged in if not user or not user.pk or user.is_anonymous(): return [] if new_messages: message_submenus = [ { "id": info.message.pk, "href": url("message/inbox?message=%s" % info.message.pk), "label": "%s - %s" % ( info.message.start_on.date(), info.message.subject[:10] ) } for info in context["new_messages"][:3]] else: message_submenus = [ { "id": "no-messages", "href": url("message/inbox"), "label": "No new unread messages" } ] message_menu = { "label": "Messages", "id": "menu-inbox", "icon": "icon-envelope icon-white", "iconLabel": str(new_messages.count() if new_messages else 0), "submenus": [ { "id": "menu-inbox-all", "href": url("message/inbox"), "label": "Inbox (See All)", } ] + message_submenus } employer_menu = { "label": "Employers", "id": "employers", "submenuId": "employer-apps", "submenus": [ ] } if user.roles.exists() else {} if employer_menu and user.can(company, "read partner"): employer_menu["submenus"] += [ { "id": "partner-tab", "href": url("prm/view"), "label": "PRM" }, { "id": "reports-tab", "href": url("reports/view/overview"), "label": "Reports", } ] if employer_menu and user.can(company, "read role"): employer_menu["submenus"].append( { "id": "manage-users-tab", "href": url("manage-users"), "label": "Manage Users", } ) profile_menu = { "label": user.email, "submenus": [ { "id": "profile-tab", "href": url("profile/view"), "label": "My Profile" }, { "id": "searches-tab", "href": url("saved-search/view"), "label": "My Saved Searches" }, { "id": "account-tab", "href": url("account/edit"), "label": "Account Settings" }, { "id": "search-tab", "href": get_ms_url(context), "label": "Search Jobs" }, { "id": "logout-tab", "href": url("accounts/logout"), "label": "Log Out" } ] } # only return menus we've populated return [menu for menu in message_menu, employer_menu, profile_menu if menu]
def dashboard(request, template="mydashboard/mydashboard.html", extra_context=None): """ Returns a list of candidates who created a saved search for one of the microsites within the company microsite list or with the company name like jobs.jobs/company_name/careers for example between the given (optional) dates Inputs: :company: company.id that is associated with request.user Returns: :render_to_response: renders template with context dict """ if hasattr(mail, 'outbox'): solr = settings.TEST_SOLR_INSTANCE else: solr = settings.SOLR company = get_company(request) if not company: raise Http404 user_solr = Solr(solr['current']) facet_solr = Solr(solr['current']) # Add join only if we're using facets, not if we're simply searching. query_params = {'search', 'company'} if not query_params.issuperset({q_key for q_key in request.GET.keys() if q_key not in ['querystring_key', 'date_end', 'date_start', 'page']}): user_solr = user_solr.add_join(from_field='ProfileUnits_user_id', to_field='User_id') facet_solr = facet_solr.add_join(from_field='User_id', to_field='ProfileUnits_user_id') facet_solr = facet_solr.rows_to_fetch(0) authorized_microsites, buids = get_company_microsites(company) admins = CompanyUser.objects.filter(company=company.id) # Removes main user from admin list to display other admins admins = admins.exclude(user=request.user) requested_microsite = request.REQUEST.get('microsite', '') requested_date_button = request.REQUEST.get('date_button', False) candidates_page = request.REQUEST.get('page', 1) # the url value for 'All' in the select box is company name # which then gets replaced with all microsite urls for that company site_name = '' if requested_microsite != '': active_microsites = authorized_microsites.filter( domain__startswith=requested_microsite) user_solr, facet_solr = filter_by_domain(requested_microsite, user_solr, facet_solr) else: active_microsites = authorized_microsites site_name = company.name if not site_name: try: site_name = active_microsites[0] except IndexError: site_name = '' active_microsites = set(active_microsites) rng, date_start, date_end, date_display = filter_by_date(request) user_solr = user_solr.add_filter_query(rng) facet_solr = facet_solr.add_query(rng) if request.GET.get('search', False): user_solr = user_solr.add_query("%s" % request.GET['search']) facet_solr = facet_solr.add_query("%s" % request.GET['search']) user_solr, facet_solr = filter_by_microsite(company, user_solr, facet_solr) (user_solr, facet_solr, filters) = apply_facets_and_filters( request, user_solr, facet_solr) solr_results = user_solr.rows_to_fetch(100).search() # List of dashboard widgets to display. dashboard_widgets = ["home_views", "search_views", "job_views", "apply_clicks", "candidates", "search", "applied_filters", "filters"] # Date button highlighting if 'today' in request.REQUEST: requested_date_button = 'today' elif 'seven_days' in request.REQUEST: requested_date_button = 'seven_days' elif 'thirty_days' in request.REQUEST: requested_date_button = 'thirty_days' url = request.build_absolute_uri() facets = parse_facets(facet_solr.search(), request) context = { 'admin_you': request.user, 'applied_filters': filters, 'candidates_page': candidates_page, 'company_admins': admins, 'company_id': company.id, 'company_microsites': authorized_microsites, 'company_name': company.name, 'dashboard_widgets': dashboard_widgets, 'date_button': requested_date_button, 'date_display': date_display, 'date_end': date_end, 'date_start': date_start, 'date_submit_url': url, 'facets': facets, 'site_name': site_name, 'view_name': 'Company Dashboard', } results = solr_results.docs facet_var_map = { 'home': 'home', 'listing': 'job_view', 'results': 'search', 'redirect': 'apply', } analytics_solr = Solr(solr['current']).add_facet_field( 'page_category') if requested_microsite: analytics_solr = analytics_solr.add_query('domain:%s' % requested_microsite) else: analytics_solr = analytics_solr.add_query('company_id:%d' % company.pk) rng = filter_by_date(request, field='view_date')[0] analytics_solr = analytics_solr.add_filter_query(rng) all_results = analytics_solr.rows_to_fetch(0).search() analytics_facets = all_results.facets.get('facet_fields', {}).get( 'page_category', []) facet_dict = sequence_to_dict(analytics_facets) for key in facet_dict.keys(): context_key = 'total_%s' % facet_var_map.get(key, '') context[context_key] = facet_dict[key] analytics_solr = analytics_solr.add_filter_query('User_id:[* TO *]') analytics_solr = analytics_solr.add_facet_field('domain') auth_results = analytics_solr.search() analytics_facet_list = auth_results.facets.get( 'facet_fields', {}).get('domain', []) analytics_facets = sequence_to_dict(analytics_facet_list) analytics_facets = [domain for domain in analytics_facets.items() if domain[0] in active_microsites] results += auth_results.docs candidates = dict_to_object(results) domains = [get_domain(c.SavedSearch_feed) for c in candidates if hasattr(c, 'SavedSearch_feed')] search_facets = [(domain, domains.count(domain)) for domain in set(domains)] domain_facets = {} for domain, group in groupby(analytics_facets + search_facets, key=lambda x: x[0]): domain_facets[domain] = sum(item[1] for item in group) candidate_list = sorted(candidates, key=lambda y: y.SavedSearch_created_on if hasattr(y, 'SavedSearch_created_on') else y.view_date, reverse=True) context['domain_facets'] = domain_facets context['candidates'] = candidate_list context['total_candidates'] = len([x for x in groupby( candidate_list, key=lambda y: y.User_id)]) if extra_context is not None: context.update(extra_context) return render_to_response(template, context, context_instance=RequestContext(request))