Trade App

Python / Django / Websocket / Docker / Own REST / Own App Security

Basic Informations

Application for analyze a BTC stock exchange & community. Thanks this app you can subscribe BTC exchange and you can contact quickly with other app users (websocket chat & rest forum). Functionality has:

• chart (candles)
• triggers (it's create a notification when stock exchange get a your value)
• basic prognosis
• notifications

Trade App has also security func (like create/verify tokens (hashed information about user and session))

Project Structure

.
├── chat
│   ├── admin.py
│   ├── consumers.py
│   ├── models.py
│   ├── routing.py
│   ├── urls.py
│   └── views.py
├── generalApp
│   ├── AbstractCRUD.py
│   ├── admin.py
│   ├── apps.py
│   ├── exchangeVO.py
│   ├── methods.py
│   ├── models.py
│   ├── tests.py
│   ├── urls.py
│   ├── utilities.py
│   └── views.py
├── manage.py
├── migrate.sh
├── packages.sh
├── run.sh
└── TradeApp
    ├── routing.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

Useful Files

Shell / Bash Files

• ./packages.sh (every python virtual environment requirements for application run)

• ./migrate.sh (migrate every models with database in app and generate UML)

• ./run.sh (run application)

UML

Class Diagram By Apps

Comments

Application need a refactor endpoints, general functionality and security. General structure -> "generalApp" will be smashed a smaller apps/directores. Now, CRUD has been refactorized full, you can see:

class AbstractUtilsCRUD():
    """
    This class have a primary utilities for CRUD functionality
    """
    
    @classmethod
    def _objectFactory(self):
        """
        return a new specific object
        """
        pass

    @classmethod
    def _setParentID(self, parentID):
        """
        set object parent id
        """
        pass

    @classmethod
    def _allObjectsDict(self):
        """
        map all class objects to dict
        """
        objectAll = self._objectFactory().objects.all()
        list = []
        for x in objectAll:
            list.append(x.toDict())
        return list
    
    class Meta:
        abstract = True

It're a utils for CRUD classes used to global like this:

class AbstractGet(AbstractUtilsCRUD):
    """
    This class have a abstract `getOne` / `getAll` / `getByParent`
    """

    parent_id_field = ''
    
    @classmethod
    def getObject(self, objectID):
        """
        get one object
        """
        return self.__getObjectNormal(self, objectID)

    def __getObjectNormal(self, objectID):
        object = self._objectFactory().objects.get(pk = objectID).toDict()
        return HttpResponse(json.dumps(object))

    @classmethod
    def getAllObjects(self):
        """
        get all objects
        """
        objectsAll = self._allObjectsDict()
        return HttpResponse(json.dumps(objectsAll))

    @classmethod
    def getObjectsByParentID(self, parentID):
        """
        get objects by parent id
        """
        return HttpResponse(self.__getAllByParentID(parentID))
    
    @classmethod
    def __getAllByParentID(self, parentID):
        list = [ 
            x.toDict() 
            for x in self._objectFactory()
            .objects.filter(**{ self._objectFactory().parent_id_field: parentID })
        ]
        return json.dumps(list)

    class Meta:
        abstract = True
        

And other example

class AbstractCreate(AbstractUtilsCRUD):
    """
    This class have a abstract `create`
    """

    [...]
    
    @classmethod
    def _saveObject(self, objectDict):
        """
        save object without parent
        """
        del objectDict['token']
        newObject = self._objectFactory().objects.create(**objectDict)
        
        [...]
        
        newObject.save()
        return HttpResponse(f"Add new Object: {newObject.toDict()}")

Other classes looks similar to AbstractCreate / AbstractGet (let's see AbstractCRUD for more details).

Generaly - I'm gonna refactor this app with design patterns like:

• chain of responsibility (thanks tree structure classes, possible go this way: endpoint request -> verify user (security functionality) -> app functionality)
• wrapper (this pattern will be helpfull in the future when I will expanded app for more stock exchanges)
• strategy (for swapping functionality in functionality classes with many if statements)