Added class object and tester, not finished.

The class object is to later be replacing the current nfo-file parser
and making custom class objects instead. Just about done with CPU in
SystemSpecs, next up is GPU and then later recommendedspecs.

Also a seed-script update.

bcnsGDSAPI/sql/bcnsgds_seed.sql

@@ -1,5 +1,4 @@
 -- ratingOrgan
-
 INSERT INTO ratingOrgan (name) VALUES ('PEGI');
 INSERT INTO ratingOrgan (name) VALUES ('ELSPA');
 INSERT INTO ratingOrgan (name) VALUES ('USK');
@@ -8,7 +7,6 @@ INSERT INTO ratingOrgan (name) VALUES ('VET / SFB');
 INSERT INTO ratingOrgan (name) VALUES ('BBFC');
 
 -- additionalFileType
-
 INSERT INTO additionalFileType (name) VALUES ('patch'); 
 INSERT INTO additionalFileType (name) VALUES ('manual'); 
 INSERT INTO additionalFileType (name) VALUES ('quickstart'); 

gameobject.py

@@ -0,0 +1,405 @@
+import pprint
+from typing import List
+
+
+class SystemSpecs:
+    def __init__(self):
+        pass
+
+    @property
+    def os(self):
+        return self._os
+
+    @os.setter
+    def os(self, os):
+        # List
+        self._os = os
+
+    @property
+    def ramsize(self):
+        return self._ramsize
+
+    @ramsize.setter
+    def ramsize(self, ramsize):
+        # Int
+        self._ramsize = ramsize
+
+    @property
+    def cpu(self):
+        return self._cpu
+
+    @cpu.setter
+    def cpu(self):
+        self._cpu = self.CPU()
+
+    @property
+    def opticaldrive(self):
+        return self._opticaldrive
+
+    @opticaldrive.setter
+    def opticaldrive(self, opticaldrive):
+        # String
+        self._opticaldrive = opticaldrive
+
+    @property
+    def gpu(self):
+        return self._gpu
+
+    @gpu.setter
+    def gpu(self):
+        self._gpu = self.GPU()
+
+    @property
+    def hddspace(self):
+        return self._hddspace
+
+    @hddpspace.setter
+    def hddspace(self, hddspace):
+        # Int
+        self.hddspace = hddspace
+
+    @property
+    def nic(self):
+        return self._nic
+
+    @nic.setter
+    def nic(self, nic):
+        # List
+        self._nic = nic
+
+    def to_dict(self):
+        d = self.__dict__
+        for value in self.cpu:
+            d["cpu"][d["cpu"].index(value)] = value.to_dict()
+
+        for value in self.gpu:
+            d["gpu"][d["gpu"].index(value)] = value.to_dict()
+
+        return d
+
+    class CPU:
+        def __init__(self):
+            pass
+
+        @property
+        def frequency(self):
+            return self._frequency
+
+        @frequency.setter
+        def frequency(self, frequency):
+            # String
+            self._frequency = frequency
+
+        @property
+        def unit(self):
+            return self._unit
+
+        @unit.setter
+        def unit(self, unit):
+            # String
+            self._unit = unit
+
+        @property
+        def model(self):
+            return self._model
+
+        @model.setter
+        def model(self, model):
+            # List
+            self._model = model
+
+        def to_dict(self):
+            return self.__dict__
+
+    class GPU:
+        def __init__(self):
+            pass
+
+        def manufacturer(self, manufacturer):
+            # String
+            self.manufacturer = manufacturer
+
+        def model(self, model):
+            # List
+            self.model = model
+
+        def transfertype(self, transfertype):
+            # List
+            self.transfertype = transfertype
+
+        def memorysize(self, memorysize):
+            # Int
+            self.memorysize = memorysize
+
+        def engine(self, engine):
+            # String
+            self.engine = engine
+
+        def directx(self, directx):
+            # String
+            self.directx = directx
+
+        def to_dict(self):
+            return self.__dict__
+
+
+class Rating:
+    def __init__(self):
+        pass
+
+    def organ(self, organ):
+        # String
+        self.organ = organ
+
+    def verdict(self, verdict):
+        # String
+        self.verdict = verdict
+
+    def to_dict(self):
+        d = self.__dict__
+        return d
+
+
+class Game:
+    #def __init__(self, title, year, originaltitle=""):
+    def __init__(self):
+        self._title = ""
+#        self._originaltitle = ""
+#        self._year = ""
+#        self._plot = ""
+#        self._genre = ""
+#        self._playermodes = ""
+#        self._cdkey = ""
+#        if originaltitle == "":
+#            self.originaltitle = title
+#        else:
+#            self.originaltitle = originaltitle
+#        self.year = year
+
+    @property
+    def title(self):
+        return self._title
+
+    @title.setter
+    def title(self, title):
+        self._title = title
+
+    @property
+    def originaltitle(self):
+        return self._originaltitle
+
+    @originaltitle.setter
+    def originaltitle(self, originaltitle):
+        if originaltitle == "":
+            originaltitle = self._title
+        self._originaltitle = originaltitle
+
+    @property
+    def year(self):
+        return self._year
+
+    @year.setter
+    def year(self, year):
+        self._year = year
+
+    def example(self):
+        self._title = "Battlefield 2142"
+        self._year = 2006
+
+    @property
+    def plot(self):
+        return self._plot
+
+    @plot.setter
+    def plot(self, plot):
+        self._plot = plot
+
+    @property
+    def genre(self):
+        return self._genre
+
+    @genre.setter
+    def genre(self, genre):
+        self._genre = genre
+
+    @property
+    def playermodes(self):
+        return self._playermodes
+
+    @playermodes.setter
+    def playermodes(self, playermodes):
+        modes = ["Singleplayer",
+                 "Online Multiplayer",
+                 "LAN"]
+        try:
+            if isinstance(playermodes, list):
+                for mode in playermodes:
+                    assert mode in modes, (
+                            "### Assert error: " + self.title +
+                            ": playermode \"" + mode +
+                            "\" not valid. Valid options are " + str(modes) +
+                            ". Skipping.")
+                    # if mode not in modes:
+                    # raise Exception("playermode " + mode + " not valid")
+                self._playermodes = playermodes
+        except AssertionError as e:
+            print(e)
+
+    def artwork(self, artwork):
+        # TODO add type, title, region, notes and filename
+        pass
+
+    def imagelist(self, imagelist):
+        # TODO add type, name, titleD6
+        pass
+
+    @property
+    def cdkey(self):
+        return self._cdkey
+
+    @cdkey.setter
+    def cdkey(self, cdkey):
+        # TODO add validation of sorts
+        self._cdkey = cdkey
+
+    def documents(self, documents):
+        # TODO add type and path. Also validation
+        pass
+
+    @property
+    def linuxinstructions(self):
+        return self._linuxinstructions
+
+    @linuxinstructions.setter
+    def linuxinstructions(self, linuxinstructions):
+        self._linuxinstructions = linuxinstructions
+
+    @property
+    def systemrequirements(self):
+        return self._systemrequirements
+
+    @systemrequirements.setter
+    def systemrequirements(self, specs):
+        self._systemrequirements = SystemSpecs()
+
+    @property
+    def recommendedspecs(self):
+        return self._recommendedspecs
+
+    @recommendedspecs.setter
+    def recommendedspecs(self, specs):
+        self._recommendedspecs = SystemSpecs()
+
+    @property
+    def collab(self):
+        return self._collab
+
+    @collab.setter
+    def collab(self, collab):
+        self._collab = collab
+
+    @property
+    def developer(self):
+        return self._developer
+
+    @developer.setter
+    def developer(self, developer):
+        # String
+        self._developer = developer
+
+    @property
+    def credit(self):
+        return self._credit
+
+    @credit.setter
+    def credit(self, credit):
+        try:
+            if not isinstance(credit, list):
+                raise TypeError
+            self.credit = credit
+        except TypeError:
+            print("### Type error: " + self.title + ": credit is not a list")
+
+    @property
+    def rating(self):
+        return self._rating
+
+    @rating.setter
+    def rating(self):
+        self._rating = Rating()
+
+    def to_dict(self):
+        j = self.__dict__
+        try:
+            j["systemrequirements"] = self.systemrequirements.to_dict()
+        except AttributeError:
+            print("## " + self.title +
+                  ": no systemrequirements found, skipping")
+        try:
+            j["recommendedspecs"] = self.recommendedspecs.to_dict()
+        except AttributeError:
+            print("## " + self.title +
+                  ": no recommendedspecs found, skipping")
+        try:
+            j["rating"] = self.rating.to_dict()
+        except AttributeError:
+            print("## " + self.title +
+                  ": no rating found, skipping")
+
+        return j
+
+
+def example():
+    # testdata object
+    g1 = Game("Battlefield 2142", 2006)
+    g1.plot("Framtidens krig\n\nMedan en förödande istid tömmer jordens " +
+            "resurser utkämpar två koalitioner ett desperat krig om det " +
+            "enda som spelar någon roll - överlevnad.\n\n* Från skaparna" +
+            " av den prisbelönta spelserien Battlefield\n* Krossa " +
+            "motståndarens Titan i det helt nya, målbaserade Titan-" +
+            "spelläget\n* Härska på slagfältet ned högteknologiska " +
+            "fordon och vapen, som svävarstridsvagnar och EMP-granater\n* " +
+            "Kämpa dig till titeln som överbefälhavare med belöningar i " +
+            "realtid och lås upp saker som kanonrobotar och flyttbara " +
+            "Spawn-punkter\n* Anpassa din karaktär så att den passar din " +
+            "spelstil")
+    g1.genre(["RPG", "FPS"])
+    g1.playermodes(["Singleplayer", "Online Multiplayer", "LAN"])
+    g1.cdkey("H98G-DW8M-USH8-VPL8-L265")
+    g1req = SystemSpecs()
+    g1req.os(["Windows XP"])
+    g1req.ramsize(536870912)
+    g1reqcpu = SystemSpecs().CPU()
+    g1reqcpu.frequency("1.7")
+    g1reqcpu.unit("GHz")
+    g1reqcpu.model(["Intel Pentium 4", "AMD Athlon"])
+    g1req.cpu = [g1reqcpu]
+    g1reqgpu1 = SystemSpecs().GPU()
+    g1reqgpu1.manufacturer("NVIDIA")
+    g1reqgpu1.model(["GeForce 5800"])
+    g1reqgpu1.transfertype(["AGP", "PCIe"])
+    g1reqgpu1.memorysize(134217728)
+    g1reqgpu1.directx("DirectX 9.0c")
+    g1reqgpu2 = SystemSpecs().GPU()
+    g1reqgpu2.manufacturer("ATI")
+    g1reqgpu2.model(["Radeon 9500"])
+    g1reqgpu2.transfertype(["AGP", "PCIe"])
+    g1reqgpu2.memorysize(134217728)
+    g1reqgpu2.directx("DirectX 9.0c")
+    g1req.gpu = [g1reqgpu1, g1reqgpu2]
+    g1req.opticaldrive("DVD 8x")
+    g1req.hddspace(2362232013)
+    g1req.nic(["128kbps"])
+    g1.systemrequirements = g1req
+    g1.developer("dice")
+    g1.credit(["EA", "BINK Video", "SoundBlaster X-Fi", "gamespy"])
+    g1rating = Rating()
+    g1rating.organ("PEGI")
+    g1rating.verdict("16+")
+    g1.rating = g1rating
+
+    myjson = g1.to_dict()
+    pprint.pp(myjson)
+
+
+#example()

