def get_author_detail(self, obj):
return UserSerializer(obj.author).data
class UserScoreSerializer(serializers.ModelSerializer):
voter_user = UserSerializer()
class Meta:
model = UserScore
def get(self, request):
Pimgs = User.objects.all().select_related()
Pimg = UserSerializer(Pimgs, many=True)
return Response(data=Pimg.data)
class LikeSerializer(serializers.ModelSerializer):
owner = UserSerializer(read_only=True)
class Meta:
model = Like
fields = '__all__'
class CommentSerializer(serializers.ModelSerializer):
comment_user = UserSerializer(allow_null=True)
class Meta:
model = Comment
class HostSerializer(serializers.ModelSerializer):
# RGmapId = serializers.IntegerField(source='id')
host = UserSerializer(source='host')
class Meta:
model = Invitation
fields = ('host')
class ArticleSerializer(serializers.ModelSerializer):
user = UserSerializer(required=False)
class Meta:
model = Article
fields = '__all__'
def get_user_detail(self, obj):
return UserSerializer(obj.user).data
def get_user_detail(self, obj):
user_obj = obj.user
user = UserSerializer(user_obj).data
return user
class BillingProfileSerializer(serializers.ModelSerializer):
user = UserSerializer()
class Meta:
model = BillingProfile
fields = ['id', 'user', 'email']
def get(self, request, format=None):
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
class HotelDetailSerializer(ModelSerializer):
url = hotel_detail_url
user = UserSerializer(read_only=True)
image1 = SerializerMethodField()
image2 = SerializerMethodField()
image3 = SerializerMethodField()
image4 = SerializerMethodField()
comments = SerializerMethodField()
class Meta:
model = Hotel
fields = [
'url',
'id',
'slug',
'user',
'title',
'lat',
'lng',
'content',
'price',
'address',
'city',
'state',
'publish',
'image1',
'image2',
'image3',
'image4',
'comments',
]
def get_html(self, obj):
return obj.get_markdown()
def get_image1(self, obj):
try:
image1 = obj.image1.url
except:
image1 = None
return image1
def get_image2(self, obj):
try:
image2 = obj.image2.url
except:
image2 = None
return image2
def get_image3(self, obj):
try:
image3 = obj.image3.url
except:
image3 = None
return image3
def get_image4(self, obj):
try:
image4 = obj.image4.url
except:
image4 = None
return image4
def get_comments(self, obj):
c_qs = Comment.objects.filter_by_instance(obj)
comments = CommentSerializer(c_qs, many=True).data
return comments
class ProjectSerializer(DetailSerializer, serializers.ModelSerializer):
users = UserSerializer(many=True, read_only=True)
organization = OrganizationSerializer(hide_detail=True, read_only=True)
country = CountryField(required=False)
def validate_name(self, value):
# Check that name is not restricted
invalid_names = settings.CADASTA_INVALID_ENTITY_NAMES
if slugify(value, allow_unicode=True) in invalid_names:
raise serializers.ValidationError(
_("Project name cannot be “Add” or “New”."))
# Check that name is unique org-wide
# (Explicit validation: see comment in the Meta class)
is_create = not self.instance
if is_create:
org_slug = self.context['organization'].slug
else:
org_slug = self.instance.organization.slug
queryset = Project.objects.filter(
organization__slug=org_slug,
name=value,
)
if is_create:
not_unique = queryset.exists()
else:
not_unique = queryset.exclude(id=self.instance.id).exists()
if not_unique:
raise serializers.ValidationError(
_("Project with this name already exists "
"in this organization."))
return value
class Meta:
model = Project
fields = (
'id',
'organization',
'country',
'name',
'description',
'archived',
'urls',
'contacts',
'users',
'access',
'slug',
'extent',
)
read_only_fields = ('id', 'country', 'slug')
detail_only_fields = ('users', )
# Suppress automatic model-derived UniqueTogetherValidator because
# organization is a read-only field in the serializer.
# Instead, perform this validation explicitly in validate_name()
validators = []
def create(self, validated_data):
organization = self.context['organization']
return Project.objects.create(organization_id=organization.id,
**validated_data)
def to_representation(self, instance):
data = super().to_representation(instance)
s_data = UserSerializer(instance.inspector).data
data['inspector'] = s_data
data['solution']
return data
def register_user(request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response(serializer.data, status=201)
class CustomProfileSerializer(serializers.ModelSerializer):
user = UserSerializer()
class Meta:
model = Profile
fields = ['user']
class CommentSerializer(serializers.ModelSerializer):
user = UserSerializer()
class Meta:
model = Comment
fields = '__all__'
def to_representation(self, instance):
if isinstance(instance, User):
rep = UserSerializer(instance).data
rep[self.Meta.role_key] = self.get_role_json(instance)
return rep
def get(self, request):
users = get_user_model().objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
def jwt_response_payload_handler(token, user=None, request=None):
return {
'token': token,
'user': UserSerializer(user, context={'request': request}).data
}
def status(self, request):
ready = request.data.get('ready', False)
user = request.user
user.ready = ready
user.save()
return JsonResponse(UserSerializer(request.user).data)
def users(request):
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
class ReviewSerializer(serializers.ModelSerializer):
user = UserSerializer(required=False)
class Meta:
model = Review
fields = ['id','title','content','user','rank','created_at','updated_at']
read_only_fields = ['user','id']
def getuserdetail(request, user_name):
selected_user = get_object_or_404(User, username=user_name)
serializer = UserSerializer(selected_user)
return Response(serializer.data)
class AnswerSerializer(serializers.ModelSerializer):
comment = CommentSerializer(many=True)
reply_user = UserSerializer()
class Meta:
model = Answer
def post(self, request, format=None):
member_data = request.data.copy()
# try:
username = member_data.pop('username', None)
first_name = member_data.pop('first_name', None)
last_name = member_data.pop('last_name', None)
email = member_data.pop('email', None)
password = member_data.pop('password', None)
user_data_dict = {
'username': username[0],
'first_name': first_name[0],
'last_name': last_name[0],
'email': email[0],
'password': password[0],
}
#recreating the query dict
user_data_query_dict = QueryDict('', mutable=True)
user_data_query_dict.update(user_data_dict)
#add query dict to user serializer
member_serializer = GroupMemberSerializer(data=member_data)
if member_serializer.is_valid():
user_account_serializer = UserSerializer(data=user_data_query_dict)
user_account_serializer.is_valid(raise_exception=True)
user_account_serializer.save()
user = User.objects.get(pk=user_account_serializer.data['id'])
member_serializer.save(user_id=user)
#create savings and shares accounts
savings_account_number = generate_account_number(
member_serializer.data['id'], "savings")
savings_account = {
'group_member_related': member_serializer.data['id'],
'account_number': savings_account_number
#'account_balance':member_serializer.data[''],
#'running_balance':0,
#'interest_accrued':0
}
savings_account_creation = SavingsAccountSerializer(
data=savings_account)
savings_account_creation.is_valid(raise_exception=True)
savings_account_creation.save()
#create shares account
shares_account_number = generate_account_number(
member_serializer.data['id'], 'shares')
shares_account = {
'group_member_related': member_serializer.data['id'],
'account_number': shares_account_number,
'account_balance': member_serializer.data['shares_fee'],
'running_balance': member_serializer.data['shares_fee'],
#'interest_accrued':0
}
shares_account_creation = SharesAccountSerializer(
data=shares_account)
shares_account_creation.is_valid(raise_exception=True)
shares_account_creation.save()
#send twilio sms with registration details
phone_number = "{}{}".format(
member_serializer.data['phone_dialing_code'],
member_serializer.data['phone_number'])
message = "Welcome to MFI, Savings account Number is {} with balance of {}, Shares Account Number is {} with balance of {} shs".format(
savings_account_number, 0, shares_account_number, 0)
try:
send_sms(phone_number, message)
except:
print("Message Not sending")
data_dict = {
"status": 201,
"data": member_serializer.data,
"savings_account": savings_account,
"shares_account": shares_account
}
return Response(data_dict, status=status.HTTP_201_CREATED)
# except:
# print("Failed")
# # return Response(member_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(member_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def list(self, request, *args, **kwargs):
print(self.request.user)
data = UserSerializer(self.request.user).data
return Response(data=data, status=status.HTTP_200_OK)
def get(self, request, format=None):
users = User.objects.all()
serializer = UserSerializer(users, many=True)
data_dict = {"status": 200, "data": serializer.data}
return Response(data_dict, status=status.HTTP_200_OK)
class ChatSerializer(serializers.ModelSerializer):
participants = UserSerializer(many=True)
class Meta:
model = Chat
fields = ('id', 'participants')
def post(self, request):
serializer = UserSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
