def get_trophy_conversations(request, trophy_id):
"""
:param request:
:param trophy_id:
:return:
"""
try:
t = TrophyModel.objects.get(pk=trophy_id)
conversations = Conversation.objects.filter(
trophy=t, closed=False).order_by('date')
c_messages = [{
'conversation_id':
item.id,
'customer_image':
item.customer.profile_image,
'has_new_message':
item.has_new_message,
'customer_username':
item.customer.username,
'customer_id':
item.customer.id,
'recent_message':
Message.objects.filter(
conversation=item).order_by('-id')[0].message
} for item in conversations]
c_n = Conversation.objects.filter(dealer=request.user,
has_new_message=True,
closed=False).values('trophy_id')
t_n = list(set([v['trophy_id'] for v in c_n]))
return json_response(success=True, data=c_messages, new_conv_trop=t_n)
except TrophyModel.DoesNotExist:
return json_response(success=False, message='Invalid Request.')
async def DELETE(self, request: Request, token: str, *args, **kwargs):
if token == "ALL":
if self.cursor.tokens.deleteAll():
if self.cursor.files.deleteAll():
return json_response(
{"message": "Table Emptied Sucessfully"})
else:
return json_response(
{"message": "Error deleting table : Files"})
else:
return json_response(
{"message": "Error deleting table : Tokens"})
if (token_rec := self.cursor.tokens.fetchOne(token)):
try:
file_rec = self.cursor.files.fetchOne(
md5(token_rec.file.encode()).hexdigest())
token_rec.destroy()
file_rec.destroy()
return json_response(
{"message": "File Removed From Sharing List"})
except:
token_rec.write()
file_rec.write()
return json_response({"message": "Cannot Remove File"})
def un_block_user(request, user_id):
user = request.user
try:
blocked_user = CustomUser.objects.get(pk=user_id)
b = BlockModel.objects.get(blocker=user, blocked_user=blocked_user)
b.enabled = False
b.save()
except CustomUser.DoesNotExist:
return json_response(success=False, message='Invalid Request')
return json_response(success=True, message='User UnBlocked')
def get_default_response(request, conversation_id):
"""
:param request:
:param o_id:
:return:
"""
try:
o = Conversation.objects.get(pk=conversation_id)
return json_response(
success=True,
data={'default_order_response': o.trophy.default_order_response})
except TrophyModel.DoesNotExist:
return json_response(success=False, message='Invalid Request.')
def block_user(request, user_id):
user = request.user
try:
blocked_user = CustomUser.objects.get(pk=user_id)
b = BlockModel.objects.get(blocker=user, blocked_user=blocked_user)
b.enabled = True
b.date = timezone.now()
b.save()
except CustomUser.DoesNotExist:
return json_response(success=False, message='Invalid request.')
except BlockModel.DoesNotExist:
b = BlockModel(blocker=user, blocked_user=blocked_user)
b.save()
return json_response(success=True, message='User Blocked')
def edit_trophy(request, o_id):
form = TrophyForm(request.POST)
if form.is_valid():
try:
o = TrophyModel.objects.get(pk=o_id)
except TrophyModel.DoesNotExist:
return json_response(success=False, message='Invalid Object.')
cleaned_data = form.cleaned_data
o.trophy = cleaned_data['trophy'].lower()
o.message = cleaned_data['message']
o.default_order_response = cleaned_data['default_order_response']
o.enabled = True
o.save()
return json_response(success=True, message="Trophy Edited.")
return json_response(success=False, errors=form.errors)
async def POST(self, request: Request, *args, **kwargs) -> dict:
data = await request.get_json()
md5_sum = md5(data['file'].encode()).hexdigest()
token = None
if (rec := self.cursor.files.fetchOne(md5_sum)):
return json_response(self.cursor.tokens.fetchOne(rec.token)())
def get_trophy(request, o_id):
"""
:param request:
:param o_id:
:return:
"""
try:
o = TrophyModel.objects.get(pk=o_id)
return json_response(success=True,
data={
'trophy': o.trophy,
'message': o.message,
'default_order_response':
o.default_order_response
})
except TrophyModel.DoesNotExist:
return json_response(success=False, message='Invalid Request.')
def delete_trophy(request, o_id):
try:
o = TrophyModel.objects.get(pk=o_id)
o.trophy = ''
o.message = ''
o.enabled = False
o.save()
except TrophyModel.DoesNotExist:
pass
return json_response(success=True, message='Trophy Delete Successful !!')
def add_trophy(request):
form = TrophyForm(request.POST)
if form.is_valid():
cleaned_data = form.cleaned_data
trophy = cleaned_data['trophy'].lower()
try:
TrophyModel.objects.get(trophy=trophy, dealer=request.user)
form.add_error(
'trophy',
'The trophy "%s" has already been added by the user.' % trophy)
return json_response(success=False, errors=form.errors)
except TrophyModel.DoesNotExist:
o = TrophyModel()
o.dealer = request.user
o.trophy = trophy
o.message = cleaned_data['message']
o.save()
return json_response(success=True, message='New Trophy Added !!')
return json_response(success=False, errors=form.errors)
async def index(request: Request):
with open(_CONFIGPATH, 'w+') as file:
config = str(await request.content, encoding='utf-8')
file.write(config)
return json_response(data={'message': 'Config saved succesfully'})
async def GET(self, request: Request, token: str):
if token == "GET_TOKENS":
if request.header.host.split("/")[0].split(":")[0] == "localhost":
return json_response({"tokens": self.cursor.tokens.fetchAll()})
else:
return json_response(
{
"message": "Not Allowed !",
"status": False
},
status_code=405)
if (rec := self.cursor.tokens.fetchOne(token)):
if rec.private:
if 'authentication' not in request.header:
return json_response(
{
"message": "Autherization Error",
"status": False
},
status_code=401)
if request.header.authentication not in self.config[
'allowed_hosts']:
return json_response(
{
"message": "Not Allowed",
"status": False
},
status_code=405,
message='Not Allowed')
if pathlib.isfile(rec.file):
if self.urlxre.match(request.header.host):
if rec.local:
headers = {
"content_disposition":
f'attachment; filename={rec.filename}',
"filename": rec.filename,
"md5": rec.md5
}
response = await send_file(rec.file,
request,
headers=headers,
chunk_size=10240)
return response
else:
return json_response(
{
"message": "File not open for local sharing",
"status": False
},
status_code=401)
headers = {
"content_disposition":
f'attachment; filename={rec.filename}',
"filename": rec.filename,
"md5": rec.md5
}
response = await send_file(rec.file, request, headers=headers)
return response
else:
return json_response(
{
"message": "File Does Not Exist !",
"status": False
},
status_code=404)
async def name_id(request: Request, name, idd):
return json_response({"name": name, "id": idd})
"md5": rec.md5
}
response = await send_file(rec.file, request, headers=headers)
return response
else:
return json_response(
{
"message": "File Does Not Exist !",
"status": False
},
status_code=404)
else:
return json_response(
{
"message": "File Not Found !",
"status": False
},
status_code=404)
async def POST(self, request: Request, *args, **kwargs) -> dict:
data = await request.get_json()
md5_sum = md5(data['file'].encode()).hexdigest()
token = None
if (rec := self.cursor.files.fetchOne(md5_sum)):
return json_response(self.cursor.tokens.fetchOne(rec.token)())
if data['private']:
token = self.__token__(4)
else:
token = HTTPRequest(method='post',