readnfo.py

@@ -0,0 +1,79 @@
+import json
+import sys
+import gameobject as go
+import pprint
+
+nfofilearg = sys.argv[1]
+content = ""
+with open(nfofilearg, "r") as file:
+    content = file.read()
+
+# TODO Better validation
+try:
+    content = json.loads(content)
+except:
+    print("couldn't load json, aborting")
+    exit
+
+print(content)
+c = content["game"]
+g1 = go.Game()
+keys = ["title", "originaltitle", "year", "plot", "genre", "playermodes" ,"cdkey" ,"linuxinstructions", "systemrequirements", "recommendedspecs", "recommendedspecs", "collab", "developer", "credit", "rating"]
+for key in keys:
+    try:
+        assert key in c
+    except AssertionError:
+        print("###key " + key + " not in nfo-file, skipping")
+        keys.remove(key)
+    else:
+        sskeys = ["os", "ramsize", "cpu", "opticaldrive", "gpu", "hddpsace", "nic"]
+        cpukeys =["frequency", "unit", "model"]
+        if key == "title":
+            g1.title = c["title"]
+        if key == "originaltitle":
+            g1.originaltitle = c["originaltitle"]
+        if key == "year":
+            g1.year = c["year"]
+        if key == "plot":
+            g1.plot = c["plot"]
+        if key == "genre":
+            g1.genre = c["genre"]
+        if key == "playermodes":
+            g1.playermodes = c["playermodes"]
+        if key == "cdkey":
+            g1.cdkey = c["cdkey"]
+        if key == "linuxinstructions":
+            g1.linuxinstructions = c["linuxinstructions"]
+        if key == "systemrequirements":
+            sr1 = go.SystemSpecs()
+            csr = c["systemrequirements"]
+            for srkey in sskeys:
+                try:
+                    assert srkey in c["systemrequirements"]
+                except AssertionError:
+                    print("###key " + srkey + " not in nfo-file, skipping")
+                else:
+                    if srkey == "os":
+                        sr1.os = csr["os"]
+                    if srkey == "ramsize":
+                        sr1.ramsize = csr["ramsize"]
+                    if srkey == "cpu":
+                        cpu1 = go.SystemSpecs().CPU()
+                        ccpu = csr["cpu"]
+                        for cpukey in cpukeys:
+                            try:
+                               assert cpukey in ccpu
+                            except AssertionError:
+                                print("###key " + cpukey + " not in nfo-file, skipping")
+                            else:
+                                if cpukey == "frequency":
+                                    cpu1.frequency = ccpu["frequency"]
+                                if cpukey == "unit":
+                                    cpu1.unit = ccpu["unit"]
+                                if cpukey == "model":
+                                    cpu1.model = ccpu["model"]
+
+#    g1.systemrequirements = c["systemrequirements"]
+#    g1.recommendedspcs = c["recommendedspecs"]
+
+pprint.pp(g1.to_dict())