justuser/CryptoDM
1
0
Fork 1
Code Issues Pull Requests Wiki Activity

Compare commits

base: justuser:main
Branches Tags
justuser:main
aswer:main
..
compare: aswer:main
Branches Tags
aswer:main
justuser:main

3 Commits
main ... main

Author SHA1 Message Date
aswer
44c459b537 Update 'README.md' 2024-10-27 11:22:19 +03:00
aswer
00ff8cd887 Update 'README.md' 2024-10-27 11:18:43 +03:00
aswer
93aaf5b91e Update 'README.md' 2024-10-27 11:18:33 +03:00
11 changed files with 428 additions and 781 deletions
Show Stats Expand all files Collapse all files

3
.gitignore vendored
View File

@ -1,3 +0,0 @@
db.json
user_api.json
conf.json

9
README.md
View File

@ -1,5 +1,6 @@
# CryptoDM
# CryptoIZ
Форк https://gitea.del.pw/justuser/dm_moneybot
Новая версия с ТГ, ДС, API и блэкджеком.
Форк https://gitea.del.pw/justuser/CryptoDM#
Новая валюта.
наверное...

296
api.py
View File

@ -1,11 +1,5 @@
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional
from datetime import datetime, timedelta
from statistics import median
from uuid import uuid4
from random import randint
from time import sleep
# Fix 3.3 + 0.15 = 3.4499999999999997
from decimal import Decimal as d
@ -25,66 +19,6 @@ def token_check(token):
else:
return False
############## STATS ##################
STAT_RUN = False
def stat_run(cdm_change):
# Общий баланс, среднее значение, медиана
# Низшее значение, высшее значение
# Изменение баланса и time2cdm
# Прирост за счёт алмазов, за счёт time2cdm
# Защита от конфликтов
global STAT_RUN
while STAT_RUN:
sleep(1)
STAT_RUN = True
# Получаем все балансы
db = read()
bals = []
for id in db['id']:
bals.append(db['id'][id]['bal'])
date = datetime.today().strftime('%Y-%m-%d')
stat = read('stat.json')
if date in stat:
stat[date]['gbal'] += cdm_change
else:
stat[date] = {'gbal': sum(bals), 'time2cdm': 0}
stats = {'gbal': 0, 'average': 0, 'median': 0, 'time2cdm': 0,
'gbal_delta': '0', 'time2cdm_delta': '',
'min': 0, 'max': 0,
'up_diamond': 0}
date = datetime.today().strftime('%Y-%m-%d')
yesterday = (datetime.today() - timedelta(days=1)).strftime('%Y-%m-%d')
if yesterday in stat:
gbal_y = stat[yesterday]['gbal']
time2cdm_y = stat[yesterday]['time2cdm']
else:
gbal_y, time2cdm_y = 0, 0
time2cdm = stat[date]['time2cdm']
gbal = stat[date]['gbal']
# Заполняем данные
stats['gbal'] = round(gbal, 3)
stats['average'] = round(sum([x for x in bals if x != 0])/len([x for x in bals if x != 0]), 3)
stats['median'] = round(median([x for x in bals if x != 0]), 3)
stats['time2cdm'] = round(time2cdm, 3)
stats['time2cdm_delta'] = round(time2cdm-time2cdm_y, 3)
stats['gbal_delta'] = round(gbal-gbal_y, 3)
stats['min'] = round(min([x for x in bals if x != 0]), 3)
stats['max'] = round(max(bals), 3)
stats['up_diamond'] = round(gbal - (gbal_y + time2cdm))
stat[date] = stats
write(stat, 'stat.json')
STAT_RUN = False
#######################
class User_in_db(BaseModel):
token: str
id: str = None
@ -120,11 +54,12 @@ def gen_id():
db = read()
for i in range(1,100000):
check = str(i)
print(db)
if check not in db['id']:
return str(i)
return 'Full?'
class Add_user(BaseModel):
class User_add(BaseModel):
token: str
id: str = None
tg: str = None
@ -132,14 +67,14 @@ class Add_user(BaseModel):
mine: str = None
nick: str
passwd: str
@app.post('/api/add_user/')
def add_user(it: Add_user):
@app.post('/api/user_add/')
def user_add(it: User_add):
token, id, tg, ds, mine, nick, passwd = it.token, it.id, it.tg, it.ds, it.mine, it.nick, it.passwd
id = gen_id()
print(id)
if token_check(token):
db = read()
db['id'][id] = {'tg': tg, 'ds': ds, 'mine': mine, 'nick': nick, 'passwd': passwd
, 'bal': 0.0, 'time2cdm': [0, datetime.today().strftime('%Y-%m-%d')]}
db['id'][id] = {'tg': tg, 'ds': ds, 'mine': mine, 'nick': nick, 'passwd': passwd, 'bal': 0.0}
db['nick'][nick] = id
if tg:
db['tg'][tg] = id
@ -152,11 +87,11 @@ def add_user(it: Add_user):
else:
return 'Error'
class Del_user(BaseModel):
class User_del(BaseModel):
token: str
id: str
@app.post('/api/del_user/')
def del_user(it: Del_user):
@app.post('/api/user_del/')
def user_del(it: User_del):
token, id = it.token, it.id
if token_check(token):
db = read()
@ -174,48 +109,43 @@ def del_user(it: Del_user):
else:
return 'Error'
class Add_coins(BaseModel):
class Coins_add(BaseModel):
token: str
id: str
amount: str
@app.post('/api/add_coins/')
def add_coins(it: Add_coins):
token, id, amount = it.token, it.id, abs(float(it.amount))
@app.post('/api/coins_add/')
def coins_add(it: Coins_add):
token, id, amount = it.token, it.id, float(it.amount)
if token_check(token):
db = read()
db['id'][id]['bal'] = fix_add(db['id'][id]['bal'], amount)
write(db)
stat_run(amount)
return 'OK'
else:
return 'Error'
class Del_coins(BaseModel):
class Coins_del(BaseModel):
token: str
id: str
amount: str
@app.post('/api/del_coins/')
def del_coins(it: Del_coins):
token, id, amount = it.token, it.id, abs(float(it.amount))
if token_check(token):
db = read()
if db['id'][id]['bal'] >= amount:
db['id'][id]['bal'] = fix_sub(db['id'][id]['bal'], amount)
write(db)
stat_run(amount*-1)
return 'OK'
else:
return 'Error'
else:
return 'Error'
@app.post('/api/coins_del/')
def coins_del(it: Coins_del):
token, id, amount = it.token, it.id, float(it.amount)
if token_check(token):
db = read()
db['id'][id]['bal'] = fix_sub(db['id'][id]['bal'], amount)
write(db)
return 'OK'
else:
return 'Error'
class Transfer_coins(BaseModel):
class Coins_transfer(BaseModel):
token: str
src_id: str
dst_id: str
amount: str
@app.post('/api/transfer_coins/')
def transfer_coins(it: Transfer_coins):
@app.post('/api/coins_transfer/')
def coins_transfer(it: Coins_transfer):
token, src_id, dst_id, amount = it.token, it.src_id, it.dst_id, float(it.amount)
if token_check(token):
db = read()
@ -327,7 +257,7 @@ class Update_passwd(BaseModel):
id: str
passwd: str
@app.post('/api/update_passwd/')
def update_passwd(it: Update_passwd):
def update_tg(it: Update_passwd):
token, id, passwd = it.token, it.id, it.passwd
if token_check(token):
db = read()
@ -337,61 +267,18 @@ def update_passwd(it: Update_passwd):
else:
return 'Error'
class Add_time(BaseModel):
token: str
id: str
time: str
@app.post('/api/add_time/')
def add_time(it: Add_time):
token, id, time = it.token, it.id, int(it.time)
if token_check(token):
course = read('conf.json')['time2cdm']
amount = time*course
# Пополнение баланса
db = read()
db['id'][id]['bal'] += amount
# Статистика
date = datetime.today().strftime('%Y-%m-%d')
# Для пользователя
t2c_date = db['id'][id]['time2cdm'][1]
if t2c_date != date:
db['id'][id]['time2cdm'][0] = amount
db['id'][id]['time2cdm'][1] = date
else:
db['id'][id]['time2cdm'][0] += amount
write(db)
# Глобально
stat = read('stat.json')
if date not in stat:
stat_run(0)
stat[date]['time2cdm'] += amount
write(stat, 'stat.json')
stat_run(amount)
return 'OK'
else:
return 'Error'
class Check_bal(BaseModel):
token: str
id: str
@app.post('/api/check_bal/')
def check_bal(it: Check_bal):
token, id = it.token, it.id
if token_check(token):
stat_run(0)
db = read()
# Если дата time2cdm прошла - обнулить баланс
date = datetime.today().strftime('%Y-%m-%d')
t2c_date = db['id'][id]['time2cdm'][1]
if t2c_date != date:
db['id'][id]['time2cdm'][0] = 0
db['id'][id]['time2cdm'][1] = date
write(db)
return db['id'][id]['bal']
else:
return 'Error'
token, id = it.token, it.id
if token_check(token):
db = read()
return db['id'][id]['bal']
else:
return 'Error'
class Get_nick(BaseModel):
token: str
@ -453,120 +340,7 @@ def get_passwd(it: Get_passwd):
else:
return 'Error'
class Get_time2cdm(BaseModel):
token: str
id: str
@app.post('/api/get_time2cdm/')
def get_time(it: Get_time2cdm):
token, id = it.token, it.id
if token_check(token):
db = read()
return db['id'][id]['time2cdm'][0]
else:
return 'Error'
class Get_stat(BaseModel):
token: str
date: Optional[str] = None
@app.post('/api/get_stat/')
def get_stat(it: Get_stat):
token, date = it.token, it.date
if not date:
date = datetime.today().strftime('%Y-%m-%d')
if token_check(token):
stat_run(0)
db = read('stat.json')
if date not in db:
return 'Not found'
stats = db[date]
return stats
else:
return 'Error'
############# USER API ################
class Gen_token(BaseModel):
token: str
id: str
@app.post('/api/gen_token/')
def gen_token(it: Gen_token):
token, id = it.token, it.id
if token_check(token):
user_token = str(uuid4())
user_api = read('user_api.json')
user_api['tokens'][id] = user_token
write(user_api, 'user_api.json')
return user_token
else:
return 'Error'
class List_fp(BaseModel):
token: str
id: str
@app.post('/api/list_fp/')
def list_fp(it: List_fp):
token, id = it.token, it.id
if token_check(token):
user_api = read('user_api.json')
if id not in user_api['fp']:
user_api['fp'][id] = []
write(user_api, 'user_api.json')
return user_api['fp'][id]
else:
return 'Error'
def gen_fp_id(user_api):
ok = False
while not ok:
ok = True
fp_id = str(randint(5236, 645862))
if fp_id in user_api['fp']:
ok = False
return fp_id
class Gen_fp(BaseModel):
token: str
id: str
amount: str
@app.post('/api/gen_fp/')
def gen_fp(it: Gen_fp):
token, id, amount = it.token, it.id, it.amount
if token_check(token):
try:
if float(amount) <= 0.0001:
return 'Error'
amount = str(float(amount)) # Защиты от 1000 нулей в начале
except:
return 'Error'
user_api = read('user_api.json')
if id not in user_api['fp']:
user_api['fp'][id] = []
write(user_api, 'user_api.json')
if len(user_api['fp'][id]) >= 5:
return 'Limit'
fp_id = gen_fp_id(user_api)
user_api['fp'][fp_id] = [id, amount]
user_api['fp'][id].append(fp_id)
write(user_api, 'user_api.json')
return fp_id
else:
return 'Error'
class Del_fp(BaseModel):
token: str
fp_id: str
@app.post('/api/del_fp/')
def del_fp(it: Del_fp):
token, fp_id = it.token, it.fp_id
if token_check(token):
user_api = read('user_api.json')
id = user_api['fp'][fp_id][0]
del user_api['fp'][fp_id]
user_api['fp'][id].remove(fp_id)
write(user_api, 'user_api.json')
return 'OK'
else:
return 'Error'
# TODO: unauth from account
if __name__ == '__main__':
import uvicorn

