debugging entry

2024-07-25 00:57:48 +00:00
parent 09e39987e2
commit c0fb177d02
24 changed files with 1051 additions and 395 deletions
--- a/rog/serializers.py
+++ b/rog/serializers.py
@ -1,15 +1,25 @@
+import uuid
+from django.db import IntegrityError
+from django.core.mail import send_mail
+from django.conf import settings
+from django.urls import reverse
+
+from django.db import transaction
 from rest_framework import serializers
 from rest_framework_gis.serializers import GeoFeatureModelSerializer
 from sqlalchemy.sql.functions import mode
-from .models import Location, Location_line, Location_polygon, JpnAdminMainPerf, Useractions, GifuAreas, RogUser, UserTracks, GoalImages, CheckinImages,CustomUser,NewEvent, Team, Category, Entry, Member, TempUser
+from .models import Location, Location_line, Location_polygon, JpnAdminMainPerf, Useractions, GifuAreas, RogUser, UserTracks, GoalImages, CheckinImages,CustomUser,NewEvent,NewEvent2, Team, NewCategory, Category, Entry, Member, TempUser,EntryMember
 from drf_extra_fields.fields import Base64ImageField

 #from django.contrib.auth.models import User
 from .models import CustomUser
 from django.contrib.auth import authenticate
+from .utils import send_activation_email

 from .models import TestModel
+import logging

+logger = logging.getLogger(__name__)

 class LocationCatSerializer(serializers.ModelSerializer):
    class Meta:
@ -194,15 +204,67 @@ class RegistrationSerializer(serializers.ModelSerializer):
        user.save()
        return user

+class NewCategorySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = NewCategory
+        #fields = ['id','category_name', 'category_number', 'duration', 'num_of_member', 'family', 'female']
+        fields = ['id','category_name', 'category_number']
+
+class NewEvent2Serializer(serializers.ModelSerializer):
+    class Meta:
+        model = NewEvent2
+        fields = ['id','event_name', 'start_datetime', 'end_datetime']
+
 class NewEventSerializer(serializers.ModelSerializer):
    class Meta:
        model = NewEvent
        fields = ['event_name', 'start_datetime', 'end_datetime']

 class TeamSerializer(serializers.ModelSerializer):
+    #category = serializers.PrimaryKeyRelatedField(queryset=NewCategory.objects.all())
+
+    category = NewCategorySerializer(read_only=True)
+    #category_id = serializers.PrimaryKeyRelatedField(
+    #    queryset=NewCategory.objects.all(),
+    #    source='category',
+    #    write_only=True
+    #)
+    owner = serializers.PrimaryKeyRelatedField(read_only=True)
+
+
    class Meta:
        model = Team
-        fields = ['zekken_number', 'team_name', 'password', 'owner']
+        fields = ['id','zekken_number', 'team_name', 'category', 'owner']
+        read_only_fields = ['id', 'owner', 'zekken_number']
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['category'] = {
+            'id': instance.category.id,
+            'category_name': instance.category.category_name,
+            'category_number': instance.category.category_number
+        }
+        ret['owner'] = CustomUserSerializer(instance.owner).data
+        return ret
+    
+    def validate_category(self, value):
+        if not NewCategory.objects.filter(id=value.id).exists():
+            raise serializers.ValidationError("Invalid category ID.")
+        return value
+
+    def create(self, validated_data):
+        category = validated_data.pop('category')
+        team = Team.objects.create(category=category, **validated_data)
+        return team
+
+        #logger.debug(f"Creating team with data: {validated_data}")
+        #validated_data['owner'] = self.context['request'].user
+        #return super().create(validated_data)
+
+    def update(self, instance, validated_data):
+        if 'category' in validated_data:
+            instance.category = validated_data.pop('category')
+        return super().update(instance, validated_data)

 class CategorySerializer(serializers.ModelSerializer):
    class Meta:
@ -210,29 +272,60 @@ class CategorySerializer(serializers.ModelSerializer):
        fields = ['category_name', 'category_number', 'duration', 'num_of_member', 'family', 'female']

 class EntrySerializer(serializers.ModelSerializer):
