class SignatureSerializer(BaseSerializer):
"""
"""
key_data = serializers.FilePathField(path=DEFAULT_PATH)
cert_data = serializers.FilePathField(path=DEFAULT_PATH)
password = serializers.CharField()
class GraCreationSerializer(serializers.ModelSerializer):
teacher_username = serializers.CharField(max_length=32)
student_username = serializers.CharField(max_length=32)
file_url = serializers.FilePathField(settings.MEDIA_ROOT)
class Meta:
model = GraProject
exclude = ('select_file', 'start_file', 'end_file', 'task_file',
'check_file', 'update_time', 'student', 'pro_state',
'teacher')
def validate(self, data):
teacher = User.objects.filter(
username=data['teacher_username']).first()
if teacher is None:
raise serializers.ValidationError(
"teacher({}) does not exist!".format(data['teacher_username']))
student = User.objects.filter(
username=data['student_username']).first()
gra_pro = GraProject.objects.filter(student=student).first()
if gra_pro is not None:
raise serializers.ValidationError(
"student({}) has already had a graduation project!".format(
student.username))
# file_url = data['select_file']
return data
class AnnexSer(serializers.Serializer):
filename = serializers.FilePathField("./")
filesize = serializers.SerializerMethodField('get_file_size')
file = serializers.FileField()
def get_file_size(self, obj):
return "{} kb".format(obj.file.size/1000)
class ImportLocalSerializer(serializers.Serializer):
filepath = serializers.FilePathField(path="{}/uploads".format(
settings.MEDIA_ROOT),
recursive=True)
name = serializers.CharField()
operating_system = serializers.ChoiceField(
choices=["Linux", "Mac", "Windows"])
def make_string_validator(cls, settings: ParamSettings):
if settings.regex:
return serializers.RegexField(
settings.regex,
default=settings.default,
max_length=settings.max_length,
min_length=settings.min_length,
)
if settings.format is None:
return serializers.CharField(
default=settings.default,
max_length=settings.max_length,
min_length=settings.min_length,
trim_whitespace=settings.trim_whitespace,
)
if settings.format == "email":
return serializers.EmailField(
default=settings.default,
max_length=settings.max_length,
min_length=settings.min_length,
)
if settings.format == "slug":
return serializers.SlugField(
default=settings.default,
max_length=settings.max_length,
min_length=settings.min_length,
)
if settings.format == "url":
return serializers.URLField(
default=settings.default,
max_length=settings.max_length,
min_length=settings.min_length,
)
if settings.format == "uuid":
return serializers.UUIDField(default=settings.default)
if settings.format == "file_path":
return serializers.FilePathField(
default=settings.default,
path=settings.path,
match=settings.match,
recursive=settings.recursive,
allow_files=settings.allow_files,
allow_folders=settings.allow_folders,
)
if settings.format == "ipv6":
return serializers.IPAddressField(default=settings.default, protocol="IPv6")
if settings.format == "ipv4":
return serializers.IPAddressField(default=settings.default, protocol="IPv4")
if settings.format == "ip":
return serializers.IPAddressField(default=settings.default, protocol="both")
class DirectoryInputSerializer(serializers.ModelSerializer):
value = serializers.FilePathField(
settings.MEDIA_ROOT, allow_folders=True, allow_files=False,
)
class Meta:
model = DirectoryInput
fields = "id", "key", "value", "run", "definition"
class FileInfoWithDateSerializer(serializers.ModelSerializer):
path = serializers.FilePathField(TARGET_FILE_DIRECTORY)
date = serializers.DateField()
savetime = serializers.IntegerField()
class Meta:
model = FileInfo
fields = '__all__'
class AdviceSerializer(serializers.HyperlinkedModelSerializer):
# def __repr__(self):
# import pdb
# pdb.set_trace()
media = serializers.FilePathField(path="/home/flush")
class Meta:
fields = "__all__"
model = Advice
class TestFilePathField(FieldValues):
"""
Valid and invalid values for `FilePathField`
"""
valid_inputs = {
__file__: __file__,
}
invalid_inputs = {
'wrong_path': ['"wrong_path" is not a valid path choice.']
}
outputs = {}
field = serializers.FilePathField(
path=os.path.abspath(os.path.dirname(__file__)))
class ChatListSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(read_only=True)
message_field = serializers.CharField(read_only=True)
url_field = serializers.URLField(read_only=True)
file_field = serializers.FilePathField(read_only=True, path='/Media/')
wish = WishSerializer(read_only=True)
creation_date = serializers.DateTimeField(read_only=True)
user = UserSerializer(read_only=True)
class Meta:
model = EventChat
fields = ('id', 'message_field', 'url_field', 'file_field', 'wish',
'event', 'user', 'type', 'creation_date')
class GraStateChangeSerializer(serializers.Serializer):
pro_id = serializers.IntegerField()
username = serializers.HiddenField(
default=serializers.CurrentUserDefault())
file_url = serializers.FilePathField(settings.MEDIA_ROOT)
op_code = serializers.ChoiceField(choices=OperationCode.model_choices())
def validate(self, data):
gra_pro = GraProject.objects.filter(id=data['pro_id']).first()
if gra_pro is None:
raise serializers.ValidationError(
"project({}) does not exist!".format(data['pro_id']))
if gra_pro.teacher.username != str(data['username']):
raise serializers.ValidationError("project id ({}) error!".format(
data['pro_id']))
return data
class AnsibleRepositorySerializer(RepositorySerializer):
"""
Serializer for Ansible Repositories.
"""
last_synced_metadata_time = serializers.DateTimeField(
help_text=_("Last synced metadata time."), allow_null=True, required=False
)
keyring = serializers.FilePathField(
path=settings.ANSIBLE_CERTS_DIR,
help_text=_("Location of keyring used to verify signatures uploaded to this repository"),
allow_blank=True,
default="",
required=False,
)
class Meta:
fields = RepositorySerializer.Meta.fields + ("last_synced_metadata_time", "keyring")
model = AnsibleRepository
class EduCreationSerializer(serializers.ModelSerializer):
username = serializers.HiddenField(
default=serializers.CurrentUserDefault())
file_url = serializers.FilePathField(settings.MEDIA_ROOT)
class Meta:
model = EduProject
exclude = ('apply_file', 'update_time', 'pro_state', 'middle_file',
'end_file', 'abnormal_file', 'person_in_charge')
def validate(self, data):
PIC = User.objects.filter(username=data['username']).first()
edu_pro = EduProject.objects.filter(person_in_charge=PIC).first()
if edu_pro:
raise serializers.ValidationError(
"student ({}) has been in charge of a SRTP project.".format(
PIC.real_name))
if data['create_year'] > data['end_year']:
raise serializers.ValidationError("开始时间不能在结束时间之前!")
return data
class TranscriptSerializer(serializers.Serializer):
id = serializers.ReadOnlyField()
transcription = serializers.CharField(max_length=500,default='empty', validators=[check_charset, check_only_one_or_zero_space, check_end_for_given_chars_or_for_an_uppercase_character])
audio = serializers.FilePathField(path='./media')
transcribed = serializers.BooleanField(default=False)
user = serializers.CharField(max_length=150, default=None)
def create(self, validated_data):
return Transcript.objects.create(**validated_data)
def update(self, instance, validated_data):
instance.transcription = validated_data.get('transcription', instance.transcription)
instance.audio = validated_data.get('audio', instance.audio)
instance.transcribed = validated_data.get('transcribed', instance.transcribed)
instance.user = validated_data.get('user', instance.user)
instance.id = validated_data.get('id', instance.id)
instance.save()
return instance
class Meta:
model = Transcript
fields = ('id','transcription', 'audio', 'transcribed', 'user')
class FileInfoSerializer(serializers.ModelSerializer):
path = serializers.FilePathField(TARGET_FILE_DIRECTORY)
class Meta:
model = FileInfo
fields = '__all__'
class ProjectFromDirectorySerializer(serializers.ModelSerializer):
User = get_user_model()
owner = serializers.CharField(max_length=150)
name = serializers.CharField(max_length=100)
shared = serializers.BooleanField(required=True)
directory = serializers.FilePathField(
settings.MEDIA_ROOT,
recursive=True,
allow_folders=True,
allow_files=False,
)
class Meta:
model = Project
fields = '__all__'
def create(self, validated_data):
owner = User.objects.get(username=validated_data['owner'])
project = Project.objects.create(
owner=owner,
name=validated_data['name'],
is_shared=validated_data['shared'],
)
project_source_path = os.path.join(
project.get_path(),
settings.SOURCE_DIR,
)
os.makedirs(project_source_path, mode=0o775, exist_ok=True)
import glob
for filepath in glob.iglob(
os.path.join(validated_data['directory'], '') + '**/*',
recursive=True,
):
if os.path.realpath(filepath) == os.path.realpath(
validated_data['directory']):
continue
if os.path.realpath(filepath).startswith(
os.path.realpath(project_source_path)):
continue
if '__pycache__' in filepath:
continue
if os.path.isdir(filepath):
os.mkdir(
os.path.join(
project_source_path,
os.path.relpath(
filepath,
validated_data['directory'],
),
))
else:
with open(filepath) as module_filepath:
m = Module.objects.create(
owner=owner,
project=project,
source=ContentFile(module_filepath.read(),
name=os.path.relpath(
filepath,
validated_data['directory'],
)),
time=timezone.now(),
)
return project
class FileOutputSerializer(serializers.ModelSerializer):
value = serializers.FilePathField(settings.MEDIA_ROOT)
class Meta:
model = FileOutput
fields = "id", "key", "value", "run", "definition"
class FileInputDefinitionSerializer(serializers.ModelSerializer):
default = serializers.FilePathField(settings.MEDIA_ROOT, required=False)
class Meta:
model = FileInputDefinition
fields = "__all__"
class GroupSearchResultSerializer(serializers.ModelSerializer):
group_search_result_log = serializers.FilePathField(TARGET_FILE_DIRECTORY)
class Meta:
model = GroupSearchResult
fields = '__all__'