305
api.py.bak Normal file
View File

@ -0,0 +1,305 @@
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from db import *
app = FastAPI()
def token_check(token):
db = read()
if token in db['tokens']:
return True
else:
return False
class User_in_db(BaseModel):
token: str
id: str = None
tg: str = None
ds: str = None
mine: str = None
nick: str = None
@app.post('/api/user_in_db/')
def user_in_db(it: User_in_db):
token, id, tg, ds, mine, nick = it.token, it.id, it.tg, it.ds, it.mine, it.nick
if token_check(token):
db = read()
if id and id in db['id']:
return id
elif tg and tg in db['tg']:
return db['tg'][tg]
elif ds and ds in db['ds']:
return db['ds'][ds]
elif mine and mine in db['mine']:
return db['mine'][mine]
elif nick and nick in db['nick']:
return db['nick'][nick]
else:
return False
else:
return 'Error'
def gen_id():
db = read()
for i in range(1,100000):
check = str(i)
print(db)
if check not in db['id']:
return str(i)
return 'Full?'
class User_add(BaseModel):
token: str
id: str = None
tg: str = None
ds: str = None
mine: str = None
nick: str
passwd: str
@app.post('/api/user_add/')
def user_add(it: User_add):
token, id, tg, ds, mine, nick, passwd = it.token, it.id, it.tg, it.ds, it.mine, it.nick, it.passwd
id = gen_id()
print(id)
if token_check(token):
db = read()
db['id'][id] = {'tg': tg, 'ds': ds, 'mine': mine, 'nick': nick, 'passwd': passwd, 'bal': 0.0}
db['nick'][nick] = id
if tg:
db['tg'][tg] = id
if ds:
db['ds'][ds] = id
if mine:
db['mine'][mine] = id
write(db)
return 'OK'
else:
return 'Error'
class User_del(BaseModel):
token: str
id: str
@app.post('/api/user_del/')
def user_del(it: User_del):
token, id = it.token, it.id
if token_check(token):
db = read()
tg, ds, mine, nick = db['id'][id]['tg'], db['id'][id]['ds'], db['id'][id]['mine'], db['id'][id]['nick']
del db['nick'][nick]
if tg:
del db['tg'][tg]
if ds:
del db['ds'][ds]
if mine:
del db['mine'][mine]
del db['id'][id]
write(db)
return 'OK'
else:
return 'Error'
class Coins_add(BaseModel):
token: str
id: str
amount: str
@app.post('/api/coins_add/')
def coins_add(it: Coins_add):
token, id, amount = it.token, it.id, float(it.amount)
if token_check(token):
db = read()
db['id'][id]['bal'] += amount
write(db)
return 'OK'
else:
return 'Error'
class Coins_del(BaseModel):
token: str
id: str
amount: str
@app.post('/api/coins_del/')
def coins_del(it: Coins_del):
token, id, amount = it.token, it.id, float(it.amount)
if token_check(token):
db = read()
db['id'][id]['bal'] -= amount
write(db)
return 'OK'
else:
return 'Error'
class Coins_transfer(BaseModel):
token: str
src_id: str
dst_id: str
amount: str
@app.post('/api/coins_transfer/')
def coins_transfer(it: Coins_transfer):
token, src_id, dst_id, amount = it.token, it.src_id, it.dst_id, float(it.amount)
if token_check(token):
db = read()
src_bal = db['id'][src_id]['bal']
if src_bal > amount:
db['id'][src_id]['bal'] -= amount
db['id'][dst_id]['bal'] += amount
write(db)
return 'OK'
else:
return 'No_money'
else:
return 'Error'
class Update_tg(BaseModel):
token: str
id: str
tg: str
@app.post('/api/update_tg/')
def update_tg(it: Update_tg):
token, id, tg = it.token, it.id, it.tg
if token_check(token):
db = read()
cur_tg = db['id'][id]['tg']
del db['tg'][cur_tg]
db['id'][id]['tg'] = tg
db['tg'][tg] = id
write(db)
return 'OK'
else:
return 'Error'
class Update_ds(BaseModel):
token: str
id: str
ds: str
@app.post('/api/update_ds/')
def update_ds(it: Update_ds):
token, id, ds = it.token, it.id, it.ds
if token_check(token):
db = read()
cur_ds = db['id'][id]['ds']
del db['ds'][cur_ds]
db['id'][id]['ds'] = ds
db['ds'][ds] = id
write(db)
return 'OK'
else:
return 'Error'
class Update_mine(BaseModel):
token: str
id: str
mine: str
@app.post('/api/update_mine/')
def update_mine(it: Update_mine):
token, id, mine = it.token, it.id, it.mine
if token_check(token):
db = read()
cur_mine = db['id'][id]['mine']
del db['mine'][cur_mine]
db['id'][id]['mine'] = mine
db['mine'][mine] = id
write(db)
return 'OK'
else:
return 'Error'
class Update_nick(BaseModel):
token: str
id: str
nick: str
@app.post('/api/update_nick/')
def update_nick(it: Update_nick):
token, id, nick = it.token, it.id, it.nick
if token_check(token):
db = read()
cur_nick = db['id'][id]['nick']
del db['nick'][cur_nick]
db['id'][id]['nick'] = nick
db['nick'][nick] = id
write(db)
return 'OK'
else:
return 'Error'
class Update_passwd(BaseModel):
token: str
id: str
passwd: str
@app.post('/api/update_passwd/')
def update_tg(it: Update_tg):
token, id, passwd = it.token, it.id, it.passwd
if token_check(token):
db = read()
db['id'][id]['passwd'] = passwd
write(db)
return 'OK'
else:
return 'Error'
class Check_bal(BaseModel):
token: str
id: str
@app.post('/api/check_bal/')
def check_bal(it: Check_bal):
token, id = it.token, it.id
if token_check(token):
db = read()
return db['id'][id]['bal']
else:
return 'Error'
class Get_nick(BaseModel):
token: str
id: str
@app.post('/api/get_nick/')
def get_nick(it: Get_nick):
token, id = it.token, it.id
if token_check(token):
db = read()
return db['id'][id]['nick']
else:
return 'Error'
class Get_tg(BaseModel):
token: str
id: str
@app.post('/api/get_tg/')
def get_tg(it: Get_tg):
token, id = it.token, it.id
if token_check(token):
db = read()
return db['id'][id]['tg']
else:
return 'Error'
class Get_ds(BaseModel):
token: str
id: str
@app.post('/api/get_ds/')
def get_ds(it: Get_ds):
token, id = it.token, it.id
if token_check(token):
db = read()
return db['id'][id]['ds']
else:
return 'Error'
class Get_mine(BaseModel):
token: str
id: str
@app.post('/api/get_mine/')
def get_mine(it: Get_mine):
token, id = it.token, it.id
if token_check(token):
db = read()
return db['id'][id]['mine']
else:
return 'Error'
# TODO: unauth from account
if __name__ == '__main__':
import uvicorn
uvicorn.run(app, host='127.0.0.1', port=1111)

