class TicketUpdateUpdateSerializer(serializers.ModelSerializer):
created_by = UserMinSerializer(read_only=True,
default=serializers.CurrentUserDefault())
created_at = serializers.ReadOnlyField()
last_edited_by = UserMinSerializer(read_only=True)
attachments = AttachmentSerializerDetail(many=True,
required=False,
read_only=True)
class Meta:
model = TicketUpdate
fields = '__all__'
def get_users(self, request, pk):
del request, pk # unused
client = self.get_object()
return Response({
'users':
UserMinSerializer(instance=client.users, many=True).data
})
def get_users_not_in_client(self, request, pk):
del request, pk # unused
"""Retrieve regular active users without any client associated to them"""
self.get_object() # Checks permissions
users = get_user_model().objects.filter(is_active=True,
is_staff=False,
clients__isnull=True)
return Response(
{'users': UserMinSerializer(instance=users, many=True).data})
class StaffOrderSerializer(serializers.ModelSerializer):
# cart = StaffOrderItemSerializer(read_only=True, many=True) # NOTE(tomo): remove this field
user = UserMinSerializer(read_only=True)
client = ClientMinSerializer(read_only=True)
invoice = StaffInvoiceBriefSerializer(read_only=True)
fraud_check_result = serializers.JSONField(read_only=True)
items = StaffOrderItemSerializer(read_only=True, many=True)
total = serializers.DecimalField(read_only=True, decimal_places=2, max_digits=12)
class Meta:
model = Order
fields = '__all__'
class ResellerPublicKeySerializer(serializers.ModelSerializer):
created_at = serializers.DateTimeField(read_only=True,
default=CreateOnlyDefault(
timezone.now))
user = UserMinSerializer(read_only=True,
default=serializers.CurrentUserDefault())
class Meta:
model = PublicKey
fields = ('id', 'name', 'public_key', 'created_at', 'fingerprint',
'user')
read_only_fields = (
'id',
'fingerprint',
'user',
)
validators = [
UniqueTogetherValidator(
queryset=PublicKey.objects.all(),
fields=('name', 'user'),
message=_('A key already exists with the same name'))
]
def to_internal_value(self, data):
data = super().to_internal_value(data)
data['fingerprint'] = get_fingerprint(data['public_key'])
return data
@staticmethod
def validate_public_key(value):
if not is_valid_ssh_public_key(value):
raise serializers.ValidationError(_('Invalid SSH public key'))
return value
@staticmethod
def validate_name(value):
# NOTE(tomo): OpenStack only allows "_- " digits and numbers
safechars = "_- " + string.digits + string.ascii_letters
clean_value = "".join(x for x in value if x in safechars)
if clean_value != value:
raise serializers.ValidationError(
_("Name contains unsafe characters"))
return value
class ActivityLogSerializer(serializers.ModelSerializer):
log = serializers.SerializerMethodField()
type = serializers.SerializerMethodField()
user = UserMinSerializer()
tasks_count = serializers.SerializerMethodField()
class Meta:
model = Log
fields = ('id', 'created_at', 'user', 'ip', 'type', 'parameters',
'log', 'tasks_count')
read_only_fields = ('id', 'created_at', 'tasks_count')
@staticmethod
def get_tasks_count(instance: Log) -> bool:
return instance.tasks.count()
@staticmethod
def get_log(instance):
return smart_text(instance)
@staticmethod
def get_type(instance):
return instance.log_class.type
class TicketUpdateSerializer(serializers.ModelSerializer):
attachments = AttachmentSerializerDetail(many=True,
required=False,
read_only=True)
created_by = UserMinSerializer(read_only=True,
default=serializers.CurrentUserDefault())
created_by_display = serializers.SerializerMethodField(required=False,
read_only=True)
new_status_display = serializers.SerializerMethodField(required=False,
read_only=True)
new_status = serializers.CharField(required=False,
read_only=True,
allow_null=True,
allow_blank=True)
new_department_display = serializers.SerializerMethodField(required=False,
read_only=True)
new_department = serializers.CharField(required=False,
read_only=True,
allow_null=True,
allow_blank=True)
created_at = serializers.ReadOnlyField()
new_client = serializers.CharField(required=False,
read_only=True,
allow_null=True,
allow_blank=True)
new_client_display = serializers.SerializerMethodField(required=False,
read_only=True)
last_edited_by = UserMinSerializer(read_only=True)
new_cc = serializers.CharField(required=False,
read_only=True,
allow_null=True,
allow_blank=True)
email_generated = serializers.SerializerMethodField(required=False,
read_only=True)
ticket_activity = serializers.SerializerMethodField(required=False,
read_only=True)
update_owner_email = serializers.SerializerMethodField(required=False,
read_only=True)
is_staff_generated = serializers.SerializerMethodField(required=False,
read_only=True)
class Meta:
model = TicketUpdate
fields = (
'id',
'created_at',
'created_by',
'is_staff_generated',
'created_by_display',
'reply_text',
'ticket_activity',
'new_status',
'new_status_display',
'new_internal_status',
'description_changed',
'new_department',
'new_department_display',
'title_changed',
'new_client',
'new_client_display',
'last_edited',
'last_edited_by',
'new_cc',
'attachments',
'email_generated',
'update_owner_email',
)
@staticmethod
def get_is_staff_generated(model: TicketUpdate):
if model.created_by:
return model.created_by.is_staff
if model.email_message:
user = AppUser.objects.filter(
email=model.email_message.sender_address).first()
if user:
return user.is_staff
return False
return False
@staticmethod
def get_update_owner_email(model: TicketUpdate):
if model.created_by:
return model.created_by.email
if model.email_message and not model.created_by:
return model.email_message.sender_address
return None
@staticmethod
def get_ticket_activity(model: TicketUpdate):
if model.reply_text and (not model.new_status
or not model.new_internal_status):
return False
return True
@staticmethod
def get_email_generated(model: TicketUpdate):
return True if model.email_message is not None else False
@staticmethod
def get_created_by_display(model: TicketUpdate):
if model.created_by:
user = model.created_by
return user.get_full_name() if user.get_full_name(
) else user.username
elif model.email_message:
return model.email_message.sender_address
else:
return _('N/A')
@staticmethod
def get_new_status_display(model: TicketUpdate):
return TicketStatus.status_map.get(model.new_status, _('n/a'))
@staticmethod
def get_new_department_display(model: TicketUpdate):
return str(model.new_department) if model.new_department else _('n/a')
@staticmethod
def get_new_client_display(model: TicketUpdate):
return str(model.new_client) if model.new_client else _('n/a')
class TicketSerializer(serializers.ModelSerializer):
updates = TicketUpdateSerializer(many=True, required=False, read_only=True)
department_display = serializers.SerializerMethodField(required=False,
read_only=True)
status_display = serializers.SerializerMethodField(required=False,
read_only=True)
client_display = serializers.SerializerMethodField(required=False,
read_only=True)
description = serializers.CharField(max_length=10240,
allow_null=True,
allow_blank=True,
required=False)
created_at = serializers.ReadOnlyField()
created_by = UserMinSerializer(read_only=True,
default=serializers.CurrentUserDefault())
department = serializers.PrimaryKeyRelatedField(
queryset=Department.objects.all(), required=True, allow_null=False)
assigned_to_display = serializers.SerializerMethodField(required=False,
read_only=True)
assigned_to = serializers.PrimaryKeyRelatedField(read_only=True)
associated_attachment_ids = serializers.CharField(write_only=True,
required=False,
allow_null=True)
service = ClientFilteredServicesPrimaryKeyRelatedField(
queryset=Service.objects, allow_null=True, required=False)
main_attachments = serializers.SerializerMethodField(read_only=True,
required=False)
created_by_email = serializers.SerializerMethodField(required=False,
read_only=True)
ticket_owner_email = serializers.SerializerMethodField(required=False,
read_only=True)
is_staff_generated = serializers.SerializerMethodField(required=False,
read_only=True)
created_by_display = serializers.SerializerMethodField(required=False,
read_only=True)
class Meta:
model = Ticket
fields = (
'id',
'created_at',
'is_staff_generated',
'created_by',
'created_by_display',
'client',
'client_display',
'title',
'description',
'department',
'department_display',
'status',
'status_display',
'updates',
'cc_recipients',
'assigned_to',
'created_by_email',
'ticket_owner_email',
'assigned_to_display',
'associated_attachment_ids',
'main_attachments',
'service',
)
@staticmethod
def get_created_by_display(model: Ticket):
if model.created_by:
user = model.created_by # type: AppUser
return user.get_full_name() if user.get_full_name(
) else user.username
elif model.email_message:
return model.email_message.sender_address
else:
return _('n/a')
@staticmethod
def get_is_staff_generated(model: Ticket):
if model.created_by:
return model.created_by.is_staff
if model.email_message:
user = AppUser.objects.filter(
email=model.email_message.sender_address).first()
if user:
return user.is_staff
return False
return False
@staticmethod
def get_main_attachments(model: Ticket):
att = Attachment.objects.filter(ticket=model,
ticket_update=None,
ticket_note=None)
if not att:
return None
return AttachmentBriefSerializer(instance=att,
many=True,
read_only=True).data
@staticmethod
def get_ticket_owner_email(model: Ticket):
if model.created_by:
return model.created_by.email
if model.email_message and not model.created_by:
return model.email_message.sender_address
return None
@staticmethod
def get_created_by_email(model: Ticket):
# returns None if the ticket was not generated from a received email
return model.email_message.sender_address if model.email_message is not None else None
@staticmethod
def validate_status(status):
if not status:
return status
if not TicketStatus.status_map.get(status, None):
raise ValidationError(_('Invalid status.'))
return status
@staticmethod
def validate_cc_recipients(recipients):
if not recipients:
return recipients
if recipients[-1] == ',':
raise ValidationError(detail=_('No email after the last comma'))
email_regex = re.compile(r".+\@.+\..+")
emails_list = recipients.split(',')
for email in emails_list:
if not email_regex.match(email):
raise ValidationError(detail=_('Invalid list of emails'))
return recipients
@staticmethod
def get_assigned_to_display(model: Ticket):
if model.assigned_to:
user = model.assigned_to
return user.get_full_name() if user.get_full_name(
) else user.username
else:
return _('N/A')
@staticmethod
def get_client_display(model: Ticket):
return str(model.client) if model.client else _('n/a')
@staticmethod
def get_department_display(model: Ticket):
return str(model.department) if model.department else _('n/a')
@staticmethod
def get_status_display(model: Ticket):
return TicketStatus.status_map.get(model.status, _('n/a'))
def get_users(user_group):
qs = AppUser.objects.filter(user_groups=user_group)
return UserMinSerializer(instance=qs, many=True).data