def get_company_initials(request):
"""
return string company initials
"""
company = get_company_from_request(request)
initials = u''.join([part[0] for part in company.name.split(' ')])
return initials.upper()
def get_queryset(self):
company = get_company_from_request(self.request)
qs = Report.objects.filter(
company=company
)
return qs
def _check_subscription(request):
company = get_company_from_request(request, fail_silently=True)
if company:
customer = company.get_customer()
if customer and not customer.has_active_subscription():
redirect_url = resolve_url('djstripe:subscribe',
**dict(company_id=company.pk))
return redirect(redirect_url)
def get_queryset(self):
from shareholder.models import ShareholderStatementReport
from utils.session import get_company_from_request
company = get_company_from_request(self.request)
qs = ShareholderStatementReport.objects.filter(
company=company)
return qs.order_by('company__name', '-report_date')
def get_new_shareholder_number(self, request):
"""
returns unused new unused shareholder number
"""
company = get_company_from_request(request)
number = company.get_new_shareholder_number()
payload = {'number': number}
return Response(payload, status=status.HTTP_200_OK)
def get_new_certificate_id(self, request):
"""
returns unused new certificate id
"""
company = get_company_from_request(request)
cert_id = company.get_new_certificate_id()
payload = {'certificate_id': cert_id}
return Response(payload, status=status.HTTP_200_OK)
def has_permission(self, request, view):
"""
check company subscription
"""
company = get_company_from_request(request, fail_silently=True)
if not company:
logger.warning('cannot get company from request')
return False
plan_name = company.get_current_subscription_plan()
if not plan_name:
# FIXME: what now? True or False?
logger.warning('cannot get plan name. returning false for perm')
return False
subscription_features = getattr(view, 'subscription_features', [])
if not subscription_features:
return True
plan = settings.DJSTRIPE_PLANS.get(plan_name, {})
if not plan:
logger.error('plan lookup in rest api permissions failed',
extra={
'plan_name': plan_name,
'DJSTRIPE_PLANS': settings.DJSTRIPE_PLANS
})
plan_features = plan.get('features', {})
for feature in subscription_features:
if feature not in plan_features:
self.message = {feature: _('Feature not supported.')}
logger.warning(
'feature %s is not in plan features %s. returning false',
feature, plan_features)
return False
feature_config = plan_features.get(feature, {})
if not feature_config:
continue
# got config
validators = feature_config.get('validators', {})
action = getattr(view, 'action', '')
for validator in validators.get(action, []):
validator_class = import_string(validator)
try:
validator_class(company)()
except ValidationError as err:
self.message = {feature: err.messages}
logger.warning(
'validation error "%s" for feature %s by '
'validator %s. returning false for perm', err.messages,
feature, validator)
return False
return True
def _get_statements(self):
""" return qs with statements for this user for this company """
#
company = get_company_from_request(self.request, fail_silently=True)
if not company:
return {}
statements = self.get_object().user.shareholderstatement_set.filter(
report__company=company)
return {'statements': statements}
def perform_create(self, serializer):
""" complete missing data for model """
report = serializer.save(
eta=timezone.now(), # placeholder
user=self.request.user,
company=get_company_from_request(self.request)
)
report.update_eta()
report.save()
report.render(notify=True, track_downloads=True)
return report
def get_queryset(self):
company = get_company_from_request(self.request)
qs = OptionTransaction.objects.filter(
option_plan__company=company
)
# filter if option plan is given in query params
# FIXME: why no use filter or detail route???
pk = self.request.query_params.get('optionplan_pk')
if pk:
qs = qs.filter(option_plan_id=pk)
return qs
def get_queryset(self):
"""
user has no company selected
"""
self.subscription_features = ['shareholders']
if not self.request.session.get('company_pk'):
return Shareholder.objects.none()
company = get_company_from_request(self.request)
qs = Shareholder.objects.filter(company=company)
qs = self._filter_queryset_by_order_cache(qs)
return qs.select_related('company', 'user', 'user__userprofile') \
.prefetch_related('user__operator_set') \
.distinct()
def process_request(self, request):
path = request.path.lstrip('/')
if (request.user.is_authenticated() and
any(re.compile(m).match(path) for m in self.BLACKLIST_URLS)):
# check if any companies have no active subscription
company = get_company_from_request(request, fail_silently=True)
if company:
customer = company.get_customer()
if customer and not customer.has_active_subscription():
redirect_url = resolve_url(
'djstripe:subscribe',
**dict(company_id=company.pk)
)
return redirect(redirect_url)
def company_number_segments(self, request):
company = get_company_from_request(request)
shareholder = company.get_company_shareholder()
kwargs = {}
if request.GET.get('date'):
# FIXME: parse date(time) properly
kwargs.update({'date': request.GET.get('date')[:10]})
data = {}
for security in shareholder.company.security_set.all():
if security.track_numbers:
kwargs.update({'security': security})
data.update({
security.pk: shareholder.current_segments(**kwargs)
})
return Response(data, status=status.HTTP_200_OK)
def get(self, request, optionsplan_id, shareholder_id):
"""
returns available option segments from shareholder X and
optionplan Y
"""
company = get_company_from_request(request)
optionplan = get_object_or_404(OptionPlan.objects.filter(
company=company), pk=optionsplan_id)
shareholder = get_object_or_404(Shareholder.objects.filter(
company=company), pk=shareholder_id)
kwargs = {
'security': optionplan.security,
'optionplan': optionplan,
}
if request.GET.get('date'):
kwargs.update({'date': request.GET.get('date')[:10]})
return Response(shareholder.current_options_segments(**kwargs))
def option_holder(self, request):
"""
returns the captable part for all option holders
"""
self.subscription_features = ['shareholders', 'options']
# if user has no company yet
if not self.request.session.get('company_pk'):
return Response(Shareholder.objects.none())
company = get_company_from_request(request)
ohs = company.get_active_option_holders()
ohs = self.filter_queryset(ohs)
page = self.paginate_queryset(ohs)
if page is not None:
serializer = OptionHolderSerializer(
page, many=True, context={'request': request})
return self.get_paginated_response(serializer.data)
serializer = OptionHolderSerializer(
ohs, many=True, context={'request': request})
return Response(serializer.data)
def post(self, request, fomat=None):
data = request.data
is_valid, errors = self._validate_data(data)
if is_valid:
# get company and run company.split_shares(data)
company = get_company_from_request(request)
data.update({
'execute_at': dateutil.parser.parse(data['execute_at']),
'security': Security.objects.get(id=data['security']['pk'])
})
company.split_shares(data)
positions = Position.objects.filter(
buyer__company__operator__user=request.user).order_by(
'-bought_at')
serializer = PositionSerializer(
positions, many=True, context={'request': request})
return Response(
{'success': True, 'data': serializer.data},
status=status.HTTP_201_CREATED)
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
def get_queryset(self):
company = get_company_from_request(self.request)
return Operator.objects.filter(company=company)\
.exclude(user__is_superuser=True).distinct()
def get_queryset(self):
company = get_company_from_request(self.request)
return Security.objects.filter(company=company)
def get_context_data(self, **kwargs):
context = super(IndexView, self).get_context_data(**kwargs)
context['company'] = get_company_from_request(self.request)
return context
def get_queryset(self):
company = get_company_from_request(self.request)
return Position.objects.filter(
Q(buyer__company=company) |
Q(seller__company=company)
).distinct().order_by('-bought_at', '-pk')
def has_permission(self, request, view):
is_authenticated = super(IsOperatorPermission,
self).has_permission(request, view)
company = get_company_from_request(request, fail_silently=True)
return (is_authenticated and company
and request.user.operator_set.filter(company=company).exists())
def get_queryset(self):
company = get_company_from_request(self.request)
return OptionPlan.objects.filter(company=company)