87
call2api.py
View File

@ -1,5 +1,5 @@
from requests import post
from json import dumps, loads
from json import dumps
from xxhash import xxh32
from db import *
@ -11,20 +11,14 @@ def hash(text):
text = str(text)
return xxh32(text).hexdigest()
def call(api_url, data, pre=True, fix=True):
def call(api_url, data, pre=True):
if pre:
response = post(url_pre + api_url, data=dumps(data))
else:
response = post(api_url, data=dumps(data))
#print(response.status_code)
#print(response.text)
try:
if fix:
return response.text.replace('"', '')
else:
return response.text
except:
return response.text
print(response.status_code)
print(response.text)
return response.text.replace('"', '')
def user_in_db(token, id=None, tg=None, ds=None, mine=None, nick=None):
data = {'token': token}
@ -41,7 +35,7 @@ def user_in_db(token, id=None, tg=None, ds=None, mine=None, nick=None):
#print(data)
return call('api/user_in_db/', data)
def add_user(token, nick, passwd, tg=None, ds=None, mine=None):
def user_add(token, nick, passwd, tg=None, ds=None, mine=None):
passwd = hash(passwd)
data = {'token': token, 'nick': nick, 'passwd': passwd}
if tg:
@ -51,23 +45,23 @@ def add_user(token, nick, passwd, tg=None, ds=None, mine=None):
if mine:
data['mine'] = mine
print(data)
return call('api/add_user/', data)
return call('api/user_add/', data)
def del_user(token, id):
def user_del(token, id):
data = {'token': token, 'id': id}
return call('api/del_user/', data)
return call('api/user_del/', data)
def add_coins(token, id, amount):
def coins_add(token, id, amount):
data = {'token': token, 'id': id, 'amount': amount}
return call('api/add_coins/', data)
return call('api/coins_add/', data)
def del_coins(token, id, amount):
def coins_del(token, id, amount):
data = {'token': token, 'id': id, 'amount': amount}
return call('api/del_coins/', data)
return call('api/coins_del/', data)
def transfer_coins(token, src_id, dst_id, amount):
def coins_transfer(token, src_id, dst_id, amount):
data = {'token': token, 'src_id': src_id, 'dst_id': dst_id, 'amount': amount}
return call('api/transfer_coins/', data)
return call('api/coins_transfer/', data)
def update_tg(token, id, tg):
if tg != None:
@ -92,9 +86,6 @@ def update_passwd(token, id, passwd):
data = {'token': token, 'id': id, 'passwd': hash(passwd)}
return call('api/update_passwd/', data)
def update_time(token, id, time):
data = {'token': token, 'id': id, 'time': time}
return call('api/update_time/', data)
def check_bal(token, id):
data = {'token': token, 'id': id}
@ -105,55 +96,25 @@ def get_nick(token, id):
return call('api/get_nick/', data)
def get_tg(token, id):
data = {'token': token, 'id': id}
return call('api/get_tg/', data)
data = {'token': token, 'id': id}
return call('api/get_tg/', data)
def get_ds(token, id):
data = {'token': token, 'id': id}
return call('api/get_ds/', data)
data = {'token': token, 'id': id}
return call('api/get_ds/', data)
def get_mine(token, id):
data = {'token': token, 'id': id}
return call('api/get_mine/', data)
data = {'token': token, 'id': id}
return call('api/get_mine/', data)
def get_passwd(token, id):
data = {'token': token, 'id': id}
return call('api/get_passwd/', data)
def get_time2cdm(token, id):
data = {'token': token, 'id': id}
return call('api/get_time2cdm/', data)
def get_stat(token, date = None):
data = {'token': token}
if date:
data['date'] = date
return loads(call('api/get_stat/', data, fix=False))
data = {'token': token, 'id': id}
return call('api/get_passwd/', data)
def transfer_callback(addr, token, src_nick, dst_nick, amount):
amount = str(amount)
data = {'token': token, 'src_nick': src_nick, 'dst_nick': dst_nick, 'amount': amount}
print(addr + 'api/transfer_callback/')
return call(addr + 'api/transfer_callback/', data, pre=False)
def gen_token(token, id):
data = {'token': token, 'id': id}
return call('api/gen_token/', data)
def gen_fp_mess(token, nick, amount, chat_id, fp_id):
data = {'token': token, 'nick': nick, 'amount': amount, 'chat_id': chat_id, 'fp_id': fp_id}
return call('http://127.0.0.1:7002/api/gen_fp_mess/', data, pre=False)
def list_fp(token, id):
data = {'token': token, 'id': id}
return call('api/list_fp/', data)
def gen_fp(token, id, amount):
data = {'token': token, 'id': id, 'amount': amount}
return call('api/gen_fp/', data)
def del_fp(token, fp_id):
data = {'token': token, 'fp_id': fp_id}
return call('api/del_fp/', data)
#print( user_in_db('ee77b9d8-44f3-4e01-a702-69d5524ee50b', '1234') )

