class OrderRecordSerializer(serializers.ModelSerializer): project1 = ProjectSerializer() project2 = ProjectSerializer() project3 = ProjectSerializer() project4 = ProjectSerializer() class Meta: model = OrderRecord fields = [ 'id', 'order', 'project1', 'course_num1', 'project2', 'course_num2', 'project3', 'course_num3', 'project4', 'course_num4', 'all_amount' ] def to_representation(self, instance): data = super().to_representation(instance) if data['course_num1']: data['project1']['course_number'] = data['course_num1'] data['project1']['project_column'] = 'project1_id' if data['course_num2']: data['project2']['course_number'] = data['course_num2'] data['project2']['project_column'] = 'project2_id' if data['course_num3']: data['project3']['course_number'] = data['course_num3'] data['project3']['project_column'] = 'project3_id' if data['course_num4']: data['project4']['course_number'] = data['course_num4'] data['project4']['project_column'] = 'project4_id' return data
def put(self, request, pk, format=None): project = project.objects.get(id=pk) serializer = ProjectSerializer(project, data=request.data) if serializer.is_valid(): serializer.save() return Response( { 'status': '200', 'msg': 'showing data', 'data': serializer.data, }, status.HTTP_200_OK, )
class CrawlerProjectDtSerializer(serializers.ModelSerializer): """ 项目详情 """ project = ProjectSerializer() class Meta: model = CrawlerProject fields = '__all__'
class RelationSerializer(serializers.Serializer): authors = PersonSerializer(many=True) keywords = LabelSerializer(many=True) parties = OrganisationSerializer(many=True) themes = LabelSerializer(many=True) projects = ProjectSerializer(many=True) children = serializers.ListField(child=serializers.CharField()) parents = serializers.ListField(child=serializers.CharField())
def create(self, request, *args, **kwargs): serializer = ProjectSaveSerializer(request, data=request.data) if serializer.is_valid(): project = serializer.save() project_object = ProjectSerializer(project) if project_object: return Response(project_object.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ProjectBugSerializer(serializers.ModelSerializer): handler = UserSerializer() tester = UserSerializer() checker = UserSerializer() project = ProjectSerializer() task = ProjectTaskSerializer() class Meta: model = ProjectBug depth = 1 fields = "__all__"
class CrawlerDtSerializer(serializers.ModelSerializer): # 格式化时间输出 add_time = serializers.DateTimeField(format="%Y-%m-%d ", read_only=True, default='') built_at = serializers.DateTimeField(format="%Y-%m-%d", read_only=True, default='') generated_at = serializers.DateTimeField(format="%Y-%m-%d", read_only=True, default='') server = ServerSerializer(many=True) project = ProjectSerializer(many=True) class Meta: model = Crawler fields = '__all__'
def patch_title(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) new_title = request.data.get('title') if not new_title: return Response({}, status=status.HTTP_400_BAD_REQUEST) project.title = new_title project.save() serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, pk, *args, **kwargs): project = Project.objects.get(id=pk) serializer = ProjectSerializer(project) return Response( { 'status': '200', 'msg': 'showing data', 'data': serializer.data, }, status.HTTP_200_OK, )
def list(self, request, format=None): queryset = Project.objects.all() serializer = ProjectSerializer(queryset, many=True) return Response( { 'status': '200', 'msg': 'showing data', 'data': serializer.data, }, status.HTTP_200_OK, )
def remove_keyword(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) keyword = get_object_or_404(project.keywords, id=kwargs.get('keyword_id')) new_count = keyword.count - 1 keyword.count = new_count keyword.save() project.keywords.remove(keyword) serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def remove_ability(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) ability = get_object_or_404(project.abilities, id=kwargs.get('ability_id')) new_count = ability.count - 1 ability.count = new_count ability.save() project.abilities.remove(ability) serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def patch_date(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) new_started_at = request.data.get('started_at') new_ends_at = request.data.get('ends_at') if not new_started_at or not new_ends_at: return Response({}, status=status.HTTP_400_BAD_REQUEST) project.started_at = new_started_at project.ends_at = new_ends_at project.save() serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def indexViewAll(request, sig_name): projects = {} if sig_name=='Catalyst': start_year = 2019 else: start_year = 2018 for year in range(start_year,datetime.today().year+1): projects_obj = Project.objects.filter( sigs__name=sig_name, year=year ).order_by('name') projects_data = ProjectSerializer(projects_obj,many=True).data projects[str(year)+'-'+str(year+1)[2:]] = projects_data return Response(projects)
def indexViewCurrent(request, sig_name): this_year = datetime.now().year this_month = datetime.now().month if this_month<7: this_year = this_year-1 sig = SIG.objects.get( name=sig_name ) projects_obj = Project.objects.filter( sigs__name=sig.name, year=this_year ).order_by('name') projects_data = ProjectSerializer(projects_obj,many=True).data return Response(projects_data)
def patch_schedules(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) schedule_data = request.data.get('schedule') schedule = project.schedule project_serializer = ProjectSerializer(project) schedule_serializer = ProjectScheduleSaveSerializer(schedule, data=schedule_data) if schedule_serializer.is_valid(): schedule_serializer.save() return Response(project_serializer.data, status=status.HTTP_200_OK) else: return Response(schedule_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def patch_location(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) new_location_code = request.data.get('location_code') if not new_location_code: return Response({}, status=status.HTTP_400_BAD_REQUEST) new_location = get_object_or_404(Location, address_1_code=new_location_code, address_2_code__isnull=True) project.location = new_location project.save() serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def patch_descriptions(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) descriptions_data = request.data.get('descriptions') ProjectDescription.objects.filter(project=project).delete() for description_data in descriptions_data: description = ProjectDescription( project=project, question_id=description_data.get('question'), answer=description_data.get('answer'), ) description.save() serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def mutate(root, info, data): # TODO : Add can update or not try: instance = Project.objects.get(id=data['id']) except Project.DoesNotExist: return UpdateClient(errors=[ CustomErrorType(field='nonFieldErrors', messages=gettext('Project Does not exist')) ]) serializer = ProjectSerializer(instance=instance, data=data, context={'request': info.context}, partial=True) if errors := mutation_is_not_valid(serializer): return UpdateProject(errors=errors, ok=False)
class TaskDetailSerializer(serializers.ModelSerializer): assignee = UserSerializer() initiator = UserSerializer() project = ProjectSerializer() release = ReleaseSerializer() sprint = SprintSerializer() parent_task = TaskSerializer() sub_tasks = TaskSerializer(many=True) class Meta: model = Task fields = '__all__' extra_kwargs = { 'status': {'default': 0, }, }
def update(self, request, pk=None, *args, **kwargs): try: params = request.data if request.data else request.POST kw = {} assigned_to = params.get('assigned_to', []) project = Project.objects.filter(pk=pk) for key, val in params.items(): if key in ['name', 'description']: if val.strip(): kw[key] = val else: return JsonResponse( {'message': 'Project {} is not valid'.format(key)}, status=400) if key in ['start_date', 'end_date', 'completed_on']: if val.strip(): kw[key] = datetime.strptime(val, '%d-%m-%Y') else: return JsonResponse( {'message': 'Project {} is not valid'.format(key)}, status=400) kw['is_completed'] = True if params.get( 'is_completed', '') == 'true' else False kw['modified_by'] = request.user project.update(**kw) project = project.first() if assigned_to: for x in assigned_to: project.assigned_to.add(Employee.objects.get(id=x)) project.assigned_by = request.user.employee project.assigned_on = datetime.now() project.save() return JsonResponse( { "Message": 'Data Updated Successfully....', "data": ProjectSerializer(project).data }, status=200) except Exception as e: return JsonResponse({"Message": str(e)}, status=400)
def patch_media(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) media_data = request.data.get('media') project.medai.all().delete() for media_data_object in media_data: type_data = media_data_object.get('type') url_data = media_data_object.get('url') media = Media( type_id=type_data, url=url_data, ) media.save() project.media.add(media) serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def patch_contacts(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) contacts_data = request.data.get('contacts') project.contacts.all().delete() for contact_data in contacts_data: type_data = contact_data.get('type') information_data = contact_data.get('information') contact = Contact( type_id=type_data, information=information_data, ) contact.save() project.contacts.add(contact) serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def add_ability(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) ability_string = request.data.get('ability') try: project.abilities.get(name=ability_string) return Response({}, status=status.HTTP_409_CONFLICT) except ObjectDoesNotExist: ability, created = Ability.objects.get_or_create( name=ability_string) new_count = ability.count + 1 ability.count = new_count ability.save() project.abilities.add(ability) serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def add_keyword(self, request, *args, **kwargs): project = get_object_or_404(Project, id=kwargs.get('project_id')) self.check_object_permissions(request, project) keyword_string = request.data.get('keyword') try: project.keywords.get(name=keyword_string) return Response({}, status=status.HTTP_409_CONFLICT) except ObjectDoesNotExist: keyword, created = Keyword.objects.get_or_create( name=keyword_string) new_count = keyword.count + 1 keyword.count = new_count keyword.save() project.keywords.add(keyword) serializer = ProjectSerializer(project) return Response(serializer.data, status=status.HTTP_200_OK)
def test_retrieve_project_list(self): """Test retrieving a list of projects""" project1 = Project.objects.create( project_name='test 1', project_description='description 1', ) project2 = Project.objects.create( project_name='test 2', project_description='description 2', ) project1.users.add(self.user) project2.users.add(self.user) res = self.client.get(PROJECTS_URL) projects = Project.objects.all().order_by('-project_name') serializer = ProjectSerializer(projects, many=True) self.assertEqual(res.status_code, status.HTTP_200_OK) self.assertEqual(res.data, serializer.data)
def suite_init(request, pk): try: suite = TestSuite.objects.get(id=pk) except TestSuite.DoesNotExist: return Http404 cases = ApiTestCases.objects.filter(suite_id=pk).all() project = Projects.objects.get(id=suite.project_id) suite_log = SuiteChangeLog.objects.filter(test_suite_id=pk).last() old_coding = suite_log.code_content if suite_log != None else None if not os.path.exists(project.project_root): os.makedirs(project.project_root) suite_file_path = os.path.join(project.project_root, '{}.py'.format(suite.suite_name)) if request.method == "GET": suite_content = CaseBuilder(suite_file_path).suite_build( suite.suite_name, suite.suite_desc) for case in cases: cases_content = CaseBuilder(suite_file_path).case_build( case.func_name, case.description) suite_content += cases_content data = { 'suite': testSuiteSerializers(suite).data, 'project': ProjectSerializer(suite.project).data, 'file_path': suite_file_path, 'file_content': suite_content, 'last': old_coding } return Response(data) elif request.method == "POST": if request.data.get("active") == "save": coding = request.data.get("coding") log = SuiteChangeLog.objects.create(test_suite_id=suite.id, code_content=coding) log.save() try: with open(suite_file_path, 'wb') as f: f.write(coding) f.close() except IOError as e: return Response({"status": "fail"}, status=status.HTTP_204_NO_CONTENT) return Response({"status": "ok"}, status=status.HTTP_204_NO_CONTENT)
class UserOrderCourseSerializer(serializers.ModelSerializer): project = ProjectSerializer() class Meta: model = Order fields = [ 'id', 'user', 'project', 'currency', 'payment', 'create_time', 'status', 'course_num', 'standard_fee', 'pay_fee', 'project', 'remark' ] def to_representation(self, instance): data = super().to_representation(instance) user_course = Course.objects.filter( usercourse__order=instance, usercourse__user=self.context['request'].user) user_course_data = OrderCourseSerializer( user_course, many=True).data if user_course else None data['user_course'] = user_course_data return data
class ExtensionPropertiesSerializer(serializers.Serializer): external_id = serializers.CharField() state = serializers.ChoiceField(required=False, choices=Document.States.choices) title = serializers.CharField(required=False) description = serializers.CharField(required=False) language = serializers.CharField(required=False, max_length=2) published_at = serializers.DateField(required=False) copyright = serializers.ChoiceField(required=False, choices=settings.COPYRIGHT_VALUES) authors = PersonSerializer(many=True, required=False) parties = OrganisationSerializer(many=True, required=False) projects = ProjectSerializer(many=True, required=False) themes = LabelSerializer(many=True, required=False) keywords = LabelSerializer(many=True, required=False) parents = serializers.ListField(child=serializers.CharField(), required=False) children = serializers.ListField(child=serializers.CharField(), required=False)
class ExtensionSerializer(DocumentBaseSerializer, ExtensionPropertiesSerializer): id = serializers.CharField(read_only=True) is_addition = serializers.BooleanField(required=False, default=False) properties = ExtensionPropertiesSerializer(read_only=True) external_id = serializers.CharField(write_only=True) state = serializers.CharField(write_only=True, required=False) title = serializers.CharField(write_only=True, required=False) description = serializers.CharField(write_only=True, required=False) language = serializers.CharField(write_only=True, required=False, max_length=2) published_at = serializers.DateField(write_only=True, required=False) copyright = serializers.ChoiceField(write_only=True, required=False, choices=settings.COPYRIGHT_VALUES) authors = PersonSerializer(many=True, write_only=True, required=False) parties = OrganisationSerializer(many=True, write_only=True, required=False) projects = ProjectSerializer(many=True, write_only=True, required=False) themes = LabelSerializer(many=True, write_only=True, required=False) keywords = LabelSerializer(many=True, write_only=True, required=False) parents = serializers.ListField(child=serializers.CharField(), write_only=True, required=False) children = serializers.ListField(child=serializers.CharField(), write_only=True, required=False) def validate_external_id(self, external_id): path_external_id = self.context["view"].kwargs.get("external_id") if path_external_id and path_external_id != external_id: raise ValidationError("External id in path and body do not match.") return external_id def validate_published_at(self, published_at): return published_at.strftime("%Y-%m-%d") def validate_relation_ids(self, ids): if not len(ids): return document_ids = { external_id for external_id in Document.objects.filter( reference__in=ids).values_list("reference", flat=True) } extension_ids = { external_id for external_id in Extension.objects.filter( id__in=ids).values_list("id", flat=True) } for external_id in ids: if external_id not in document_ids and external_id not in extension_ids: raise ValidationError( f"Document or Extension with id '{external_id}' does not exist." ) def validate_parents(self, parents): self.validate_relation_ids(parents) return parents def validate_children(self, children): self.validate_relation_ids(children) return children def validate(self, attrs): external_id = attrs["external_id"] if not attrs.get("is_addition", False): if not Document.objects.filter(reference=external_id).exists(): raise ValidationError( f"Could not find Document with external_id '{external_id}'. Did you mean to create an addition?" ) addition_properties = ["language", "published_at", "copyright"] for prop in addition_properties: if prop in attrs: raise ValidationError( f"Can't set {prop} property for anything but an addition extension." ) if self.context["request"].method == "POST": if Extension.objects.filter(id=external_id, deleted_at__isnull=True).exists(): raise ValidationError( f"Extension with id '{external_id}' already exists. Try to PUT the extension instead." ) return super().validate(attrs) def create(self, validated_data): external_id = validated_data["external_id"] is_addition = validated_data.pop("is_addition") # Detect whether a deleted addition extension exists and permanently delete it before creation if is_addition: Extension.objects.filter(id=external_id, deleted_at__isnull=False).delete() # Create the extension extension = super().create({ "id": external_id, "is_addition": is_addition, "reference": external_id, "properties": validated_data }) if not is_addition: Document.objects.filter(reference=external_id).update( modified_at=now(), extension=extension) return extension def update(self, instance, validated_data): is_addition = validated_data.pop("is_addition", None) if not is_addition: Document.objects.filter( reference=validated_data["external_id"]).update( modified_at=now()) instance.properties.update(validated_data) instance.save() return super().update(instance, validated_data) class Meta: model = Extension fields = ("id", "created_at", "modified_at", "properties", "is_addition", "external_id", "state", "title", "description", "language", "published_at", "copyright", "authors", "parties", "projects", "themes", "keywords", "parents", "children")