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()
