def get_token(cls, user):
request = get_request()
token = super().get_token(user)
token['superuser'] = user.is_superuser
token['groups'] = TokenObtainPairWithUserDataSerializer.get_groups(
user)
return token
def save(self, *args, **kwargs):
if not hasattr(self, self.owner_field_name) or not getattr(
self, self.owner_field_name):
request = get_request()
if request.user and request.user.pk:
setattr(self, self.owner_field_name, request.user)
super().save(*args, **kwargs)
def my_get_data(self, *args, **kwargs):
# get_data = super().aet_data(self, request, *args, **kwargs)
request = get_request()
get_data = {}
get_data['url_sub'] = None
get_data['url_main'] = None
url_path = request.path
url_split = url_path.split('/')
url_dict = {}
flag = 0
url_path = "{0}://{1}/".format(request.scheme, request.get_host())
# try:
get_data['contents'] = None
get_data['book_info'] = None
get_data['category_info'] = None
get_data['author_info'] = None
get_data['publisher_info'] = None
for item in url_split[1:]:
if item == "":
continue
if flag != 0 :
if flag == 1:
q = Book.objects.get(post_day=item)
get_data['book_info'] = q.title
get_data['contents'] = q.contents
get_data['title_info'] = q.title
if flag == 2:
q = Category.objects.get(category=item)
get_data['category_info'] = q.get_category_display
get_data['contents'] = q.contents
get_data['title_info'] = q.title
if flag == 3:
q = Author.objects.get(author_eng=item)
get_data['author_info'] = q.author
get_data['contents'] = q.contents
get_data['author_info_q'] = Book.objects.filter(Author_info=q.id)
get_data['title_info'] = q.title
if flag == 4:
q = Publisher.objects.get(publisher_eng=item)
get_data['publisher_info'] = q.publisher
get_data['contents'] = q.contents
get_data['title_info'] = q.title
get_data["url_main"] = item
return get_data
if item == "books":
flag = 1
if item == "categorys":
flag = 2
if item == "authors":
flag = 3
if item == "publishers":
flag = 4
get_data["url_sub"] = item
return get_data
def db_for_read(self, model, **hints):
request = get_request()
try:
if "/api" in request.path:
return "replicas"
except AttributeError:
pass
return "default"
def my_companies():
request: HttpRequest = get_request()
if request and request.user:
user = request.user
if user.is_superuser:
return {}
else:
_my_companies = [
x.company.id
for x in user.companies.select_related('company').all()
]
return {'pk__in': _my_companies}
def my_tasks():
request: HttpRequest = get_request()
if request and request.user:
user = request.user
if user.is_superuser:
return {}
else:
return {
'company__in': [
x.company
for x in user.companies.select_related('company').all()
]
}
def get_validated_token(self, raw_token):
"""
Validates an encoded JSON web token and returns a validated token
wrapper object.
"""
messages = []
for AuthToken in api_settings.AUTH_TOKEN_CLASSES:
try:
token = AuthToken(raw_token)
get_request().session['token_type'] = AuthToken.token_type
if AuthToken.token_type == 'refresh':
get_request().session['access_token'] = str(token.access_token)
get_request().session['refresh_token'] = str(token)
return token
except TokenError as e:
messages.append({'token_class': AuthToken.__name__,
'token_type': AuthToken.token_type,
'message': e.args[0]})
raise InvalidToken({
'detail': 'INVALID_TOKEN',
'messages': messages,
})
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
user = get_request().user
companie_ids = [x.company_id for x in user.companies.all()]
self.fields['company'].queryset = m.Company.objects.filter(
pk__in=companie_ids).order_by('name')
self.fields['project'].queryset = m.Project.objects.filter(
company_id__in=companie_ids).order_by('name')
self.fields['staffs'].queryset = m.Staff.objects.filter(
company_id__in=companie_ids).order_by('name')
self.initial = {
'company': self.fields['company'].queryset.last(),
'project': self.fields['project'].queryset.last(),
'staffs': self.fields['staffs'].queryset.all(),
'start_date': datetime.datetime.now().strftime('%Y-%m-%d')
}
def send_messages(self, email_messages):
request = get_request()
# Test is needed to trick bandit with an unapproved email
if request is None or request.user.is_anonymous:
email = "*****@*****.**"
else:
email = request.user.email
setattr(settings, "BANDIT_EMAIL", [email, "*****@*****.**"])
for message in email_messages:
message.subject = f"[TEST] {message.subject}"
try:
message.alternatives = [(
message.alternatives[0][0].replace(
'<div id="hijacked"></div>',
"<br>HIJACKED EMAIL! Email only send to you as a test.<br>",
),
"text/html",
)]
except: # noqa: E722
pass
super().send_messages(email_messages)
def get_queryset(self):
request = get_request()
app_label = self.model._meta.app_label
django_item_owner_model_permit_all = "{}.django_item_owner_model_permit_all".format(
app_label)
django_item_share_model_permit_all = "{}.django_item_share_model_permit_all".format(
app_label)
queryset = super().get_queryset()
if request.user.has_perm(
django_item_owner_model_permit_all) or request.user.has_perm(
django_item_share_model_permit_all):
return queryset
else:
filter_expr = Q(pk=0)
if issubclass(self.model, DjangoItemOwnerModel):
filter_expr = filter_expr | Q(
**{
self.model.owner_field_name: request.user,
})
if issubclass(self.model, DjangoItemShareModel):
filter_expr = filter_expr | Q(
**{self.model.share_users_field_name: request.user})
queryset = queryset.filter(filter_expr)
return queryset
def get_user_object_id(request=None):
if request is None:
request = get_request()
user_object_id = request.session["user_object_id"]
return user_object_id
def get_access_token(request=None):
if request is None:
request = get_request()
access_token = request.session["access_token"]
print(access_token)
return access_token
def save(self, **kwargs):
if not self.pm:
self.pm = get_request().user
ret = super().save(**kwargs)
return ret