+    team = serializers.PrimaryKeyRelatedField(queryset=Team.objects.all())
+    event = serializers.PrimaryKeyRelatedField(queryset=NewEvent.objects.all())
+    category = serializers.PrimaryKeyRelatedField(queryset=NewCategory.objects.all())
+    owner = serializers.PrimaryKeyRelatedField(read_only=True)
+
    class Meta:
        model = Entry
-        fields = ['team', 'event', 'category', 'date']
+        fields = ['id','team', 'event', 'category', 'date','owner']

-class MemberSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Member
-        fields = ['team', 'user']
+    def validate_team(self, value):
+        if not value.members.exists():
+            raise serializers.ValidationError("チームにメンバーが登録されていません。")
+        return value

-class TempUserSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = TempUser
-        fields = ['email', 'password', 'is_rogaining', 'zekken_number', 'event_code', 'team_name', 'group', 'firstname', 'lastname', 'date_of_birth', 'female', 'verification_code', 'created_at', 'expires_at']
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['team'] = instance.team.team_name
+        ret['event'] = instance.event.event_name
+        ret['category'] = instance.category.category_name
+        ret['owner'] = instance.owner.email
+        return ret

 class CustomUserSerializer(serializers.ModelSerializer):
    class Meta:
        model = CustomUser
-        fields = ['email', 'is_staff', 'is_active', 'is_rogaining', 'zekken_number', 'event_code', 'team_name', 'group', 'firstname', 'lastname', 'date_of_birth', 'female']
+        #fields = ['email', 'is_staff', 'is_active', 'is_rogaining', 'zekken_number', 'event_code', 'team_name', 'group', 'firstname', 'lastname', 'date_of_birth', 'female']
+        fields = ['id','email', 'firstname', 'lastname', 'date_of_birth', 'female']
+        read_only_fields = ['email']
+
+class TeamDetailSerializer(serializers.ModelSerializer):
+    category = NewCategorySerializer(read_only=True)
+    
+    class Meta:
+        model = Team
+        fields = ['id', 'zekken_number', 'team_name', 'category']

 class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = CustomUser
-        fields = ['email', 'firstname', 'lastname', 'date_of_birth', 'female', 'is_rogaining', 'zekken_number', 'event_code', 'team_name', 'group']
+        fields = ['id','email', 'firstname', 'lastname', 'date_of_birth', 'female', 'is_rogaining', 'zekken_number', 'event_code', 'team_name', 'group']
+        read_only_fields = ('id', 'email')
+
+class UserUpdateSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = CustomUser
+        fields = ['firstname', 'lastname', 'date_of_birth', 'female']
+        extra_kwargs = {'email': {'read_only': True}}
+
+    def update(self, instance, validated_data):
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)
+        instance.save()
+        return instance
+

 class MemberWithUserSerializer(serializers.ModelSerializer):
    user = UserSerializer(read_only=True)
@ -240,3 +333,149 @@ class MemberWithUserSerializer(serializers.ModelSerializer):
    class Meta:
        model = Member
        fields = ['user', 'team']
