def my_profile(self, request): serializer = UserSerializer(request.user) return Response(serializer.data, status=status.HTTP_200_OK)
class OrderSerializer(serializers.ModelSerializer): creator_id = UserSerializer(read_only=True) order_positions = OrderProductSerializer(many=True, required=True) class Meta: model = Order fields = ( 'id', 'creator_id', 'order_positions', 'total_price', 'status', 'created_at', 'updated_at', ) read_only_fields = ('status', ) def validate_order_positions(self, order_positions): product_ids = [ order_position['product'].id for order_position in order_positions ] product_ids_set = set(product_ids) if len(product_ids_set) != len(product_ids): raise serializers.ValidationError( 'В заказе содержатся дубли товаров') return order_positions def create(self, validated_data): validated_data['creator_id'] = self.context['request'].user order_positions_data = validated_data.pop('order_positions') total_price = 0 for order_position_data in order_positions_data: product = Product.objects.filter( id=order_position_data['product'].id).first() total_price += product.price * order_position_data['quantity'] validated_data['total_price'] = total_price order = super().create(validated_data) raw_order_positions = [] for order_position_data in order_positions_data: order_position = OrderProduct( order=order, product=order_position_data['product'], quantity=order_position_data['quantity']) raw_order_positions.append(order_position) OrderProduct.objects.bulk_create(raw_order_positions) return order def update(self, instance, validated_data): if instance.status != validated_data['status']: if not self.context['request'].user.is_staff: raise serializers.ValidationError( 'Только администраторы могут менять статус заказа') return super().update(self.instance, validated_data)
def user(self, request): serializer = UserSerializer(request.user) return Response(serializer.data)
def get(self, request, offered, series): user = request.user # 判断用户角色做不同处理 user_roles = [role.get('id') for role in user.roles.values('id')] if min(user_roles) == 1: serializer = self.get_serializer(self.get_queryset(), many=True) offered_list = [ department.get('department_name') for department in serializer.data ] else: offered_list = [ department.get('department_name') for department in user.department.values('department_name') ] if offered == 'ALL': hardware_p_info = SQLHepler.fetch_all( SQL_Hardware_All_Product_Client, args=(offered_list, ), db_dict=Sidus_Dev_Database) elif offered != 'ALL' and series == 'ALL': if offered not in offered_list: return Response({ "status": RET.PARAMERR, "msg": Info_Map[RET.PARAMERR] }) hardware_p_info = SQLHepler.fetch_all(SQL_Hardware_Product_Client, args=offered, db_dict=Sidus_Dev_Database) else: if offered not in offered_list: return Response({ "status": RET.PARAMERR, "msg": Info_Map[RET.PARAMERR] }) hardware_p_info = SQLHepler.fetch_all( SQL_Hardware_Product_offered_series_Client, args=(offered, series), db_dict=Sidus_Dev_Database) info = [] # 获取参与人员列表信息 for data in hardware_p_info: uuid = data.get('uuid') instance = ProdPartner.objects.filter(pro_uuid=uuid) creator = None partner = [] if instance: serializer = ProdPartnerSerializer(instance=instance, many=True) partner = serializer.data[0].get('pro_user') creator = serializer.data[0].get('pro_create') # if creator in partner: # partner.remove(creator) # 获取创建者用户所在部门的高级用户 try: user = instance.first().pro_create if user: department_list = [ c_user.get('id') for c_user in user.department.values('id') ] # 添加部门的高级人员到参与者 temp_list = User.objects.filter( department__in=department_list, roles=2) for high_user in temp_list: high_user_data = UserSerializer( instance=high_user).data if high_user_data and high_user_data not in partner: partner.append(high_user_data) except Exception as e: return Response({"status": RET.UNKOWNERR, "msg": str(e)}) if creator in partner: partner.remove(creator) data.update(creator=creator, partner=partner) info.append(data) return Response({ "status": RET.OK, "msg": Info_Map[RET.OK], "data": info })
class TaskSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) name = serializers.CharField(max_length=200) users_order = serializers.CharField(required=False, allow_blank=True) mode = serializers.CharField() delay = serializers.IntegerField(required=False) cycle = serializers.IntegerField(required=False) use_retry_fail_executor = serializers.BooleanField(required=False) description = serializers.CharField() workflow_id = serializers.CharField(required=False) workflow = WorkflowSerializer(read_only=True) users = UserSerializer(many=True) executor = UserSerializer(read_only=True) last_date = serializers.DateTimeField(format=BASE_DATETIME_FORMAT, input_formats=[BASE_DATETIME_FORMAT], required=False) change_order_date = serializers.DateTimeField( format=BASE_DATETIME_FORMAT, input_formats=[BASE_DATETIME_FORMAT], required=False) created_at = serializers.DateTimeField(format=BASE_DATETIME_FORMAT, read_only=True) updated_at = serializers.DateTimeField(format=BASE_DATETIME_FORMAT, read_only=True) compleated = serializers.BooleanField(read_only=True) closed = serializers.BooleanField(read_only=True) to_retry_count_day = serializers.IntegerField(read_only=True) def get_workflow(self, user, id): try: return Workflow.objects.get(id=id, users__id__exact=user.id) except Workflow.DoesNotExist: raise Http404 def get_workflow_user(self, id, workflow): try: user = User.objects.get(id=id) if user not in workflow.users.all(): raise Http404 return user except Workflow.DoesNotExist: raise Http404 def create(self, validated_data): workflow_id = validated_data.pop('workflow_id') workflow = self.get_workflow(self.context['request'].user, workflow_id) validated_data['workflow'] = workflow user_list, user_ordering = [], [] for user_data in validated_data.pop('users', []): user_list.append(self.get_workflow_user(user_data['id'], workflow)) user_ordering.append(user_data['id']) validated_data['users_order'] = json.dumps(user_ordering) self.users = user_list return Task.objects.create(**validated_data) class Meta: model = Task
def jwt_response_payload_handler(token, user=None, request=None): return { 'token': token, 'user': UserSerializer(user).data }
def delete(self, request): serializer = UserSerializer(data=request.method) if serializer.is_valid(): serializer.delete() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request): userSerializer = UserSerializer(request.user) return Response(userSerializer.data)
def list(self, request): query = User.objects.all() # query = User.objects.filter(deleted=False) data = UserSerializer(query, many=True).data return Response(data)
def patch(self, request): serializer = UserSerializer(data=request.data, partial=True) if user and serializer.is_valid(): return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_404_NOT_FOUND)
def get(self, request, format=None): query_set = User.object.all() # query_set = User.object.get(id=1) userSerializer = UserSerializer(query_set, many=True) content = {'users': userSerializer.data} return Response(content)
from user.serializers import UserSerializer from user.models import User from rest_framework.renderers import JSONRenderer # TO Save a new User using UserSerializer data = { "name": "Admin 2 Kumar", "email": "*****@*****.**", "password": "******" } obj = UserSerializer(data=data) # To see a User data using UserSerializer u1 = User.objects.first() obj = UserSerializer(u1) json = JSONRenderer().render(obj.data)
def get_user(self, obj): user = obj.user serializer = UserSerializer(user, many=False) return serializer.data
def get(self, request): serializer = UserSerializer(request.user) return Response({'user': serializer.data})
def get(self, request): users = User.objects.all() serializer = UserSerializer(users, many=True) return Response(serializer.data)
def UserViewSet(request): queryset = User.objects.all().order_by('-date_joined') serializer = UserSerializer(queryset, many=True) return Response(serializer.data)
def get(self, request, pk, format=None): users = User.objects.get(pk=pk) serializer = UserSerializer(users) return Response(serializer.data)
class ProjectUserSerializer(UserModelSerializer): user = UserSerializer() class Meta: model = ProjectUser exclude = ("project", )
def get(request, *args, **kwargs): user = request.user serializer = UserSerializer(user) return Response(serializer.data)
def get_user(self, instance): return UserSerializer(instance=instance.user, exclude_fields=( 'token', 'email', 'followers', 'followees')).data
def get_me(request, format=None): user = User.objects.get(pk=request.user.id) serializer = UserSerializer(user, context={'request': request}) return Response(serializer.data)
def list(self, request, *args, **kwargs): user = UserModel.objects.get(id=self.request.user.id) return Response(UserSerializer(user.friends, many=True).data)
def partial_update(self, request, *args, **kwargs): instance = self.get_object() serializer = UserSerializer(instance, data=request.data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data)
def retrieve(self, request, *args, **kwargs): qs = self.get_queryset().filter(id=self.request.user.id).first() return Response(UserSerializer(qs).data)
class BasePaperSerializer(serializers.ModelSerializer): authors = serializers.SerializerMethodField() bullet_points = serializers.SerializerMethodField() csl_item = serializers.SerializerMethodField() discussion = serializers.SerializerMethodField() first_figure = serializers.SerializerMethodField() first_preview = serializers.SerializerMethodField() hubs = SimpleHubSerializer(many=True, required=False) summary = serializers.SerializerMethodField() uploaded_by = UserSerializer(read_only=True) user_vote = serializers.SerializerMethodField() user_flag = serializers.SerializerMethodField() promoted = serializers.SerializerMethodField() boost_amount = serializers.SerializerMethodField() file = serializers.SerializerMethodField() discussion_users = serializers.SerializerMethodField() unified_document_id = serializers.SerializerMethodField() unified_document = serializers.SerializerMethodField() class Meta: abstract = True exclude = ["references"] read_only_fields = [ "score", "user_vote", "user_flag", "users_who_bookmarked", "unified_document_id", "slug", "hypothesis_id", ] model = Paper # def get_uploaded_by(self, obj): # return UserSerializer(obj.uploaded_by, read_only=True).data def get_unified_document_id(self, instance): try: target_unified_doc = instance.unified_document return target_unified_doc.id if (target_unified_doc is not None) else None except Exception: return None def to_internal_value(self, data): data = self._transform_to_dict(data) data = self._copy_data(data) valid_authors = [] for author_id in data.get("authors", []): if isinstance(author_id, Author): author_id = author_id.id try: author = Author.objects.get(pk=author_id) valid_authors.append(author) except Author.DoesNotExist: print(f"Author with id {author_id} was not found.") data["authors"] = valid_authors valid_hubs = [] for hub_id in data.get("hubs", []): if isinstance(hub_id, Hub): hub_id = hub_id.id try: hub = Hub.objects.filter(is_removed=False).get(pk=hub_id) valid_hubs.append(hub) except Hub.DoesNotExist: print(f"Hub with id {hub_id} was not found.") data["hubs"] = valid_hubs return data def _transform_to_dict(self, obj): if isinstance(obj, QueryDict): authors = obj.getlist("authors", []) hubs = obj.getlist("hubs", []) raw_authors = obj.getlist("raw_authors", []) obj = obj.dict() obj["authors"] = authors obj["hubs"] = hubs obj["raw_authors"] = raw_authors return obj def _copy_data(self, data): """Returns a copy of `data`. This is a helper method used to handle files which, when present in the data, prevent `.copy()` from working. Args: data (dict) """ file = None try: file = data.pop("file") except KeyError: pass data = data.copy() data["file"] = file return data def get_authors(self, paper): serializer = AuthorSerializer( paper.authors.filter(claimed=True), many=True, read_only=False, required=False, context=self.context, ) return serializer.data def get_bullet_points(self, paper): return None def get_summary(self, paper): # return SummarySerializer( # paper.summary, # required=False, # context=self.context # ).data return None def get_csl_item(self, paper): if self.context.get("purchase_minimal_serialization", False): return None return paper.csl_item def get_discussion(self, paper): if self.context.get("purchase_minimal_serialization", False): return None threads_queryset = paper.threads.all() threads = ThreadSerializer( threads_queryset.order_by("-created_date")[:PAGINATION_PAGE_SIZE], many=True, context=self.context, ) return {"count": threads_queryset.count(), "threads": threads.data} def get_first_figure(self, paper): try: if len(paper.figure_list) > 0: figure = paper.figure_list[0] return FigureSerializer(figure).data except AttributeError: figure = paper.figures.filter(figure_type=Figure.FIGURE).first() if figure: return FigureSerializer(figure).data return None def get_first_preview(self, paper): try: if len(paper.preview_list) > 0: figure = paper.preview_list[0] return FigureSerializer(figure).data except AttributeError: figure = paper.figures.filter(figure_type=Figure.PREVIEW).first() if figure: return FigureSerializer(figure).data return None def get_user_flag(self, paper): if self.context.get("purchase_minimal_serialization", False): return None flag = None user = get_user_from_request(self.context) if user: try: flag_created_by = paper.flag_created_by if len(flag_created_by) == 0: return None flag = FlagSerializer(flag_created_by).data except AttributeError: try: flag = paper.flags.get(created_by=user.id) flag = FlagSerializer(flag).data except Flag.DoesNotExist: pass return flag def get_user_vote(self, paper): vote = None user = get_user_from_request(self.context) if user: try: vote_created_by = paper.vote_created_by if len(vote_created_by) == 0: return None vote = PaperVoteSerializer(vote_created_by).data except AttributeError: try: vote = paper.votes.get(created_by=user.id) vote = PaperVoteSerializer(vote).data except Vote.DoesNotExist: pass return vote def get_unified_document(self, obj): from researchhub_document.serializers import DynamicUnifiedDocumentSerializer serializer = DynamicUnifiedDocumentSerializer( obj.unified_document, _include_fields=['id', 'reviews'], context={}, many=False) return serializer.data def get_promoted(self, paper): return paper.get_promoted_score() def get_boost_amount(self, paper): return paper.get_boost_amount() def get_file(self, paper): file = paper.file if file: return paper.file.url return None def get_discussion_users(self, paper): contributions = Contribution.objects.filter( unified_document=paper.unified_document) contribution_users = contributions.values_list("user", flat=True).distinct() users = User.objects.filter(id__in=contribution_users) serializer = UserSerializer(users, many=True) data = serializer.data return data
def get_user(self, survey): if survey.user: return UserSerializer(survey.user, context=self.context).data return None
def perform_update(self, serializer): updated_by = UserSerializer(self.request.user).data serializer.save(created_by=updated_by)
def users_list(request): if request.method == 'GET': users = User.objects.all() users_serializer = UserSerializer(users, many=True) return JsonResponse(users_serializer.data, safe=False)
def get(self, request): user = request.user serializer = UserSerializer(user, context={'request': request}) return Response({'user': serializer.data})
def get(self, request): u""" 获取用户列表 --- parameters: - name: varieties_id description: 品类 paramType: query required: True - name: date description: 日期 paramType: query required: True - name: index description: 分页显示第几页 paramType: query required: false - name: number description: 每页显示几条数据 paramType: query required: false - name: descent description: 需要倒序的字段,用逗号分开,默认通过ID 正序 paramType: query required: false """ query_dict = request.query_params.dict().copy() date = query_dict.get('date', None) varieties_id = query_dict.get('varieties_id', '') user_id = request.user.id index = query_dict.get('index', 1) descent = query_dict.get('descent', None) number = query_dict.get('number', 10) # is_page = query_dict.get('is_page', '1') offset = (int(index) - 1) * int(number) order_by = 'u.id' ai_vals = get_ai_prediction(date, varieties_id) me_vals = get_user_prediction(user_id, date, varieties_id) res = [] if ai_vals: res.append(ai_vals) if me_vals: res.append(me_vals) if descent: order_by = '' for i in descent.split(','): order_by = order_by + ', %s desc' % i with connection.cursor() as cr: sql = """ select u.username, u.id as user_id, u.visit_time, u.victor_number, u.fail_number, u.win_percent, p.prediction, u.head_img, p.date from user as u left join alert_prediction_record as p on u.id=p.user_id where p.date = '%s' and p.varieties_id = %s and u.id != '%s' order by %s limit %s offset %s """ % (date, varieties_id, user_id, order_by, number, offset) cr.execute(sql) vals_lst = cr.fetchall() head = get_description(cr.description) vals = get_res(head, vals_lst) or [] res = res + vals for key in res: if key: key['recent_predict'] = get_recent_prediction( date, key['user_id'], 4) obj = User.objects.get(pk=key['user_id']) user_vals = UserSerializer(obj).data key.update(user_vals) if key.get('visible', None) == None: key['visible'] = False logger.info('正常返回分页:%s:' % (index)) return BackstageHTTPResponse(data=res, message=u'正常返回分页').to_response()