use hermetization in AbstractCRUD classes && fix

generalApp/AbstractCRUD.py

@@ -6,25 +6,25 @@ class AbstractUtilsCRUD():
     """
     
     @classmethod
-    def objectFactory(self):
+    def _objectFactory(self):
         """
         return a new specific object
         """
         pass
 
     @classmethod
-    def setParentID(self, parentID):
+    def _setParentID(self, parentID):
         """
         set object parent id
         """
         pass
 
     @classmethod
-    def allObjectsDict(self):
+    def _allObjectsDict(self):
         """
         map all class objects to dict
         """
-        objectAll = self.objectFactory().objects.all()
+        objectAll = self._objectFactory().objects.all()
         list = []
         for x in objectAll:
             list.append(x.toDict())
@@ -46,7 +46,7 @@ class AbstractGet(AbstractUtilsCRUD):
         return self.__getObjectNormal(self, objectID)
 
     def __getObjectNormal(self, objectID):
-        object = self.objectFactory().objects.get(pk = objectID).toDict()
+        object = self._objectFactory().objects.get(pk = objectID).toDict()
         return HttpResponse(json.dumps(object))
 
     @classmethod
@@ -54,7 +54,7 @@ class AbstractGet(AbstractUtilsCRUD):
         """
         get all objects
         """
-        objectsAll = self.allObjectsDict()
+        objectsAll = self._allObjectsDict()
         return HttpResponse(json.dumps(objectsAll))
 
     @classmethod
@@ -67,7 +67,7 @@ class AbstractGet(AbstractUtilsCRUD):
     def __getAllByParentID(self, parentID):
         list = [ 
             x.toDict() 
-            for x in self.objectFactory()
+            for x in self._objectFactory()
             .__get.objects.filter(**{ parent_id_field: parentID })
         ]
         return json.dumps(list)
@@ -85,46 +85,46 @@ class AbstractCreate(AbstractUtilsCRUD):
         """
         object = jsonLoad(request)
         if checkSession(request, privilige):
-            if self.validateUnique(object):
+            if self._validateUnique(object):
-                 return self.saveObject(object)
+                 return self._saveObject(object)
             else:
                 return HttpResponse("Object Is Already Exist")
         else:
             return HttpResponse("No Permission")
 
-    def validateUnique(self, userDict):
+    def _validateUnique(self, userDict):
         """
         use validate in override this method
         """
         return True
 
-    def saveObject(self, objectDict):
+    def _saveObject(self, objectDict):
         """
         save object without parent
         """
-        newObject = self.objectFactory()
+        newObject = self._objectFactory()
         newObject.fromDict(objectDict)
         newObject.save()
         return HttpResponse(f"Add new Object: {newObject.toDict()}")
 
-    def saveObject(self, parentID, objectDict):
+    def _saveObject(self, parentID, objectDict):
         """
         save object with parent & subject + comment & set trigger time
         """
-        newObject = self.objectFactory()
+        newObject = self._objectFactory()
         newObject.fromDict(objectDict)
 
-        self.setParentID(parentID)
+        self.__setParentID(parentID)
-        self.createFirstComment(newObject, objectDict)
+        self._createFirstComment(newObject, objectDict)
-        self.setActualTimeTrigger()
+        self._setActualTimeTrigger()
 
         newObject.save()
         return HttpResponse(f"Add new Object: {newObject.toDict()}")
 
-    def createFirstComment(newSubject, objectDict):
+    def _createFirstComment(newSubject, objectDict):
         pass
 
-    def setActualTimeTrigger():
+    def _setActualTimeTrigger():
         pass
 
 
@@ -134,15 +134,19 @@ class AbstractUpdate(AbstractUtilsCRUD):
     """
 
     @classmethod
-    def updateObject(self, objectDict, objectID):
+    def putObject(self, request, objectID, privilige):
-        objectOld = self.objectFactory().objects.get(pk = objectID)
+        object = jsonLoad(request) 
-        objectOld.fromDict(objectDict)
+        if checkSession(request, privilige) and checkUserPermission(object, request)
-        if checkSession(request, privilige) and checkUserPermission(objectDel.toDict(), request):
+            return self._updateObject(object, objectID)
-            objectOld.save()
+        else:
-            return HttpResponse(f"Update Object: {objectOld.toDict()}")
-        else
             return HttpResponse("No Permission")
 
+    def _updateObject(self, objectDict, objectID):
+        objectOld = self._objectFactory().objects.get(pk = objectID)
+        objectOld.fromDict(objectDict)
+        objectOld.save()
+        return HttpResponse(f"Update Object: {objectOld.toDict()}")
+
 
 class AbstractDelete(AbstractUtilsCRUD):
     """
@@ -151,7 +155,7 @@ class AbstractDelete(AbstractUtilsCRUD):
 
     @classmethod
     def deleteObject(self, request, objectID, privilige):
-        objectDel = self.objectFactory().objects.get(pk = objectID)
+        objectDel = self._objectFactory().objects.get(pk = objectID)
         if checkSession(request, privilige) and checkUserPermission(objectDel.toDict(), request):
             objectDel.delete()
             return HttpResponse(f"Delete Object: {objectDel}")

generalApp/models.py

@@ -3,6 +3,7 @@ from django.http import HttpResponse
 from django.db.models import Avg
 from datetime import datetime
 from .utilities import *
+from .AbstractCRUD import AbstractCRUD
 
 
 class ObjectAbstract(models.Model):