+
+class MemberSerializer(serializers.ModelSerializer):
+    user = CustomUserSerializer()
+    team = TeamDetailSerializer(read_only=True)
+
+    #email = serializers.EmailField(write_only=True, required=False)
+    #firstname = serializers.CharField(write_only=True, required=False)
+    #lastname = serializers.CharField(write_only=True, required=False)
+    #date_of_birth = serializers.DateField(write_only=True, required=False)
+    #female = serializers.BooleanField(write_only=True, required=False)
+
+    class Meta:
+        model = Member
+        fields = ['id','user','team']  # ,'email','firstname','lastname','date_of_birth','female']
+        #read_only_fields = ['id', 'team']
+
+    def create(self, validated_data):
+        team = validated_data['team']
+        email = validated_data.get('email')
+        
+        if email:
+            user, created = CustomUser.objects.get_or_create(email=email)
+            if created:
+                user.firstname = validated_data.get('firstname', '')
+                user.lastname = validated_data.get('lastname', '')
+                user.date_of_birth = validated_data.get('date_of_birth')
+                user.female = validated_data.get('female', False)
+                user.is_active = False
+                user.activation_token = str(uuid.uuid4())
+                user.save()
+
+                activation_link = self.context['request'].build_absolute_uri(
+                    reverse('user-activation', kwargs={'activation_token': user.activation_token})
+                )
+                try:
+                    send_activation_email(user, activation_link)
+                except Exception as e:
+                    logger.error(f"アクティベーションメールの送信中にエラーが発生しました: {str(e)}")
+                    # メール送信に失敗しても、ユーザー作成は続行します
+
+        else:
+            dummy_email = f"dummy_{uuid.uuid4()}@example.com"
+            user = CustomUser.objects.create(
+                email=dummy_email,
+                firstname=validated_data.get('firstname', ''),
+                lastname=validated_data.get('lastname', ''),
+                date_of_birth=validated_data.get('date_of_birth'),
+                female=validated_data.get('female', False),
+                is_active=True
+            )
+
+        try:
+            member = Member.objects.create(user=user, team=team)
+        except IntegrityError:
+            # ユーザーがすでにチームのメンバーの場合
+            raise serializers.ValidationError("このユーザーは既にチームのメンバーです。")
+        
+        return member
+
+    def update(self, instance, validated_data):
+        user_data = validated_data.pop('user', {})
+        user = instance.user
+
+        if user.email.startswith('dummy_'):  # dummy_ で始まるメールアドレスの場合のみ更新
+            for attr, value in user_data.items():
+                setattr(user, attr, value)
+            user.save()
+        else:
+            raise serializers.ValidationError("このユーザーの情報は更新できません。")
+
+        return super().update(instance, validated_data)
+
+
+
+class EntryMemberSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EntryMember
+        fields = ['id', 'entry', 'member', 'is_temporary']
+
+
+class TempUserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = TempUser
+        fields = ['id','email', 'password', 'is_rogaining', 'zekken_number', 'event_code', 'team_name', 'group', 'firstname', 'lastname', 'date_of_birth', 'female', 'verification_code', 'created_at', 'expires_at']
+
+class EntryCreationSerializer(serializers.Serializer):
+    owner_email = serializers.EmailField()
+    event_name = serializers.CharField()
+    category_name = serializers.CharField()
+    team_name = serializers.CharField()
+    zekken_number = serializers.CharField()
+    date = serializers.DateField()
+    members = serializers.ListField(child=serializers.DictField())
+
+    def create(self, validated_data):
+        owner = CustomUser.objects.get(email=validated_data['owner_email'])
+        event = NewEvent2.objects.get(event_name=validated_data['event_name'])
+        category = NewCategory.objects.get(category_name=validated_data['category_name'])
+
+        # Create or get team
+        team, _ = Team.objects.get_or_create(
+            zekken_number=validated_data['zekken_number'],
+            category=category,
+            defaults={'team_name': validated_data['team_name'], 'owner': owner}
+        )
+
+        # Create or update entry
+        entry, _ = Entry.objects.update_or_create(
+            owner=owner,
+            team=team,
+            event=event,
+            date=validated_data['date'],
+            defaults={'category': category}
+        )
+
+        # Process members
+        for member_data in validated_data['members']:
+            user, created = CustomUser.objects.get_or_create(
+                email=member_data.get('email'),
+                defaults={
+                    'firstname': member_data['firstname'],
+                    'lastname': member_data['lastname'],
+                    'date_of_birth': member_data['date_of_birth']
+                }
+            )
+
+            if created:
+                TempUser.objects.create(
+                    email=user.email,
+                    firstname=user.firstname,
+                    lastname=user.lastname,
+                    date_of_birth=user.date_of_birth
+                )
+                # Send invitation email here
+
+            member, _ = NewMember.objects.get_or_create(
+                user=user,
+                team=team,
+                defaults={'is_temporary': created}
+            )
+
+            EntryMember.objects.get_or_create(entry=entry, member=member)
+
+        return entry
+
+