23
db.py
View File

@ -15,32 +15,13 @@ if not os.path.exists('db.json'):
if not os.path.exists('conf.json'):
db = {'api_token': 'None',
'tg_token': 'None',
'ds_token': 'None',
'push_src_nick': 0,
'push_id': 0,
'push_amount': 0,
'time2cdm': 0,
'owner': 0}
'tg_token': 'None',
'ds_token': 'None'}
js = json.dumps(db, indent=2)
with open("conf.json", "w") as outfile:
outfile.write(js)
print('Created new conf.json')
if not os.path.exists('stat.json'):
db = {}
js = json.dumps(db, indent=2)
with open("stat.json", "w") as outfile:
outfile.write(js)
print('Created new stat.json')
if not os.path.exists('user_api.json'):
db = {'tokens': {}, 'fp': {}}
js = json.dumps(db, indent=2)
with open("user_api.json", "w") as outfile:
outfile.write(js)
print('Created new user_api.json')
def read(file = 'db.json'):
with open(file, "r", encoding="utf-8") as openfile:
db = json.load(openfile)

87
ds.py
View File

@ -86,21 +86,16 @@ async def help(message):
/nick ник - Смена ника
/bal - Баланс
/pay ник сумма - Перевод
/time2cdm - Конвертация времени на сервере в CDM
/stats - Статистика
`
''')
async def bal(message):
send = message.channel.send
if await checkauth(message):
id = user_in_db(API_TOKEN, ds=message.author.id)
coins = check_bal(API_TOKEN, id)
nick = get_nick(API_TOKEN, id)
time = int(get_time(API_TOKEN, id))
hours = time//3600 ; minutes = (time - hours*3600)//60
await send(f'''Ваш баланс: `{coins}` CDM
Время на сервере: `{f"{hours}:{minutes}"}`
send = message.channel.send
if await checkauth(message):
id = user_in_db(API_TOKEN, ds=message.author.id)
coins = check_bal(API_TOKEN, id)
nick = get_nick(API_TOKEN, id)
await send(f'''Ваш баланс: `{coins}` CDM
Ник: `{nick}`''')
@ -212,63 +207,23 @@ async def pay(message):
else:
await send('/pay ник количество')
async def time2cdm(message):
send = message.channel.send
if await checkauth(message):
id = user_in_db(API_TOKEN, ds=message.author.id)
course = read('conf.json')['time2cdm']
time = int(get_time(API_TOKEN, id))
amount = time*course
if update_time(API_TOKEN, id, '0'):
if coins_add(API_TOKEN, id, str(amount)):
# Статистика
stat = read('stat.json')
date = datetime.today().strftime('%Y-%m-%d')
stat[date]['time2cdm'] += amount
write(stat, 'stat.json')
await send(f'''Вы успешно конвертировали время на сервере в `{str(amount)}` CDM.''')
async def stats(message):
send = message.channel.send
if await checkauth(message):
data = get_stat(API_TOKEN)
bal = f'Баланс ({data["gbal_delta"]})'
t2cdm = f'Time2cdm ({data["time2cdm_delta"]})'
max_len = max(len(bal), len(t2cdm), 19)
await send(f'''```json
{bal.ljust(max_len)}: {data["gbal"]}
{t2cdm.ljust(max_len)}: {data["time2cdm"]}
Среднее значение : {data["average"]}
Медиана : {data["median"]}
Минимум : {data["min"]}
Максимум : {data["max"]}
Ввод/вывод алмазов : {data["up_diamond"]}
```
''')
@bot.event
async def on_message(message):
send = message.channel.send
if command('help', message):
await help(message)
elif command('reg', message):
await reg(message)
elif command('login', message):
await login(message)
elif command('unreg', message):
await unreg(message)
elif command('bal', message):
await bal(message)
elif command('passwd', message):
await passwd(message)
elif command('pay', message):
await pay(message)
elif command('time2cdm', message):
await time2cdm(message)
elif command('stats', message):
await stats(message)
send = message.channel.send
if command('help', message):
await help(message)
elif command('reg', message):
await reg(message)
elif command('login', message):
await login(message)
elif command('unreg', message):
await unreg(message)
elif command('bal', message):
await bal(message)
elif command('passwd', message):
await passwd(message)
elif command('pay', message):
await pay(message)
# API для переводов TG->DS / ...

BIN
imgs/2024-12-02_11-36.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 31 KiB

BIN
imgs/2024-12-02_11-46.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

219
tg.py
View File

@ -28,6 +28,7 @@ def checkauth(message, reg = False):
if not reg:
markup = ReplyKeyboardMarkup(resize_keyboard=True)
markup.add('Баланс')
#markup.add('Перевод')
markup.add('Помощь')
bot.reply_to(message, '''Пожалуйста, зарегистрируйтесь или войдите:
/reg Nickname 1234567890
@ -39,71 +40,31 @@ def checkauth(message, reg = False):
@bot.message_handler(commands=['start'])
def start(message):
markup = ReplyKeyboardMarkup(resize_keyboard=True)
markup = ReplyKeyboardMarkup(resize_keyboard=True)
markup.add('Баланс')
markup.add('Помощь')
markup.add('Баланс')
markup.add('Помощь')
if not checkauth(message):
return
if message.text == '/start':
bot.reply_to(message, 'Всё работает', reply_markup=markup)
else:
try:
fp_id = message.text.split(' ')[1]
dst_id, amount = read('user_api.json')['fp'][fp_id]
nick = get_nick(API_TOKEN, dst_id)
if float(amount) <= 0.0001:
bot.reply_to(message, 'Слишком малое или недопустимое значение.')
return
amount = str(float(amount)) # Защиты от 1000 нулей в начале
src_id = user_in_db(API_TOKEN, tg=message.chat.id)
if dst_id == 'false':
bot.reply_to(message, 'Не существует такого пользователя.')
else:
print(src_id)
print(amount)
status = transfer_coins(API_TOKEN, src_id, dst_id, amount)
if status == 'No_money':
bot.reply_to(message, 'Недостаточно средств.')
elif status == 'OK':
bot.reply_to(message, f'''Успешно переведено {hcode(amount)} CDM.
Адресат: {hcode(nick)}''', parse_mode='HTML')
del_fp(API_TOKEN, fp_id)
tg_dst = get_tg(API_TOKEN, dst_id)
ds_dst = get_ds(API_TOKEN, dst_id)
src_nick = nick
if tg_dst != 'null':
transfer_callback('http://127.0.0.1:7002/', API_TOKEN, src_nick, nick, amount)
elif ds_dst != 'null':
transfer_callback('http://127.0.0.1:7003/', API_TOKEN, src_nick, nick, amount)
except:
pass
if not checkauth(message):
pass
else:
bot.reply_to(message, 'Всё работает', reply_markup=markup)
@bot.message_handler(commands=['help'])
def help(message):
bot.reply_to(message, f'''
Доступные команды: `
/help - Помощь
bot.reply_to(message, f'''Исходный код: https://gitea.del.pw/justuser/CryptoDM
Доступные команды:
{hcode("""/help - Помощь
/reg ник - Регистрация
/login ник пароль - Войти в аккаунт
/unreg - Выйти из аккаунта
/passwd пароль - Смена пароля
/nick ник - Смена ника
/bal - Баланс
/pay ник сумма - Перевод
/stats - Статистика
/gen_token - (Ре)генерация токена API
/chat_id - Айди чата
/user_id - Айди пользователя
/burn - Сжечь CDM`
[Исходный код](https://gitea.del.pw/justuser/CryptoDM)
[Документация UserAPI](https://gitea.del.pw/justuser/cdm_example_user_api)
[UserAPI URL](https://cdm-api.del.pw/docs)
''', parse_mode='Markdown')
""")}
''', parse_mode='HTML')
@bot.message_handler(commands=['reg'])
def reg(message):
@ -117,7 +78,7 @@ def reg(message):
com, nick, passwd = message.text.split()
# Проверяем нет ли такого же ника
if user_in_db(API_TOKEN, nick=nick) == 'false':
if add_user(API_TOKEN, nick, passwd, tg=message.chat.id) == 'OK':
if user_add(API_TOKEN, nick, passwd, tg=message.chat.id) == 'OK':
bot.reply_to(message, 'Вы успешно зарегистрированны!')
else:
bot.reply_to(message, 'Что-то пошло не так...')
@ -138,6 +99,7 @@ def login(message):
return 0
com, nick, passwd = message.text.split()
id = user_in_db(API_TOKEN, nick=nick)
print('!!!!', get_tg(API_TOKEN, id))
if get_tg(API_TOKEN, id) != 'null':
bot.reply_to(message, 'Этот пользователь уже авторизован')
elif get_passwd(API_TOKEN, id) == hash(passwd):
@ -150,12 +112,21 @@ def login(message):
else:
bot.reply_to(message, '/login ник пароль')
@bot.message_handler(commands=['unreg'])
def unreg(message):
id = user_in_db(API_TOKEN, tg=message.chat.id)
if update_tg(API_TOKEN, id, 'None') == 'OK':
bot.reply_to(message, 'Вы успешно вышли из аккаунта')
# @bot.message_handler(commands=['unreg'])
# def unreg(message):
# id = user_in_db(API_TOKEN, tg=message.chat.id)
# if update_tg(API_TOKEN, id, 'None') == 'OK':
# bot.reply_to(message, 'Вы успешно вышли из аккаунта')
'''
@bot.message_handler(commands=['unreg'])
def unreg(message):
id = user_in_db(API_TOKEN, tg=message.chat.id)
print(int(id))
print("1")
if user_del(API_TOKEN, id) == 'OK':
bot.reply_to(message, 'OK')
'''
@bot.message_handler(commands=['passwd'])
def passwd(message):
@ -188,11 +159,9 @@ def nick(message):
def bal(message):
if checkauth(message):
id = user_in_db(API_TOKEN, tg=message.chat.id)
coins = round(float(check_bal(API_TOKEN, id)), 4)
coins = check_bal(API_TOKEN, id)
nick = get_nick(API_TOKEN, id)
time2cdm = round(float(get_time2cdm(API_TOKEN, id)), 4)
bot.reply_to(message, f'''Ваш баланс: {hcode(f"{coins}")} CDM
Валюта за время (сегодня): {hcode(f"{time2cdm}")}
bot.reply_to(message, f'''Ваш баланс: {hcode(coins)} CDM
Ник: {hcode(nick)}''', parse_mode='HTML')
@ -210,7 +179,7 @@ def pay(message):
if dst_id == 'false':
bot.reply_to(message, 'Не существует такого пользователя.')
else:
status = transfer_coins(API_TOKEN, src_id, dst_id, amount)
status = coins_transfer(API_TOKEN, src_id, dst_id, amount)
if status == 'No_money':
bot.reply_to(message, 'Недостаточно средств.')
elif status == 'OK':
@ -227,97 +196,6 @@ def pay(message):
else:
bot.reply_to(message, '/pay ник количество')
def format_sign(number):
if '-' in str(number):
return f"{number}"
if number > 0:
return f"+{number}"
elif number == 0:
return f"{number}"
else:
return f"-{number}"
@bot.message_handler(commands=['stats'])
def stats(message):
if checkauth(message):
data = get_stat(API_TOKEN)
bal = f'Баланс ({format_sign(data["gbal_delta"])})'
t2cdm = f'Time2cdm ({format_sign(data["time2cdm_delta"])})'
max_len = max(len(bal), len(t2cdm), 19)
bot.reply_to(message, f'''
```json
{bal.ljust(max_len)}: {data["gbal"]}
{t2cdm.ljust(max_len)}: {data["time2cdm"]}
Среднее значение : {data["average"]}
Медиана : {data["median"]}
Минимум : {data["min"]}
Максимум : {data["max"]}
Ввод/вывод алмазов : {data["up_diamond"]}
```
''', parse_mode='Markdown')
@bot.message_handler(commands=['course'])
def course(message):
conf = read('conf.json')
if message.from_user.id == conf['owner']:
bot.reply_to(message, f'''Текущий курс: `{conf['time2cdm']}`
CDM в час: `{conf['time2cdm']*3600}`''', parse_mode = 'Markdown')
@bot.message_handler(commands=['set_course'])
def set_course(message):
conf = read('conf.json')
if message.from_user.id == conf['owner']:
conf['time2cdm'] = float(message.text.split()[1])
write(conf, 'conf.json')
bot.reply_to(message, f'''Установлен новый курс: `{conf['time2cdm']}`
CDM в час: `{conf['time2cdm']*3600}`''', parse_mode = 'Markdown')
@bot.message_handler(commands=['add'])
def add(message):
conf = read('conf.json')
if message.from_user.id == conf['owner']:
id = user_in_db(API_TOKEN, tg=message.chat.id)
amount = message.text.split()[1]
if add_coins(API_TOKEN, id, amount) == 'OK':
bot.reply_to(message, f'''Начислено `{amount}` CDM.''', parse_mode='Markdown')
else:
bot.reply_to(message, 'Что-то пошло не так...')
@bot.message_handler(commands=['burn'])
def burn(message):
conf = read('conf.json')
if message.from_user.id == conf['owner']:
id = user_in_db(API_TOKEN, tg=message.chat.id)
amount = message.text.split()[1]
if del_coins(API_TOKEN, id, amount) == 'OK':
bot.reply_to(message, f'''🔥Вы безвозвратно сожгли `{amount}` CDM.''', parse_mode='Markdown')
else:
bot.reply_to(message, 'Что-то пошло не так...')
@bot.message_handler(commands=['gen_token'])
def gen_token_tg(message):
if checkauth(message):
id = user_in_db(API_TOKEN, tg=message.chat.id)
token = gen_token(API_TOKEN, id)
bot.reply_to(message, f'''Ваш новый токен: {hcode(f"{token}")}
⚠️ВНИМАНИЕ, не передавайте никому токен. Администрация не спрашивает токены.⚠️''', parse_mode='HTML')
@bot.message_handler(commands=['chat_id'])
def chat_id(message):
print(message.chat.id)
print(f'chat_id: `{message.chat.id}`')
bot.reply_to(message, f'chat\_id: `{message.chat.id}`', parse_mode='Markdown')
@bot.message_handler(commands=['user_id'])
def user_id(message):
bot.reply_to(message, f'user\_id: `{message.from_user.id}`', parse_mode='Markdown')
@bot.message_handler(func=lambda message: True)
def checks(message):
if message.text == 'Баланс':
@ -338,6 +216,7 @@ def transfer_callback_api(it: Transfer_callback_api):
if token in db['tokens']:
dst_id = user_in_db(API_TOKEN, nick=dst_nick)
tg_dst = int(get_tg(API_TOKEN, id=dst_id))
print(tg_dst)
bot.send_message(tg_dst, f'''Вам перевели {hcode(amount)} CDM.
Отправитель: {hcode(src_nick)}''', parse_mode='HTML')
@ -345,34 +224,8 @@ def transfer_callback_api(it: Transfer_callback_api):
else:
return 'Error'
# Генерация сообщения с быстрым платежом
class Gen_fp_mess_api(BaseModel):
token: str
nick: str
amount: str
chat_id: str
fp_id: str
@app.post('/api/gen_fp_mess/')
def gen_fp_mess_api(it: Gen_fp_mess_api):
try:
token, nick, amount, chat_id, fp_id = it.token, it.nick, it.amount, it.chat_id, it.fp_id
token, fp_id, chat_id = it.token, it.fp_id, it.chat_id
keyboard = telebot.types.InlineKeyboardMarkup()
url_button = telebot.types.InlineKeyboardButton('ОПЛАТИТЬ'
, url=f'https://t.me/cdm_bank_bot?start={fp_id}')
keyboard.add(url_button)
bot.send_message(int(chat_id), f'''
`----- ЧЕК -----`
Сумма: `{amount}` CDM
Получатель: `{nick}`
`---------------`''', parse_mode='Markdown', reply_markup=keyboard)
return 'OK'
except:
return 'Error'
def run_api():
uvicorn.run(app, host='0.0.0.0', port=7002)
uvicorn.run(app, host='127.0.0.1', port=7002)
# Запускаем API для переводов
api = Thread(target=run_api)

180
user_api.py
View File

@ -1,180 +0,0 @@
from fastapi import FastAPI, Request, HTTPException
from pydantic import BaseModel
from typing import Optional
from time import time
# Отключение логирования для уменьшения нагрузки
import logging
logging.disable(logging.CRITICAL)
# Fix 3.3 + 0.15 = 3.4499999999999997
from decimal import Decimal as d
def fix_add(one, two):
return float(d(str(one)) + d(str(two)))
def fix_sub(one, two):
return float(d(str(one)) - d(str(two)))
from db import *
from call2api import *
app = FastAPI()
API_TOKEN = read('conf.json')['api_token']
def check_token(nick, token):
db = read('user_api.json')
id = user_in_db(API_TOKEN, nick=nick)
if id != 'false' and token == db['tokens'][id]:
return True
else:
return False
# Анти-DDoS
# Случайные тексты
from faker import Faker
from random import choice, randint
FAKE_TEXTS = [Faker().text(max_nb_chars=100) for _ in range(100)]
# Проверка на частоту обращений
LAST_REQUESTS = {}
def too_fast(request):
ip = request.client.host
now = time()
if ip in LAST_REQUESTS and (now - LAST_REQUESTS[ip]) < 0.1:
return True
LAST_REQUESTS[ip] = time()
return False
class Check_token_user(BaseModel):
nick: str
token: str
@app.post('/api/check_token/')
def check_token_user(request: Request, it: Check_token_user):
if too_fast(request):
raise HTTPException(status_code=randint(100,999), detail=f"{choice(FAKE_TEXTS)}")
nick, token = it.nick, it.token
if check_token(nick, token):
return 'OK'
else:
return 'Error'
class Check_bal_user(BaseModel):
nick: str
token: str
@app.post('/api/check_bal/')
def check_bal_user(request: Request, it: Check_bal_user):
if too_fast(request):
raise HTTPException(status_code=randint(100,999), detail=f"{choice(FAKE_TEXTS)}")
nick, token = it.nick, it.token
if check_token(nick, token):
id = user_in_db(API_TOKEN, nick=nick)
return check_bal(API_TOKEN, id)
else:
return 'Error'
class Get_time2cdm_user(BaseModel):
nick: str
token: str
@app.post('/api/get_time2cdm/')
def get_time_user(request: Request, it: Get_time2cdm_user):
if too_fast(request):
raise HTTPException(status_code=randint(100,999), detail=f"{choice(FAKE_TEXTS)}")
nick, token = it.nick, it.token
if check_token(nick, token):
id = user_in_db(API_TOKEN, nick=nick)
return get_time2cdm(API_TOKEN, id)
else:
return 'Error'
class Get_stat_user(BaseModel):
nick: str
token: str
date: Optional[str] = None
@app.post('/api/get_stat/')
def get_stat_user(request: Request, it: Get_stat_user):
if too_fast(request):
raise HTTPException(status_code=randint(100,999), detail=f"{choice(FAKE_TEXTS)}")
nick, token, date = it.nick, it.token, it.date
if check_token(nick, token):
if date != None:
return get_stat(API_TOKEN, date)
else:
return get_stat(API_TOKEN)
else:
return 'Error'
class Transfer_coins_user(BaseModel):
nick: str
token: str
dst_nick: str
amount: str
@app.post('/api/transfer_coins/')
def transfer_coins_user(request: Request, it: Transfer_coins_user):
if too_fast(request):
raise HTTPException(status_code=randint(100,999), detail=f"{choice(FAKE_TEXTS)}")
nick, token, dst_nick, amount = it.nick, it.token, it.dst_nick, str(float(it.amount))
if check_token(nick, token):
id = user_in_db(API_TOKEN, nick=nick)
dst_id = user_in_db(API_TOKEN, nick=dst_nick)
if dst_id == 'false':
return 'Error'
if transfer_coins(API_TOKEN, id, dst_id, amount) == 'OK':
tg_dst = get_tg(API_TOKEN, dst_id)
if tg_dst != 'null':
transfer_callback('http://127.0.0.1:7002/', API_TOKEN, nick, dst_nick, amount)
return 'OK'
else:
return 'Error'
class Gen_fp_user(BaseModel):
nick: str
token: str
amount: str
chat_id: str
@app.post('/api/gen_fp/')
def gen_fp_user(request: Request, it: Gen_fp_user):
if too_fast(request):
raise HTTPException(status_code=randint(100,999), detail=f"{choice(FAKE_TEXTS)}")
nick, token, amount, chat_id = it.nick, it.token, it.amount, it.chat_id
if check_token(nick, token):
id = user_in_db(API_TOKEN, nick=nick)
fp_id = gen_fp(API_TOKEN, id, amount)
if fp_id == 'Error':
return 'Error'
elif fp_id == 'Limit':
return 'Limit'
else:
return gen_fp_mess(token, nick, amount, chat_id, fp_id)
else:
return 'Error'
class List_fp_user(BaseModel):
nick: str
token: str
@app.post('/api/list_fp/')
def list_fp_user(request: Request, it: List_fp_user):
if too_fast(request):
raise HTTPException(status_code=randint(100,999), detail=f"{choice(FAKE_TEXTS)}")
nick, token = it.nick, it.token
if check_token(nick, token):
id = user_in_db(API_TOKEN, nick=nick)
return list_fp(API_TOKEN, id)
else:
return 'Error'
class Del_fp_user(BaseModel):
nick: str
token: str
fp_id: str
@app.post('/api/del_fp/')
def del_fp_user(request: Request, it: Del_fp_user):
if too_fast(request):
raise HTTPException(status_code=randint(100,999), detail=f"{choice(FAKE_TEXTS)}")
nick, token, fp_id = it.nick, it.token, it.fp_id
if check_token(nick, token):
return del_fp(API_TOKEN, fp_id)
else:
return 'Error'
if __name__ == '__main__':
import uvicorn
uvicorn.run(app, host='0.0.0.0', port=7010)