independant sde app

sde/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class SdeConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'sde'

sde/management/commands/import_sde.py

@@ -0,0 +1,140 @@
+from django.core.management.base import BaseCommand, CommandError
+from sde.models import *
+import yaml
+
+class Command(BaseCommand):
+    help = 'Import SDE data from YAML files'
+
+    def add_arguments(self, parser):
+        parser.add_argument('path', type=str, help='Path to the SDE YAML files')
+
+    def handle(self, *args, **options):
+        # Import the SDE data
+        self.stdout.write(self.style.SUCCESS('Importing SDE data'))
+        self.import_sde_data(path=options['path'])
+        self.stdout.write(self.style.SUCCESS('Successfully imported SDE data'))
+
+    def import_sde_data(self, path):
+        self.import_icons(path + "/iconIDs.yaml")
+        self.import_categories(path + "/categoryIDs.yaml")
+        self.import_groups(path + "/groupIDs.yaml")
+        self.import_marketgroups(path + "/marketGroups.yaml")
+        self.import_metagroups(path + "/metaGroups.yaml")
+        self.import_types(path + "/typeIDs.yaml")
+        self.import_type_materials(path + "/typeMaterials.yaml")
+
+    def import_icons(self, path):
+        with open(path) as file:
+            icons = yaml.load(file, Loader=yaml.FullLoader)
+            for id, icon in icons.items():
+                SDEIcon.objects.update_or_create(
+                    id=id,
+                    defaults={
+                        'iconFile': icon['iconFile'],
+                        'description': icon['description'] if "description" in icon else ""
+                    }
+                )
+        self.stdout.write(self.style.SUCCESS('Icons imported'))
+
+    def import_categories(self, path):
+        with open(path) as file:
+            categories = yaml.load(file, Loader=yaml.FullLoader)
+            for id, category in categories.items():
+                SDECategory.objects.update_or_create(
+                    id=id,
+                    defaults={
+                        'icon': SDEIcon.objects.get(id=category['iconID']) if "iconID" in category else None,
+                        'name': category['name']['en'],
+                        'published': category['published']
+                    }
+                )
+        self.stdout.write(self.style.SUCCESS('Categories imported'))
+
+    def import_groups(self, path):
+        with open(path) as file:
+            groups = yaml.load(file, Loader=yaml.FullLoader)
+            for id, group in groups.items():
+                SDEGroup.objects.update_or_create(
+                    id=id,
+                    defaults={
+                        'category': SDECategory.objects.get(id=group['categoryID']),
+                        'name': group['name'],
+                        'published': group['published'],
+                        'useBasePrice': group['useBasePrice'],
+                        'fittableNonSingleton': group['fittableNonSingleton'],
+                        'anchored': group['anchored'],
+                        'anchorable': group['anchorable'],
+                        'icon': SDEIcon.objects.get(id=group['iconID']) if "iconID" in group else None
+                    }
+                )
+        self.stdout.write(self.style.SUCCESS('Groups imported'))
+
+    def import_marketgroups(self, path):
+        with open(path) as file:
+            marketgroups = yaml.load(file, Loader=yaml.FullLoader)
+            for id, marketgroup in marketgroups.items():
+                SDEMarektGroup.objects.update_or_create(
+                    id=id,
+                    defaults={
+                        'icon': SDEIcon.objects.get(id=marketgroup['iconID']) if "iconID" in marketgroup else None,
+                        'name': marketgroup['nameID']['en'],
+                        'description': marketgroup['descriptionID']['en'] if "descriptionID" in marketgroup else "",
+                        'hasTypes': marketgroup['hasTypes'],
+                    }
+                )
+            self.stdout.write(self.style.SUCCESS('Marketgroups imported'))
+            for id, marketgroup in marketgroups.items():
+                if "parentGroupID" in marketgroup:
+                    sde_mg = SDEMarektGroup.objects.get(id=id)
+                    sde_mg.parent_marketgroup = SDEMarektGroup.objects.get(id=marketgroup['parentGroupID'])
+                    sde_mg.save()
+        self.stdout.write(self.style.SUCCESS('Marketgroups linked'))
+
+    def import_metagroups(self, path):
+        with open(path) as file:
+            metagroups = yaml.load(file, Loader=yaml.FullLoader)
+            for id, metagroup in metagroups.items():
+                SDEMetaGroup.objects.update_or_create(
+                    id=id,
+                    defaults={
+                        'icon': SDEIcon.objects.get(id=metagroup['iconID']) if "iconID" in metagroup else None,
+                        'name': metagroup['nameID']['en'],
+                        'iconSuffix': metagroup['iconSuffix'] if "iconSuffix" in metagroup else "",
+                    }
+                )
+        self.stdout.write(self.style.SUCCESS('Metagroups imported'))
+
+    def import_types(self, path):
+        with open(path) as file:
+            types = yaml.load(file, Loader=yaml.FullLoader)
+            for id, type in types.items():
+                SDEType.objects.update_or_create(
+                    id=id,
+                    defaults={
+                        'group': SDEGroup.objects.get(id=type['groupID']),
+                        'marketgroup': SDEMarektGroup.objects.get(id=type['marketGroupID']) if "marketGroupID" in type else None,
+                        'metagroup': SDEMetaGroup.objects.get(id=type['metaGroupID']) if "metaGroupID" in type else None,
+                        'name': type['name']['en'],
+                        'description': type['description']['en'] if "description" in type else "",
+                        'published': type['published'],
+                        'basePrice': type['basePrice'] if "basePrice" in type else 0,
+                        'icon': SDEIcon.objects.get(id=type['iconID']) if "iconID" in type else None,
+                        'volume': type['volume'] if "volume" in type else 0,
+                        'portionSize': type['portionSize'],
+                    }
+                )
+        self.stdout.write(self.style.SUCCESS('Types imported'))
+
+    def import_type_materials(self, path):
+        with open(path) as file:
+            type_materials = yaml.load(file, Loader=yaml.FullLoader)
+            for id, type_material in type_materials.items():
+                for material in type_material['materials']:
+                    SDETypeMaterial.objects.update_or_create(
+                        type=SDEType.objects.get(id=id),
+                        material_type=SDEType.objects.get(id=material['materialTypeID']),
+                        defaults={
+                            'quantity': material['quantity'],
+                        }
+                    )
+        self.stdout.write(self.style.SUCCESS('Materials imported'))

