351 lines
12 KiB
Python
Executable File
351 lines
12 KiB
Python
Executable File
from django.db import models
|
|
from django.http import HttpResponse
|
|
from django.db.models import Avg
|
|
from datetime import datetime
|
|
from .utilities import *
|
|
|
|
class ObjectAbstract(models.Model):
|
|
|
|
@classmethod
|
|
def addObject(self, request, parentID, privilige):
|
|
if self.modelIsUser(self) or checkSession(request, privilige):
|
|
object = jsonLoad(request)
|
|
if self.modelIsUser(self):
|
|
object['privilige'] = 1
|
|
object['password'] = createPassHash(object['password'])
|
|
if self.checkUniqueValues(self, parentID, object):
|
|
return self.saveObject(self, parentID, object)
|
|
else:
|
|
return HttpResponse("Object Is Already Exist")
|
|
else:
|
|
return HttpResponse("No Permission")
|
|
|
|
def modelIsUser(model):
|
|
return model == Users
|
|
|
|
def checkUniqueValues(model, parentID, objectDict):
|
|
objectsAll = model.allObjectsDict(model)
|
|
for x in objectsAll:
|
|
if model == Users:
|
|
if x['login'].upper() == objectDict['login'].upper():
|
|
return False
|
|
elif model == Threads:
|
|
if x['name'].upper() == objectDict['name'].upper():
|
|
return False
|
|
elif model == Ratings:
|
|
if int(x['user_id']) == int(objectDict['user_id']) and int(x['comment_id']) == parentID:
|
|
return False
|
|
return True
|
|
|
|
def allObjectsDict(model):
|
|
objectAll = model.objects.all()
|
|
list = []
|
|
for x in objectAll:
|
|
list.append(x.toDict())
|
|
return list
|
|
|
|
def modelIsNotUser(model):
|
|
return model != Users
|
|
|
|
def saveObject(model, parentID, objectDict):
|
|
newObject = model()
|
|
newObject.fromDict(objectDict)
|
|
if model.modelHaveParent(model):
|
|
newObject.setParentID(parentID)
|
|
if model.modelIsTrigger(model):
|
|
newObject.setActualTime()
|
|
newObject.save()
|
|
if model.modelIsSubject(model) and model.newCommentInNewSubject(objectDict):
|
|
newComment = Comments(subject = newObject)
|
|
newComment.fromDict(objectDict['comment'])
|
|
newComment.save()
|
|
return HttpResponse(f"{model.__name__}/{Comments}: Add new Objects: {newObject.toDict()} and {newComment.toDict()}")
|
|
return HttpResponse(f"{model.__name__}: Add new Object: {newObject.toDict()}")
|
|
|
|
def modelHaveParent(model):
|
|
return model != Threads and model != Users
|
|
|
|
def modelIsTrigger(model):
|
|
return model == Triggers
|
|
|
|
def modelIsSubject(model):
|
|
return model == Subjects
|
|
|
|
def newCommentInNewSubject(objectDict):
|
|
return 'comment' in objectDict
|
|
|
|
@classmethod
|
|
def getObject(self, request, objectID, privilige):
|
|
return self.getObjectNormal(self, objectID)
|
|
|
|
def getObjectNormal(model, objectID):
|
|
object = model.objects.get(pk = objectID).toDict()
|
|
return HttpResponse(json.dumps(object))
|
|
|
|
@classmethod
|
|
def getAllObjects(self, request, privilige):
|
|
objectsAll = self.allObjectsDict(self)
|
|
return HttpResponse(json.dumps(objectsAll))
|
|
|
|
@classmethod
|
|
def getObjectsByParentID(self, request, parentID, privilige):
|
|
if self.modelHaveParent(self):
|
|
return HttpResponse(self.getAllByParentID(parentID))
|
|
return HttpResponse("No Permission")
|
|
|
|
@classmethod
|
|
def putObject(self, request, objectID, privilige):
|
|
if checkSession(request, privilige):
|
|
object = jsonLoad(request)
|
|
return self.updateObject(self, request, object, objectID)
|
|
else:
|
|
return HttpResponse("No Permission")
|
|
|
|
def updateObject(model, request, objectDict, objectID):
|
|
objectOld = model.objects.get(pk = objectID)
|
|
if model.modelIsUser(model):
|
|
if checkPassHash(objectDict['passwordOld'], objectOld.password):
|
|
if 'passwordNew' in objectDict.keys():
|
|
objectDict['password'] = createPassHash(objectDict['passwordNew'])
|
|
else:
|
|
return HttpResponse('Bad Password')
|
|
objectOld.fromDict(objectDict)
|
|
if checkUserPermission(objectOld.toDict(), request):
|
|
objectOld.save()
|
|
return HttpResponse(f"{model.__name__}: {objectOld.toDict()} has been updated")
|
|
else:
|
|
return HttpResponse("No Permission")
|
|
|
|
@classmethod
|
|
def deleteObject(self, request, objectID, privilige):
|
|
if checkSession(request, privilige):
|
|
objectDel = self.objects.get(pk = objectID)
|
|
if checkUserPermission(objectDel.toDict(), request):
|
|
if self.modelIsUser(self):
|
|
if checkPassHash(objectDict['password'], objectDel.password):
|
|
pass
|
|
else:
|
|
return HttpResponse("Bad Password")
|
|
objectDel.delete()
|
|
return HttpResponse(f"{self.__name__}: {objectDel} has been deleted")
|
|
else:
|
|
return HttpResponse("No Permission")
|
|
else:
|
|
return HttpResponse("No Permission")
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
class Users(ObjectAbstract):
|
|
login = models.CharField(max_length=30)
|
|
password = models.CharField(max_length=200)
|
|
email = models.EmailField(max_length=50)
|
|
avatar = models.CharField(max_length=255, default='none')
|
|
privilige = models.IntegerField(default=1)
|
|
|
|
def __str__(self):
|
|
return f"{self.id} {self.login}"
|
|
|
|
def fromDict(self, dict):
|
|
self.__dict__.update(dict)
|
|
|
|
def toDict(self):
|
|
return {"id": self.id,
|
|
"login": self.login,
|
|
"avatar": self.avatar,
|
|
"email": self.email,
|
|
"privilige": self.privilige}
|
|
|
|
class Threads(ObjectAbstract):
|
|
name = models.CharField(max_length=30)
|
|
user = models.ForeignKey(Users, on_delete = models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
def fromDict(self, dict):
|
|
self.__dict__.update(dict)
|
|
|
|
def toDict(self):
|
|
return {"id": self.id,
|
|
"name": self.name,
|
|
"user_id": self.user.id,
|
|
"moderator": self.user.login,
|
|
"moderator_avatar": self.user.avatar,
|
|
"moderator_privilige": self.user.privilige}
|
|
|
|
class Subjects(ObjectAbstract):
|
|
name = models.CharField(max_length=30)
|
|
user = models.ForeignKey(Users, on_delete = models.CASCADE)
|
|
thread = models.ForeignKey(Threads, on_delete = models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return f"{self.id} {self.name}"
|
|
|
|
def setParentID(self, parentID):
|
|
self.__dict__.update({ "thread_id": parentID })
|
|
|
|
@classmethod
|
|
def getAllByParentID(self, parentID):
|
|
list = [ x.toDict() for x in self.objects.filter(thread_id = parentID)]
|
|
return json.dumps(list)
|
|
|
|
def fromDict(self, dict):
|
|
self.__dict__.update(dict)
|
|
|
|
def toDict(self):
|
|
return {"id": self.id,
|
|
"name": self.name,
|
|
"user_id": self.user.id,
|
|
"author": self.user.login,
|
|
"author_avatar": self.user.avatar,
|
|
"author_privilige": self.user.privilige,
|
|
"thread_id": self.thread.id,
|
|
"thread_name": self.thread.name}
|
|
|
|
class Comments(ObjectAbstract):
|
|
text = models.CharField(max_length=1000)
|
|
user = models.ForeignKey(Users, on_delete = models.CASCADE)
|
|
subject = models.ForeignKey(Subjects, on_delete = models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return f"{self.user} -> {self.subject}"
|
|
|
|
def setParentID(self, parentID):
|
|
self.__dict__.update({ "subject_id": parentID })
|
|
|
|
@classmethod
|
|
def getAllByParentID(self, parentID):
|
|
list = [ x.toDict() for x in self.objects.filter(subject_id = parentID)]
|
|
return json.dumps(list)
|
|
|
|
def commentSVG(self):
|
|
return
|
|
|
|
def fromDict(self, dict):
|
|
self.__dict__.update(dict)
|
|
|
|
def toDict(self):
|
|
return {"id": self.id,
|
|
"text": self.text,
|
|
"ratings_avg": Ratings.objects.filter(comment_id = self.id).aggregate(Avg('value')),
|
|
"user_id": self.user.id,
|
|
"author": self.user.login,
|
|
"author_avatar": self.user.avatar,
|
|
"author_privilige": self.user.privilige,
|
|
"subject_id": self.subject.id,
|
|
"subject_name": self.subject.name}
|
|
|
|
class Ratings(ObjectAbstract):
|
|
value = models.IntegerField()
|
|
user = models.ForeignKey(Users, on_delete = models.CASCADE)
|
|
comment = models.ForeignKey(Comments, on_delete = models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return f"{self.user}, value: {self.value} -> comment in: {self.comment.subject}"
|
|
|
|
def setParentID(self, parentID):
|
|
self.__dict__.update({ "comment_id": parentID })
|
|
|
|
@classmethod
|
|
def getAllByParentID(self, parentID):
|
|
list = [ x.toDict() for x in self.objects.filter(comment_id = parentID)]
|
|
return json.dumps(list)
|
|
|
|
def fromDict(self, dict):
|
|
self.__dict__.update(dict)
|
|
|
|
def toDict(self):
|
|
return {"id": self.id,
|
|
"value": self.value,
|
|
"user_id": self.user.id,
|
|
"author": self.user.login,
|
|
"author_avatar": self.user.avatar,
|
|
"comment_id": self.comment.id,
|
|
"subject": self.comment.subject.name}
|
|
|
|
class Transactions(ObjectAbstract):
|
|
price = models.FloatField(default=255)
|
|
price_forecast = models.FloatField(default=255)
|
|
currency = models.CharField(max_length=255)
|
|
date_of_transaction = models.DateTimeField('date of transaction')
|
|
course_on_payment = models.FloatField(default=255)
|
|
user = models.ForeignKey(Users, on_delete = models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return f"{self.user.login}, cash: {self.price}, prognosis: {self.price_forecast}"
|
|
|
|
def setParentID(self, parentID):
|
|
self.__dict__.update({ "user_id": parentID })
|
|
|
|
@classmethod
|
|
def getAllByParentID(self, parentID):
|
|
list = [ x.toDict() for x in self.objects.filter(user_id = parentID)]
|
|
return json.dumps(list)
|
|
|
|
def fromDict(self, dict):
|
|
self.__dict__.update(dict)
|
|
|
|
def toDict(self):
|
|
return {"id": self.id,
|
|
"price": self.price,
|
|
"currency": self.currency,
|
|
"date_of_transaction": self.date_of_transaction,
|
|
"course_on_payment": self.course_on_payment,
|
|
"user_id": self.user.id,
|
|
"author": self.user.login,
|
|
"exchange_id": self.exchange.id}
|
|
|
|
class Triggers(ObjectAbstract):
|
|
course_values_for_trigger = models.FloatField(default=255)
|
|
date_of_trigger = models.CharField(max_length=255)
|
|
status = models.IntegerField(default=1)
|
|
user = models.ForeignKey(Users, on_delete = models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return f"{self.user.login}, trigger value: {self.course_values_for_trigger}, date: {self.date_of_trigger}"
|
|
|
|
def setParentID(self, parentID):
|
|
self.__dict__.update({ "user_id": parentID })
|
|
|
|
@classmethod
|
|
def getAllByParentID(self, parentID):
|
|
list = [ x.toDict() for x in self.objects.filter(user_id = parentID)]
|
|
return json.dumps(list)
|
|
|
|
def fromDict(self, dict):
|
|
self.__dict__.update(dict)
|
|
|
|
def toDict(self):
|
|
return {"id": self.id,
|
|
"course_values_for_trigger": self.course_values_for_trigger,
|
|
"date_of_trigger": self.date_of_trigger,
|
|
"status": self.status,
|
|
"user_id": self.user.id,
|
|
"author": self.user.login,}
|
|
|
|
def setActualTime(self):
|
|
self.date_of_trigger = str(datetime.now().strftime("%Y-%d-%m %H:%M"))
|
|
|
|
class Notifications(ObjectAbstract):
|
|
message = models.CharField(max_length=255)
|
|
user = models.ForeignKey(Users, on_delete = models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return f"Message: {self.message}, for User: {self.user.login}"
|
|
|
|
def setParentID(self, parentID):
|
|
self.__dict__.update({ "user_id": parentID })
|
|
|
|
@classmethod
|
|
def getAllByParentID(self, parentID):
|
|
return json.dumps(list(self.objects.filter(user_id = parentID).values()))
|
|
|
|
def fromDict(self, dict):
|
|
self.__dict__.update(dict)
|
|
|
|
def toDict(self):
|
|
return {"id": self.id,
|
|
"message": self.message,
|
|
"user_id": self.user.id}
|