Generate the unique CART ID
"""
logger.debug("Generating cart ID")
return Response({"cart_id": uuid.uuid4()})
@swagger_auto_schema(method='POST',
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'cart_id':
openapi.Schema(type=openapi.TYPE_STRING,
description='Cart ID.',
required=['true']),
'product_id':
openapi.Schema(type=openapi.TYPE_INTEGER,
description='Product ID.',
required=['true']),
'attributes':
openapi.Schema(
type=openapi.TYPE_STRING,
description='Attributes of Product.',
required=['true']),
}))
@api_view(['POST'])
def add_products(request):
"""
Add a Product in the cart
"""
# TODO: place the code here
class ResetPasswordAPIView(APIView):
"""
Reset Password API View : LoginSerializer, reset password
"""
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'username':
openapi.Schema(type=openapi.TYPE_STRING, description="username"),
'password':
openapi.Schema(type=openapi.TYPE_STRING,
description="new password")
}))
def put(self, request):
"""
This method is used to reset password for a user instance.
:param request: It's accept username and password as parameter.
:return: It's return response that password is updated or not.
"""
try:
# Login serializer
serializer = LoginSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
# Get user instance according to username
user = get_object_by_username(serializer.data.get('username'))
# Reset password
user.set_password(serializer.data.get('password'))
user.save()
# Password reseted successfully
return Response(
{
'success': True,
'message': 'Reset password successfully!',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_200_OK)
except User.DoesNotExist as e:
logger.exception(e)
return Response(
{
'success': False,
'message': 'User does not exist!',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_400_BAD_REQUEST)
except ValidationError as e:
logger.exception(e)
return Response({
'success': False,
'message': serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.exception(e)
return Response(
{
'success': False,
'message':
'Oops! Something went wrong! Please try again...'
},
status=status.HTTP_400_BAD_REQUEST)
class ForgotPasswordAPIView(APIView):
"""
ForgotPasswordAPIView:
"""
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'username':
openapi.Schema(type=openapi.TYPE_STRING, description="username")
}))
def post(self, request):
try:
# Username serializer
serializer = UsernameSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
# Get user instance according to username
user = get_object_by_username(serializer.data.get('username'))
# Extract email
user_email = user.email
# Reset password link
reset_password_link = 'http://127.0.0.1:4200/reset-password'
# Sending activation mail
email = EmailMessage(
'Reset your account password', # Subject
'Please click this link to reset your account password: '******'success': True,
'message': 'Email sended successfully for reset password!',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_200_OK)
except User.DoesNotExist as e:
logger.exception(e)
return Response(
{
'success': False,
'message': 'User does not exist!',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_400_BAD_REQUEST)
except ValidationError as e:
logger.exception(e)
return Response({
'success': False,
'message': serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.exception(e)
return Response(
{
'success': False,
'message':
'Oops! Something went wrong! Please try again...'
},
status=status.HTTP_400_BAD_REQUEST)
MOVIE_DOCUMENT_SCHEMA = openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
"id": openapi.Schema(
type=openapi.TYPE_STRING,
description="A unique identifier for the movie.",
example="123",
),
"title": openapi.Schema(
type=openapi.TYPE_STRING,
description="Title of the movie.",
example="Interstellar",
),
"image_url": openapi.Schema(
type=openapi.TYPE_STRING,
description="Link to the movie poster image.",
example="https://image.tmdb.org/t/p/w500/nBNZadXqJSdt05SHLqgT0HuC5Gm.jpg",
),
"description": openapi.Schema(
type=openapi.TYPE_STRING,
description="Synopsis of the movie plot.",
example="Interstellar chronicles the adventures of a group of explorers who make use of a newly discovered wormhole to surpass the limitations on human space travel and conquer the vast distances involved in an interstellar voyage.",
),
"release_year": openapi.Schema(
type=openapi.TYPE_STRING,
description="Year the movie was released in theaters.",
example="2014",
),
"genres": openapi.Schema(
type=openapi.TYPE_ARRAY,
description="List of genres associated with the movie.",
items=openapi.Schema(type=openapi.TYPE_STRING, example="Science Fiction"),
),
},
)
class FlowViewSet(ModelViewSet):
"""Flow Viewset"""
queryset = Flow.objects.all()
serializer_class = FlowSerializer
lookup_field = "slug"
search_fields = ["name", "slug", "designation", "title"]
filterset_fields = ["flow_uuid", "name", "slug", "designation"]
@permission_required(None, ["authentik_flows.view_flow_cache"])
@swagger_auto_schema(responses={200: CacheSerializer(many=False)})
@action(detail=False, pagination_class=None, filter_backends=[])
def cache_info(self, request: Request) -> Response:
"""Info about cached flows"""
return Response(data={"count": len(cache.keys("flow_*"))})
@permission_required(None, ["authentik_flows.clear_flow_cache"])
@swagger_auto_schema(
request_body=no_body,
responses={
204: "Successfully cleared cache",
400: "Bad request"
},
)
@action(detail=False, methods=["POST"])
def cache_clear(self, request: Request) -> Response:
"""Clear flow cache"""
keys = cache.keys("flow_*")
cache.delete_many(keys)
LOGGER.debug("Cleared flow cache", keys=len(keys))
return Response(status=204)
@permission_required(
None,
[
"authentik_flows.add_flow",
"authentik_flows.change_flow",
"authentik_flows.add_flowstagebinding",
"authentik_flows.change_flowstagebinding",
"authentik_flows.add_stage",
"authentik_flows.change_stage",
"authentik_policies.add_policy",
"authentik_policies.change_policy",
"authentik_policies.add_policybinding",
"authentik_policies.change_policybinding",
"authentik_stages_prompt.add_prompt",
"authentik_stages_prompt.change_prompt",
],
)
@swagger_auto_schema(
request_body=no_body,
manual_parameters=[
openapi.Parameter(
name="file",
in_=openapi.IN_FORM,
type=openapi.TYPE_FILE,
required=True,
)
],
responses={
204: "Successfully imported flow",
400: "Bad request"
},
)
@action(detail=False, methods=["POST"], parser_classes=(MultiPartParser, ))
def import_flow(self, request: Request) -> Response:
"""Import flow from .akflow file"""
file = request.FILES.get("file", None)
if not file:
return HttpResponseBadRequest()
importer = FlowImporter(file.read().decode())
valid = importer.validate()
if not valid:
return HttpResponseBadRequest()
successful = importer.apply()
if not successful:
return Response(status=204)
return HttpResponseBadRequest()
@permission_required(
"authentik_flows.export_flow",
[
"authentik_flows.view_flow",
"authentik_flows.view_flowstagebinding",
"authentik_flows.view_stage",
"authentik_policies.view_policy",
"authentik_policies.view_policybinding",
"authentik_stages_prompt.view_prompt",
],
)
@swagger_auto_schema(
responses={
"200":
openapi.Response("File Attachment",
schema=openapi.Schema(type=openapi.TYPE_FILE)),
}, )
@action(detail=True, pagination_class=None, filter_backends=[])
# pylint: disable=unused-argument
def export(self, request: Request, slug: str) -> Response:
"""Export flow to .akflow file"""
flow = self.get_object()
exporter = FlowExporter(flow)
response = JsonResponse(exporter.export(),
encoder=DataclassEncoder,
safe=False)
response[
"Content-Disposition"] = f'attachment; filename="{flow.slug}.akflow"'
return response
@swagger_auto_schema(responses={200: FlowDiagramSerializer()})
@action(detail=True,
pagination_class=None,
filter_backends=[],
methods=["get"])
# pylint: disable=unused-argument
def diagram(self, request: Request, slug: str) -> Response:
"""Return diagram for flow with slug `slug`, in the format used by flowchart.js"""
flow = self.get_object()
header = [
DiagramElement("st", "start", "Start"),
]
body: list[DiagramElement] = []
footer = []
# First, collect all elements we need
for s_index, stage_binding in enumerate(
get_objects_for_user(
request.user,
"authentik_flows.view_flowstagebinding").filter(
target=flow).order_by("order")):
for p_index, policy_binding in enumerate(
get_objects_for_user(
request.user,
"authentik_policies.view_policybinding").filter(
target=stage_binding).exclude(
policy__isnull=True).order_by("order")):
body.append(
DiagramElement(
f"stage_{s_index}_policy_{p_index}",
"condition",
f"Policy\n{policy_binding.policy.name}",
))
body.append(
DiagramElement(
f"stage_{s_index}",
"operation",
f"Stage\n{stage_binding.stage.name}",
))
# If the 2nd last element is a policy, we need to have an item to point to
# for a negative case
body.append(DiagramElement("e", "end", "End|future"), )
if len(body) == 1:
footer.append("st(right)->e")
else:
# Actual diagram flow
footer.append(f"st(right)->{body[0].identifier}")
for index in range(len(body) - 1):
element: DiagramElement = body[index]
if element.type == "condition":
# Policy passes, link policy yes to next stage
footer.append(
f"{element.identifier}(yes, right)->{body[index + 1].identifier}"
)
# Policy doesn't pass, go to stage after next stage
no_element = body[index + 1]
if no_element.type != "end":
no_element = body[index + 2]
footer.append(
f"{element.identifier}(no, bottom)->{no_element.identifier}"
)
elif element.type == "operation":
footer.append(
f"{element.identifier}(bottom)->{body[index + 1].identifier}"
)
diagram = "\n".join([str(x) for x in header + body + footer])
return Response({"diagram": diagram})
@permission_required("authentik_flows.change_flow")
@swagger_auto_schema(
request_body=no_body,
manual_parameters=[
openapi.Parameter(
name="file",
in_=openapi.IN_FORM,
type=openapi.TYPE_FILE,
required=True,
)
],
responses={
200: "Success",
400: "Bad request"
},
)
@action(
detail=True,
pagination_class=None,
filter_backends=[],
methods=["POST"],
parser_classes=(MultiPartParser, ),
)
# pylint: disable=unused-argument
def set_background(self, request: Request, slug: str):
"""Set Flow background"""
app: Flow = self.get_object()
icon = request.FILES.get("file", None)
if not icon:
return HttpResponseBadRequest()
app.background = icon
app.save()
return Response({})
@swagger_auto_schema(
responses={
200: LinkSerializer(many=False),
400: "Flow not applicable"
}, )
@action(detail=True, pagination_class=None, filter_backends=[])
# pylint: disable=unused-argument
def execute(self, request: Request, slug: str):
"""Execute flow for current user"""
flow: Flow = self.get_object()
planner = FlowPlanner(flow)
planner.use_cache = False
try:
plan = planner.plan(self.request,
{PLAN_CONTEXT_PENDING_USER: request.user})
self.request.session[SESSION_KEY_PLAN] = plan
except FlowNonApplicableException as exc:
return bad_request_message(
request,
_("Flow not applicable to current user/request: %(messages)s" %
{"messages": str(exc)}),
)
return Response({
"link":
request._request.build_absolute_uri(
reverse("authentik_core:if-flow",
kwargs={"flow_slug": flow.slug}))
})
SWAGGER_SECURITY_REQUIREMENTS_OAUTH,
)
from crashreports.response_descriptions import default_desc
_RESPONSE_STATUS_200_DESCRIPTION = "OK"
_DEVICE_UPDATE_HISTORY_SCHEMA = openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.Schema(
type=openapi.TYPE_OBJECT,
title="DeviceUpdateHistoryEntry",
properties=OrderedDict(
[
("build_fingerprint", openapi.Schema(type=openapi.TYPE_STRING)),
("heartbeats", openapi.Schema(type=openapi.TYPE_INTEGER)),
("max", openapi.Schema(type=openapi.TYPE_INTEGER)),
("other", openapi.Schema(type=openapi.TYPE_INTEGER)),
("prob_crashes", openapi.Schema(type=openapi.TYPE_INTEGER)),
("smpl", openapi.Schema(type=openapi.TYPE_INTEGER)),
("update_date", openapi.Schema(type=openapi.TYPE_STRING)),
]
),
),
)
class DeviceUpdateHistory(APIView):
"""View the update history of a specific device."""
permission_classes = (HasStatsAccess,)
from drf_yasg.utils import swagger_auto_schema
from rest_framework.response import Response
from rest_framework.decorators import api_view
from wish_swap.payments.models import Payment
from wish_swap.transfers.models import Transfer
'''
from wish_swap.transfers.serializers import TransferSerializer
from wish_swap.transfers.models import Transfer
from rest_framework.views import APIView
'''
payment_not_found_response = openapi.Response(
description='response if no such payment exists in db',
schema=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'detail': openapi.Schema(type=openapi.TYPE_STRING),
},
))
swap_status_response = openapi.Response(
description=
'Swap status: `SUCCESS`, `IN PROCESSS`, `FAIL` and transfer hash if `SUCCESS`',
schema=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'status': openapi.Schema(type=openapi.TYPE_STRING),
'transfer_hash': openapi.Schema(type=openapi.TYPE_STRING),
},
))
decorated_login_view = \
swagger_auto_schema(
method="post",
tags=["Token authentication"],
operation_id="login_token",
operation_description="obtain a token for login",
request_body=AuthTokenSerializer,
responses={
status.HTTP_200_OK: openapi.Response(
"successful login",
schema=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
"token": openapi.Schema(
type=openapi.TYPE_STRING,
description="authentication token"
)
}
)
),
status.HTTP_400_BAD_REQUEST: openapi.Response(
"login failed"
)
}
)(authtoken_views.obtain_auth_token)
decorated_logout_view = \
swagger_auto_schema(
method="post",
tags=["Token authentication"],
class Meta:
swagger_schema_fields = {
'type': openapi.TYPE_OBJECT,
'properties': {
'time_series': openapi.Schema(
title='time_series',
type=openapi.TYPE_INTEGER,
),
'training_dataset': openapi.Schema(
title='training_dataset',
type=openapi.TYPE_INTEGER,
),
'window_size': openapi.Schema(
title='window_size',
type=openapi.TYPE_INTEGER,
),
'normalize': openapi.Schema(
title='normalize',
type=openapi.TYPE_BOOLEAN,
),
'dtw_distance_function': openapi.Schema(
title='dtw_distance_function',
type=openapi.TYPE_STRING,
),
'delta': openapi.Schema(
title='delta',
type=openapi.TYPE_NUMBER,
),
'n_components': openapi.Schema(
title='n_components',
type=openapi.TYPE_INTEGER,
),
'train_size': openapi.Schema(
title='train_size',
type=openapi.TYPE_NUMBER,
),
'n_init': openapi.Schema(
title='n_init',
type=openapi.TYPE_INTEGER,
),
'kernel': openapi.Schema(
title='kernel',
type=openapi.TYPE_STRING,
),
'nu': openapi.Schema(
title='nu',
type=openapi.TYPE_NUMBER,
),
'bootstrap': openapi.Schema(
title='bootstrap',
type=openapi.TYPE_BOOLEAN,
),
'n_estimators': openapi.Schema(
title='n_estimators',
type=openapi.TYPE_INTEGER,
),
'time_range': openapi.Schema(
title='time_range',
type=openapi.TYPE_STRING,
),
'maximize_score': openapi.Schema(
title='maximize_score',
type=openapi.TYPE_STRING,
),
'range_start': openapi.Schema(
title='range_start',
type=openapi.TYPE_INTEGER,
),
'range_end': openapi.Schema(
title='range_end',
type=openapi.TYPE_INTEGER,
),
},
'required': ['maximize_score', 'time_range', 'range_start', 'range_end']
}
openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
"<縣市名稱>":
openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
"factories":
openapi.Schema(type=openapi.TYPE_STRING,
description="工廠數量"),
"documents":
openapi.Schema(type=openapi.TYPE_STRING,
description="公文數量"),
"report_records":
openapi.Schema(type=openapi.TYPE_STRING,
description="總回報數量"),
"towns":
openapi.Schema(
type=openapi.TYPE_OBJECT,
description="鄉鎮市的資料",
properties={
"<鄉鎮市名>":
openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
"factories":
openapi.Schema(
type=openapi.TYPE_STRING,
description="工廠數量"),
"documents":
openapi.Schema(
type=openapi.TYPE_STRING,
description="公文數量"),
"report_records":
openapi.Schema(
type=openapi.TYPE_STRING,
description="回報數量"),
},
)
},
),
},
),
},
),
product_list_example_create
from posts.models.product_model import Product
from posts.serializers.product_serializer import ProductSearchSerializer, ProductSerializer
@swagger_auto_schema(method='get',
tags=['product'],
manual_parameters=product_list_parameter,
responses={200: '상품 조회 성공'})
@swagger_auto_schema(
method='post',
tags=['product'],
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties=product_list_schema_create,
example=product_list_example_create,
required=['id_member', 'addr', 'name', 'tel', 'info', 'code']),
responses={200: '상품 등록 성공'})
@api_view(['GET', 'POST'])
def product_list(request):
"""
매물 리스트 조회, 등록 API
---
상품을 모두 보여주거나 새 상품리스트를 만듭니다.
# form/data OR json/data
- id_product : seq key
- id_member : 상품을 올린 member 외래키
- name : 상품 제목
- price : 상품 가격
type=openapi.TYPE_STRING,
required=True)
])
def delete(self, request):
user = is_logged_in(request)
user.delete()
return Response(status=200)
@swagger_auto_schema(
operation_summary='로그인',
method='post',
request_body=openapi.Schema(type=openapi.TYPE_OBJECT,
properties={
"email":
openapi.Schema(type=openapi.TYPE_STRING),
"password":
openapi.Schema(type=openapi.TYPE_STRING)
},
required=["email", "password"]))
@api_view(['POST'])
def login(request):
user = authenticate(request=request,
username=request.data.get('email'),
password=request.data.get('password'))
if user is None:
return Response(status=401)
payload = PayloadSerializers(user)
encoded = jwt.encode(payload.data, settings.SECRET_KEY, algorithm='HS256')
return Response({'token': encoded})
from .serializers import RegisterSerializer, LoginSerializer
from .models import User
from drf_yasg.utils import swagger_auto_schema
from drf_yasg import openapi
# Create your views here.
@swagger_auto_schema(method='post',
operation_description='This endpoint does some magic',
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'username':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
'email':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
'password':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
}))
@api_view(['POST'])
@permission_classes([AllowAny])
def register_user(request, *args, **kwargs):
user = request.data
serializer = RegisterSerializer(data=user)
serializer.is_valid(raise_exception=True)
serializer.save()
user_data = serializer.data
class UserViewSet(mixins.RetrieveModelMixin, mixins.UpdateModelMixin,
viewsets.GenericViewSet):
queryset = User.objects.filter(is_active=True)
serializer_class = UserModelSerializer
lookup_field = 'username'
def get_permissions(self):
if self.action in ['signup', 'verify', 'login']:
permissions = [AllowAny]
elif self.action in [
'retrieve', 'update', 'partial_update', 'profile'
]:
permissions = [IsAuthenticated, IsAccountOwner]
else:
# Method not allowed
return []
return [p() for p in permissions]
@swagger_auto_schema(
security=[],
request_body=UserSignUpSerializer,
responses={status.HTTP_201_CREATED: UserModelSerializer})
@action(detail=False, methods=['post'])
def signup(self, request):
"""User sign up view, after successful registration, an email is sent
to the user with a verification token that expires on 3 days."""
serializer = UserSignUpSerializer(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
user = serializer.save()
data = UserModelSerializer(user).data
return Response(data, status.HTTP_201_CREATED)
# Next time I'll manually write the api documentation because
# this is absurd
@swagger_auto_schema(
security=[],
manual_parameters=[
openapi.Parameter('token',
openapi.IN_QUERY,
description="Verification token sent to user",
type=openapi.TYPE_STRING)
],
request_body=no_body,
responses={
status.HTTP_200_OK:
openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'message':
openapi.Schema(type=openapi.TYPE_STRING,
description='Success message')
},
)
})
@action(detail=False, methods=['get'])
def verify(self, request):
"""User verification by jwt token view."""
token = self.request.query_params.get('token', None)
if token is None:
return Response({'token': 'Missing query parameter: token'},
status.HTTP_400_BAD_REQUEST)
serializer = UserVerificationSerializer(data={'token': token})
serializer.is_valid(raise_exception=True)
serializer.save()
data = {'message': 'You have been sucessfully verified'}
return Response(data, status.HTTP_200_OK)
@swagger_auto_schema(
security=[],
request_body=UserLoginSerializer,
responses={status.HTTP_200_OK: UserModelTokenSerializer})
@action(detail=False, methods=['post'])
def login(self, request):
"""Login endpoint, returns user's info and authorization token"""
serializer = UserLoginSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user, token = serializer.save()
user.token = token
data = UserModelTokenSerializer(user).data
return Response(data, status.HTTP_200_OK)
@swagger_auto_schema(method='get',
responses={status.HTTP_200_OK: UserModelSerializer})
@swagger_auto_schema(
methods=['put', 'patch'],
request_body=ProfileModelSerializer,
responses={status.HTTP_200_OK: ProfileModelSerializer})
@action(detail=False, methods=['get', 'put', 'patch'])
def profile(self, request, *args, **kwargs):
"""Performs actions only on profile fields"""
print(request.method)
if request.method == 'GET':
data = UserModelSerializer(self.request.user).data
return Response(data, status.HTTP_200_OK)
elif request.method == 'PATCH' or request.method == 'PUT':
profile = Profile.objects.get(user=self.request.user)
serializer = ProfileModelSerializer(
profile, data=request.data, partial=request.method == 'PUT')
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status.HTTP_200_OK)
# Manual Parameter
page_field = openapi.Parameter('page',
openapi.IN_QUERY,
description='this is a page number',
type=openapi.TYPE_STRING)
page_size_field = openapi.Parameter('page_size',
openapi.IN_QUERY,
description='this is a page size',
type=openapi.TYPE_INTEGER)
company_list_parameter = [page_field, page_size_field]
# Schema
company_list_schema_create = {
'id_member': openapi.Schema(type=openapi.TYPE_INTEGER, \
description='멤버 고유 ID'),
'name': openapi.Schema(type=openapi.TYPE_STRING, \
description='업체 이름'),
'addr': openapi.Schema(type=openapi.TYPE_STRING, \
description='업체 설정 주소 (주소는 1개가지 설정 가능)'),
'tel': openapi.Schema(type=openapi.TYPE_STRING, \
description='업체 전화번호'),
'info': openapi.Schema(type=openapi.TYPE_STRING, \
description='업체 설명'),
'code': openapi.Schema(type=openapi.TYPE_STRING, \
description='업체 카테고리 코드 ([유효성 검사] 허용된 코드 : LOCAL_SHOP)'),
}
# Example
company_list_example_create = {
required=True,
type=openapi.TYPE_STRING
)],
operation_description="Retrieve list of contents of a fridge",
responses={
200: openapi.Response(
"Retrieved contents",
openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
"item_id": openapi.Schema(
type=openapi.TYPE_STRING,
description="UUID"
),
"expiration_date": openapi.Schema(
type=openapi.TYPE_STRING, pattern="YYYY-mm-dd"
),
"amount": openapi.Schema(type=openapi.TYPE_INTEGER),
"unit": openapi.Schema(type=openapi.TYPE_STRING),
"item_name": openapi.Schema(type=openapi.TYPE_STRING),
}
)
)),
},
security=[{'FridgifyAPI_Token_Auth': []}]
)
@swagger_auto_schema(
method="post",
manual_parameters=[openapi.Parameter(
"Authorization",
achievement_update_params = openapi.Schema(
title='achievement',
description='更新achievement',
type=openapi.TYPE_OBJECT,
properties={
'organizations':
openapi.Schema(description='完成单位',
type=openapi.TYPE_ARRAY,
items=openapi.Schema(type=openapi.TYPE_STRING)),
'creators':
openapi.Schema(description='完成人',
type=openapi.TYPE_ARRAY,
items=openapi.Schema(type=openapi.TYPE_STRING)),
'published_year':
openapi.Schema(description='公布年份', type=openapi.TYPE_STRING),
'keywords':
openapi.Schema(description='关键词',
type=openapi.TYPE_ARRAY,
items=openapi.Schema(type=openapi.TYPE_STRING)),
'abstract':
openapi.Schema(description='简介', type=openapi.TYPE_STRING),
'province':
openapi.Schema(description='省市', type=openapi.TYPE_STRING),
'trade_name':
openapi.Schema(description='应用行业名称',
type=openapi.TYPE_ARRAY,
items=openapi.Schema(type=openapi.TYPE_STRING)),
'level':
openapi.Schema(description='成果水平', type=openapi.TYPE_STRING),
'contact_unit':
openapi.Schema(description='联系单位', type=openapi.TYPE_STRING),
'contact_address':
openapi.Schema(description='联系单位地址', type=openapi.TYPE_STRING),
'experts':
openapi.Schema(description='关联专家id',
type=openapi.TYPE_ARRAY,
items=openapi.Schema(type=openapi.TYPE_INTEGER)),
})
class GraphViewSet(APIView):
permission_classes = [permissions.IsAuthenticated]
@swagger_auto_schema(operation_description="get all graphs information",
responses={
200:
openapi.Response('list of all graphs information',
GraphSerializer)
})
def get(self, request):
graphs = Graph.objects.all()
serializer = GraphSerializer(graphs, many=True)
return Response(serializer.data)
@swagger_auto_schema(
operation_description="plot graph",
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'graphType':
openapi.Schema(type=openapi.TYPE_STRING,
description="Type of ploting graph"),
'mode':
openapi.Schema(type=openapi.TYPE_STRING,
description="Mode of ploting graph"),
'facilitys':
openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'{FacilityName}':
openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.TYPE_INTEGER,
description='resultids (example: [99, 101])'),
}),
}))
def post(self, request):
graphType = json.loads(request.body.decode('utf-8')).get('graphType')
if graphType == "NDS_3DCRT":
return graphService.plot_NDS_3DCRT(self, request)
elif graphType == "NDS_IMRT":
return graphService.plot_NDS_IMRT(self, request)
@swagger_auto_schema(
operation_description="delete graph according ids ",
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'graphs_list':
openapi.Schema(type=openapi.TYPE_ARRAY,
items=openapi.TYPE_INTEGER,
description='resultids (example: [99, 101])')
}))
def delete(self, request):
graphs_list = json.loads(
request.body.decode('utf-8')).get('graphs_list')
graphs_obj = Graph.objects.filter(pk__in=graphs_list)
for graph_obj in graphs_obj:
url = graph_obj.url
os.remove(url)
graph_obj.result.clear()
graph_obj.delete()
return Response(status=status.HTTP_200_OK)
from drf_yasg import openapi
CLASSROOM_PROP = {
'class_name':
openapi.Schema(type=openapi.TYPE_STRING, description='Classroom name'),
'homeroom_teacher_id':
openapi.Schema(type=openapi.TYPE_INTEGER,
description='Homeroom teacher id'),
'location':
openapi.Schema(type=openapi.TYPE_STRING, description='Location'),
}
CLASSROOM_REQUIRED = ['class_name', 'homeroom_teacher_id', 'location']
COURSE_PROP = {
'course_name':
openapi.Schema(type=openapi.TYPE_STRING, description='Course name'),
'group_course':
openapi.Schema(
type=openapi.TYPE_STRING,
description='Sc for Science, So for society and Ph for physical'),
}
TIMETABLE_PROP = {
'classroom_id':
openapi.Schema(type=openapi.TYPE_INTEGER, description='Classroom id'),
'teacher_id':
openapi.Schema(type=openapi.TYPE_INTEGER, description='Teacher id'),
'course_id':
openapi.Schema(type=openapi.TYPE_INTEGER, description='Course id'),
'day_of_week':
class SignupView(APIView):
# @swagger_auto_schema(operation_description="partial_update description override", responses={404: 'slug not found'})
# @swagger_auto_schema(method='post', manual_parameters=[test_param], responses={200: user_response})
# @api_view(['POST'])
@swagger_auto_schema(
operation_description="user signup",
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['password','username','gender','email','nickname'],
properties={
'username': openapi.Schema(type=openapi.TYPE_STRING),
'password': { "type": "string", "format": "password"},
'gender': openapi.Schema(type=openapi.TYPE_STRING),
'email': { "type": "string", "format": "email"},
'nickname': openapi.Schema(type=openapi.TYPE_STRING),
'birthdate': { "type": "string", "format": "date"}
},
),
security=[],
responses={200: user_response,400:user_response2}
)
# @swagger_auto_schema(request_body=UserSignupSerializer, tags=['Users'],responses={200: user_response,400:user_response2})
@csrf_exempt
def post(self, request):
serializer = UserSignupSerializer(data=request.data)
if serializer.is_valid():
u = serializer.save()
login(request, u)
u.status = "online"
token, created = Token.objects.get_or_create(user=u)
info = UserInfoSerializer(u)
return Response({
'message': 'your account have been created successfuly',
'data': {
'token': token.key
}
})
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST
)
@swagger_auto_schema(
operation_description="user update profile",
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'username': openapi.Schema(type=openapi.TYPE_STRING),
'password': { "type": "string", "format": "password"},
'gender': openapi.Schema(type=openapi.TYPE_STRING),
'email': { "type": "string", "format": "email"},
'nickname': openapi.Schema(type=openapi.TYPE_STRING),
'birthdate': { "type": "string", "format": "date"},
'interests':openapi.Schema(type=openapi.TYPE_STRING),
'biography':openapi.Schema(type=openapi.TYPE_STRING),
# 'user_avatar':
},
),
tags=['Profile'],
security=[],
responses={200: openapi.Response('account info has been updated')}
)
@permission_classes([IsAuthenticated])
@csrf_exempt
def put(self, request):
instance = request.user
serializer = UserSignupSerializer(instance, data=request.data, partial=True)
if serializer.is_valid():
u = serializer.save()
instance.save()
return Response(
{
'message': 'account info has been updated',
},
status=status.HTTP_200_OK
)
else:
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class DeliveryOptionView(GenericViewSet, ResponseViewMixin):
permission_classes = [IsAuthenticated]
serializer_class = DeliveryDetailSerializer
def get_queryset(self):
pass
@swagger_auto_schema(
tags=['user'],
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'shop':
openapi.Schema(type=openapi.TYPE_INTEGER),
'delivery_type':
openapi.Schema(type=openapi.TYPE_ARRAY,
items=openapi.Items(type=openapi.TYPE_STRING)),
'delivery_radius':
openapi.Schema(type=openapi.TYPE_STRING),
'delivery_charge':
openapi.Schema(type=openapi.TYPE_NUMBER),
'delivery_vehicle':
openapi.Schema(type=openapi.TYPE_ARRAY,
items=openapi.Items(type=openapi.TYPE_STRING)),
'vehicle_and_capacity':
openapi.Schema(type=openapi.TYPE_STRING),
'within_km':
openapi.Schema(type=openapi.TYPE_STRING),
'min_charge':
openapi.Schema(type=openapi.TYPE_STRING),
'extra_charge_per_km':
openapi.Schema(type=openapi.TYPE_STRING),
'free_delivery':
openapi.Schema(type=openapi.TYPE_BOOLEAN),
'free_delivery_for':
openapi.Schema(type=openapi.TYPE_NUMBER),
}))
def create(self, request):
try:
try:
delivery = DeliveryOption.objects.get(
shop=request.data.get('shop'))
serializer = DeliveryDetailSerializer(instance=delivery,
data=request.data)
except DeliveryOption.DoesNotExist:
serializer = DeliveryDetailSerializer(data=request.data)
if serializer.is_valid():
delivery = serializer.save()
delivery.save()
delivery_vehicle = request.data.get('delivery_vehicle')
for value in delivery_vehicle:
value['delivery_option'] = delivery.id
print(delivery_vehicle)
vehicle_details = VehicleDetailSerializer(
data=delivery_vehicle, many=True)
if vehicle_details.is_valid():
vehicle_details.save()
else:
return self.error_response(
code='HTTP_500_INTERNAL_SERVER_ERROR',
message=str(vehicle_details.errors))
else:
return self.error_response(
code='HTTP_500_INTERNAL_SERVER_ERROR',
message=str(serializer.errors))
return self.success_response(code='HTTP_200_OK',
data={'delivery_id': delivery.id},
message=DATA_SAVED_SUCCESSFULLY)
except Exception as e:
db_logger.exception(e)
return self.error_response(code='HTTP_500_INTERNAL_SERVER_ERROR',
message=GENERAL_ERROR)
def retrieve(self, request, pk=None):
try:
delivery = DeliveryOption.objects.get(shop_id=pk)
serializer = DeliveryRetrieveSerializer(delivery)
return self.success_response(code='HTTP_200_OK',
data=serializer.data,
message=SUCCESS)
except Shop.DoesNotExist:
return self.error_response(code='HTTP_500_INTERNAL_SERVER_ERROR',
message=GENERAL_ERROR)
openapi.IN_HEADER,
description='This is a member id number',
type=openapi.TYPE_STRING)
s_field = openapi.Parameter('s',
openapi.IN_QUERY,
description='This is the size of images.',
type=openapi.TYPE_STRING,
required=True)
product_detail_put_parameter = [id_member]
product_detail_get_parameter = [s_field]
# Schema
product_detail_schema = {
'name': openapi.Schema(type=openapi.TYPE_STRING, description='상품 이름'),
'addr': openapi.Schema(type=openapi.TYPE_STRING, description='상품 주소'),
'price': openapi.Schema(type=openapi.TYPE_INTEGER, description='상품 가격'),
'info': openapi.Schema(type=openapi.TYPE_STRING, description='상품 설명'),
'code': openapi.Schema(type=openapi.TYPE_STRING, description='상품 카테고리 코드'),
}
# Example
product_detail_example = {
'name': '잘 달리는 자전거',
'addr': '가락본동',
'price': 13231,
'info': '자전거가 날라가유 ~',
'code': 'LOCAL_SHOP',
}
# custom response schema
openapi.Schema(
title='Task creation response',
description='Task creation response',
type=openapi.TYPE_OBJECT,
properies={
'task_count':
openapi.Schema(title='task count',
description='Number of tasks added',
type=openapi.TYPE_INTEGER),
'annotation_count':
openapi.Schema(title='annotation count',
description='Number of annotations added',
type=openapi.TYPE_INTEGER),
'predictions_count':
openapi.Schema(title='predictions count',
description='Number of predictions added',
type=openapi.TYPE_INTEGER),
'duration':
openapi.Schema(title='duration',
description='Time in seconds to create',
type=openapi.TYPE_NUMBER),
'file_upload_ids':
openapi.Schema(title='file_upload_ids',
description='Database IDs of uploaded files',
type=openapi.TYPE_ARRAY,
items=openapi.Schema(title="File Upload IDs",
type=openapi.TYPE_INTEGER)),
'could_be_tasks_list':
openapi.Schema(
title='could_be_tasks_list',
description=
'Whether uploaded files can contain lists of tasks, like CSV/TSV files',
type=openapi.TYPE_BOOLEAN)
},
example={
'task_count': 50,
'annotation_count': 200,
'predictions_count': 100,
'duration': 3.5,
'file_upload_ids': [1, 2, 3]
}),
from drf_yasg import openapi
bad_request_response = openapi.Response(
"Bad request",
openapi.Schema(
title="ErrorMessage",
type=openapi.TYPE_OBJECT,
properties={
"non_field_errors":
openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.Schema(type=openapi.TYPE_STRING, ),
),
"field_name":
openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.Schema(type=openapi.TYPE_STRING, ),
),
},
example={
"non_field_errors": ["Some non filed error.", "Extra error."],
"field_name": ["This field is required.", "Extra error."],
},
))
too_many_requests_response = openapi.Response(
"Too Many Requests",
openapi.Schema(
title="ErrorMessage",
type=openapi.TYPE_OBJECT,
properties={
class LoginAPIView(APIView):
"""
Login API View : LoginSerializer, create token, authenticate user, set cache
"""
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'username':
openapi.Schema(type=openapi.TYPE_STRING, description="username"),
'password':
openapi.Schema(type=openapi.TYPE_STRING, description="password")
}))
def post(self, request):
"""
This method is used for login authentication.
:param request: It's accept username and password as parameter.
:return: It's return response that login is successfull or not.
"""
try:
# Login serializer
serializer = LoginSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
# Create token
token = jwt.encode({'username': serializer.data.get('username')},
settings.SECRET_KEY,
algorithm='HS256')
# Authenticate username & password
user = auth.authenticate(username=serializer.data.get('username'),
password=serializer.data.get('password'))
if user is not None:
# Set cache
# set_cache('username', serializer.data.get('username'))
# Login successfull
return Response(
{
'success': True,
'message': 'Login successfull!',
'data': {
'username': serializer.data.get('username'),
'token': token
}
},
status=status.HTTP_200_OK)
else:
# Login failed
return Response(
{
'success': False,
'message': 'Login failed!',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_400_BAD_REQUEST)
except ValidationError as e:
logger.exception(e)
return Response({
'success': False,
'message': serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.exception(e)
return Response(
{
'success': False,
'message':
'Oops! Something went wrong! Please try again...'
},
status=status.HTTP_400_BAD_REQUEST)
from drf_yasg import openapi
# POST auth/register/
RESPONSE_201 = openapi.Response(
description='Created',
schema=openapi.Schema(type=openapi.TYPE_OBJECT,
properties={
'name': openapi.Schema(type=openapi.TYPE_STRING),
'last_name':
openapi.Schema(type=openapi.TYPE_STRING),
'aka': openapi.Schema(type=openapi.TYPE_STRING),
}))
RESPONSE_400 = openapi.Response(
description='Bad Request',
schema=openapi.Schema(
type=openapi.TYPE_STRING,
enum=['Missing or invalid fields', 'This user already exist'],
))
RESPONSE_401 = openapi.Response(description='Unauthorized')
RESPONSE_403 = openapi.Response(description='Forbidden',
schema=openapi.Schema(
type=openapi.TYPE_STRING,
pattern='{detail: Could not log in.}'))
class UserDeleteAPIView(APIView):
"""
User Delete API View : UsernameSerializer, delete user instance
"""
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'username':
openapi.Schema(type=openapi.TYPE_STRING, description="username")
}))
def delete(self, request):
"""
This method is used to delete user instance.
:param request: It's accept username as parameter.
:return: It's return that user is successfully deleted or not.
"""
try:
# Username serializer
serializer = UsernameSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
# Get user instance according to username
user = get_object_by_username(serializer.data.get('username'))
# Delete user instance
user.delete()
# User deleted successfully
return Response(
{
'success': True,
'message': 'User deleted successfully!',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_200_OK)
except User.DoesNotExist as e:
logger.exception(e)
return Response(
{
'success': False,
'message': 'User does not exist!',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_400_BAD_REQUEST)
except ValidationError as e:
logger.exception(e)
return Response({
'success': False,
'message': serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.exception(e)
return Response(
{
'success': False,
'message':
'Oops! Something went wrong! Please try again...'
},
status=status.HTTP_400_BAD_REQUEST)
from Server.models import PricingModel
from Server.serializers import PricingSerializer
@swagger_auto_schema(method='post',
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'mobile_company':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
'mobile_model':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
'repairing_part':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
'repairing_price':
openapi.Schema(type=openapi.TYPE_INTEGER,
description='string'),
'repairing_description':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
}))
@api_view(['POST'])
def add_new_pricing(request):
try:
# fields = ['mobile_company', 'mobile_model', 'repairing_part', 'repairing_price', 'repairing_description']
mobile_company = request.data["mobile_company"]
class RegisterAPIView(APIView):
"""
Register API View : RegisterSerializer, check email & username already exist or not, create new user
"""
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'first_name':
openapi.Schema(type=openapi.TYPE_STRING, description="first name"),
'last_name':
openapi.Schema(type=openapi.TYPE_STRING, description="last name"),
'email':
openapi.Schema(type=openapi.TYPE_STRING, description="email"),
'username':
openapi.Schema(type=openapi.TYPE_STRING, description="username"),
'password':
openapi.Schema(type=openapi.TYPE_STRING, description="password")
}))
def post(self, request):
"""
This method is used to create new user instance.
:param request: It's accept first_name, last_name, email, username and password as parameter.
:return: It's return response that user created successfully or not.
"""
try:
# Register serializer
serializer = RegisterSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
# Check given email is already registered or not
if User.objects.filter(
email=serializer.data.get('email')).exists():
return Response(
{
'success': False,
'message': 'Gven email is already registered.',
'data': {
'email': serializer.data.get('email')
}
},
status=status.HTTP_400_BAD_REQUEST)
# Check given username is already taken or not
if User.objects.filter(
username=serializer.data.get('username')).exists():
return Response(
{
'success': False,
'message': 'Gven username is already taken',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_400_BAD_REQUEST)
# Create user instance
user = User.objects.create_user(
first_name=serializer.data.get('first_name'),
last_name=serializer.data.get('last_name'),
email=serializer.data.get('email'),
username=serializer.data.get('username'),
password=serializer.data.get('password'))
# Send data to queue
# json_data = json.dumps({'username': serializer.data.get('username'), 'user_email': serializer.data.get('email'), 'SECRET_KEY': settings.SECRET_KEY, 'EMAIL_HOST_USER': settings.EMAIL_HOST_USER})
# send_data_to_queue(data=json_data)
# Make user as not active
# user.is_active = False
user.save()
# User registration successfull
return Response(
{
'success': True,
'message': 'Registration successfull!',
'data': {
'username': serializer.data.get('username')
}
},
status=status.HTTP_200_OK)
except ValidationError as e:
logger.exception(e)
return Response({
'success': False,
'message': serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.exception(e)
return Response(
{
'success': False,
'message':
'Oops! Something went wrong! Please try again...'
},
status=status.HTTP_400_BAD_REQUEST)
serializer = ProjectMemberRoleSerializer(project_member.first())
return JsonResponse(serializer.data)
return HttpResponse(
"Please provide a valid 'is_admin' value.",
status=status.HTTP_400_BAD_REQUEST,
)
elif request.method == "DELETE":
project_member.delete()
return JsonResponse({}, status=status.HTTP_204_NO_CONTENT)
@swagger_auto_schema(
methods=["post"],
request_body=openapi.Schema(
type="object", properties={"user_id": openapi.Schema(type="string")}
),
responses={
201: openapi.Response(
"Returns the updated project with the new member.", ProjectSerializer
)
},
tags=["Project Members"],
)
@api_view(["POST"])
@permission_classes([permissions.IsAuthenticated])
def project_members(request, project_uuid):
project = get_object_or_404(Project, pk=project_uuid)
check_if_admin_of_project(request.user.id, project.uuid)
data = JSONParser().parse(request)