sde/models.py

@@ -0,0 +1,64 @@
+from django.db import models
+
+
+class SDEIcon(models.Model):
+    id = models.IntegerField(primary_key=True)
+    iconFile = models.CharField()
+    description = models.CharField()
+
+
+class SDECategory(models.Model):
+    id = models.IntegerField(primary_key=True)
+    icon = models.ForeignKey(SDEIcon, related_name="categories", null=True, on_delete=models.SET_NULL)
+    name = models.CharField()
+    published = models.BooleanField()
+
+
+class SDEGroup(models.Model):
+    id = models.IntegerField(primary_key=True)
+    category = models.ForeignKey(SDECategory, related_name="groups", on_delete=models.CASCADE)
+    name = models.CharField()
+    published = models.BooleanField()
+    useBasePrice = models.BooleanField()
+    fittableNonSingleton = models.BooleanField()
+    anchored = models.BooleanField()
+    anchorable = models.BooleanField()
+    icon = models.ForeignKey(SDEIcon, related_name="groups", null=True, on_delete=models.SET_NULL)
+
+
+class SDEMarektGroup(models.Model):
+    id = models.IntegerField(primary_key=True)
+    icon = models.ForeignKey(SDEIcon, null=True, on_delete=models.SET_NULL)
+    name = models.CharField()
+    description = models.CharField(default="")
+    hasTypes = models.BooleanField()
+    parent_marketgroup = models.ForeignKey("self", null=True, related_name="child_marketgroups", on_delete=models.CASCADE)
+
+
+class SDEMetaGroup(models.Model):
+    id = models.IntegerField(primary_key=True)
+    icon = models.ForeignKey(SDEIcon, related_name="metagroups", null=True, on_delete=models.SET_NULL)
+    name = models.CharField()
+    iconSuffix = models.CharField()
+
+
+class SDEType(models.Model):
+    id = models.IntegerField(primary_key=True)
+    group = models.ForeignKey(SDEGroup, related_name="types", on_delete=models.CASCADE)
+    marketgroup = models.ForeignKey(SDEMarektGroup, related_name="types", on_delete=models.SET_NULL, null=True)
+    metagroup = models.ForeignKey(SDEMetaGroup, related_name="types", on_delete=models.SET_NULL, null=True)
+    name = models.CharField()
+    description = models.CharField()
+    published = models.BooleanField()
+    basePrice = models.FloatField()
+    icon = models.ForeignKey(SDEIcon, related_name="types", null=True, on_delete=models.SET_NULL)
+    volume = models.FloatField()
+    portionSize = models.IntegerField()
+    materials = models.ManyToManyField("self", through="SDETypeMaterial", symmetrical=False, related_name="material_of")
+
+
+class SDETypeMaterial(models.Model):
+    type = models.ForeignKey(SDEType, on_delete=models.CASCADE, related_name="typematerials")
+    material_type = models.ForeignKey(SDEType, on_delete=models.CASCADE, related_name="typematerials_of")
+
+    quantity = models.IntegerField()

sde/serializers.py

@@ -0,0 +1,54 @@
+from sde.models import *
+from rest_framework import serializers
+
+
+class SDEIconSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SDEIcon
+        # fields = ['id', 'iconFile', 'description']
+        fields = "__all__"
+
+
+class SDECategorySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SDECategory
+        # fields = ['id', 'icon', 'name', 'published']
+        fields = "__all__"
+
+
+class SDEGroupSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SDEGroup
+        # fields = ['id', 'category', 'name', 'published', 'useBasePrice', 'fittableNonSingleton', 'anchored', 'anchorable', 'icon']
+        fields = "__all__"
+
+
+class SDEMarektGroupSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SDEMarektGroup
+        # fields = ['id', 'icon', 'name', 'description', 'hasTypes', 'parent_marketgroup']
+        fields = "__all__"
+
+
+class SDEMetaGroupSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SDEMetaGroup
+        # fields = ['id', 'icon', 'name', 'iconSuffix']
+        fields = "__all__"
+
+
+class SDETypeMaterialSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SDETypeMaterial
+        # fields = ['type', 'material', 'quantity']
+        # fields = "__all__"
+        exclude = ['id', 'type']
+
+
+class SDETypeSerializer(serializers.ModelSerializer):
+    typematerials = SDETypeMaterialSerializer(many=True, read_only=True)
+    class Meta:
+        model = SDEType
+        # fields = ['id', 'group', 'marketgroup', 'metagroup', 'name', 'description', 'published', 'basePrice', 'icon', 'volume', 'portionSize', 'materials']
+        fields = "__all__"
+

sde/urls.py

@@ -0,0 +1,12 @@
+from . import views
+from django.urls import include, path
+from rest_framework import routers
+
+router = routers.DefaultRouter()
+router.register(r'icons', views.SDEIconViewSet)
+router.register(r'categories', views.SDECategoryViewSet)
+router.register(r'groups', views.SDEGroupViewSet)
+router.register(r'marketgroups', views.SDEMarketGroupViewSet)
+router.register(r'metagroups', views.SDEMetaGroupViewSet)
+router.register(r'types', views.SDETypeViewSet)
+router.register(r'typematerials', views.SDETypeMaterialViewSet)

sde/views.py

@@ -0,0 +1,46 @@
+from sde.serializers import *
+from rest_framework import viewsets
+
+
+class SDEIconViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = SDEIcon.objects.all()
+    serializer_class = SDEIconSerializer
+    # permission_classes = [permissions.IsAuthenticated]
+
+
+class SDECategoryViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = SDECategory.objects.all()
+    serializer_class = SDECategorySerializer
+    # permission_classes = [permissions.IsAuthenticated]
+
+
+class SDEGroupViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = SDEGroup.objects.all()
+    serializer_class = SDEGroupSerializer
+    # permission_classes = [permissions.IsAuthenticated]
+
+
+class SDEMarketGroupViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = SDEMarektGroup.objects.all()
+    serializer_class = SDEMarektGroupSerializer
+    # permission_classes = [permissions.IsAuthenticated]
+
+
+class SDEMetaGroupViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = SDEMetaGroup.objects.all()
+    serializer_class = SDEMetaGroupSerializer
+    # permission_classes = [permissions.IsAuthenticated]
+
+
+class SDETypeViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = SDEType.objects.all()
+    serializer_class = SDETypeSerializer
+    # permission_classes = [permissions.IsAuthenticated]
+
+
+class SDETypeMaterialViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = SDETypeMaterial.objects.all()
+    serializer_class = SDETypeMaterialSerializer
+    # permission_classes = [permissions.IsAuthenticated]
+
+