def GetInstances(self, request: GetInstancesRequest,
context: ServicerContext,
claims: TokenClaims) -> GetInstancesResponse:
session = DBSession()
user = get_user_from_claims(session, claims)
instances = user.instances
session.close()
# find the instances
client = create_client()
resp = GetInstancesResponse()
for db_server in instances:
server = client.connection.get_server_by_id(db_server.id)
flavor = client.connection.get_flavor_by_id(server.flavor["id"])
i = Instance()
i.id = server.id
i.name = server.name
i.imageName = db_server.image_name
i.flavor.name = flavor.name
i.flavor.cpu = flavor.vcpus
i.flavor.memory = flavor.ram
i.flavor.rootDisk = flavor.disk
i.status = server.status
i.vmState = server.vm_state
i.powerState = str(server.power_state)
if server.task_state is not None:
i.taskState = server.task_state
i.ip = server.public_v4
i.createTime = server.created_at
resp.instances.append(i)
return resp
def spider_closed(self, spider):
session = DBSession()
task = session.query(SpiderTask).filter(
SpiderTask.spider_rule_id == self.rule_id,
SpiderTask.end_time == None).first()
if task:
task.end_time = datetime.now()
task.status = "closed"
session.commit()
session.close()
def spider_opened(self, spider):
task = SpiderTask(spider_name=self.name,
spider_rule_id=self.rule_id,
start_time=datetime.now(),
status='running')
session = DBSession()
query = session.query(SpiderTask).filter(
SpiderTask.spider_rule_id == task.spider_rule_id,
SpiderTask.end_time == None)
if query.count() == 0:
session.add(task)
session.commit()
session.close()
def unsubscribe(message):
session = DBSession()
wechat = session.query(Wechat).filter(
Wechat.openid == message.source).one_or_none()
if wechat:
wechat.subscribe = False
wechat.unsubscribe_time = datetime.datetime.now()
else:
wechat = Wechat(openid=message.source, subscribe=False,
unsubscribe_time=datetime.datetime.now(), create_time=datetime.datetime.now())
session.add(wechat)
session.commit()
session.close()
return SuccessReply()
def check_active_trades():
with app.app_context():
session = DBSession()
threads = []
users = session.query(User).filter_by(is_active=True).all()
for user in users:
if len(threads) >= NUM_WORKER_THREADS:
print("waiting for threads to join")
for thread in threads:
thread.join()
threads = []
thread = Thread(target=check_smart_trades_for_user, args=(user, ))
thread.daemon = True
thread.start()
threads.append(thread)
session.close()
class MysqlPipeline(object):
def open_spider(self, spider):
self.session = DBSession()
def close_spider(self, spider):
self.session.close()
def process_item(self, item, spider):
a = Article(title=item["title"],
url=item["url"],
body=item["body"],
text=item["text"],
publish_time=item["publish_time"],
source_site=item["source_site"])
self.session.add(a)
self.session.commit()
return item
def render_GET(self, request):
# self.count +=1
sessionweb = DBSession()
spiderRule = sessionweb.query(SpiderRule).filter(
SpiderRule.enable and SpiderRule.cron == None).one()
# spiderRule.name = '%s-%s'%(spiderRule.name,self.count)
# print('我来了%s次!!!'%spiderRule.name)
self.scheduler.add_job(crawl,
'date',
args=[spiderRule],
name=spiderRule.name,
id='%s' % spiderRule.id,
replace_existing=True)
sessionweb.close()
request.setHeader("Content-Type", "text/html; charset=utf-8")
return ("<html>Hello, world!</html>").encode('utf-8')
class DuplicatesPipeline(object):
def __init__(self):
self.urls_seen = set()
def open_spider(self, spider):
self.session = DBSession()
def close_spider(self, spider):
self.session.close()
def process_item(self, item, spider):
if item['url'] in self.urls_seen:
raise DropItem("Duplicate item found: %s" % item)
else:
self.urls_seen.add(item['url'])
count = self.session.query(Article).filter(
Article.url == item['url']).count()
if count == 0:
return item
else:
raise DropItem("Duplicate item found: %s" % item)
def GetVolumes(self, request, context, claims: TokenClaims):
client = create_client()
session = DBSession()
user = get_user_from_claims(session, claims)
db_volumes = user.volumes
session.close()
resp = GetVolumesResponse()
for db_volume in db_volumes:
volume = client.connection.get_volume_by_id(db_volume.id)
v = Volume()
v.size = volume.size
v.id = volume.id
v.createTime = volume.created_at
attachment = volume.attachments[0]
v.attachedToInstanceId = attachment.server_id
v.attachedToInstanceName = client.connection.get_server_by_id(
attachment.server_id).name
v.attachedToDevice = attachment.device
resp.volumes.append(v)
return resp
sched = TwistedScheduler()
# sched.add_jobstore('sqlalchemy', url='mysql+pymysql://root:djejeUJ3qj^[email protected]:3306/apscheduler')
spiderRules = session.query(SpiderRule).filter(SpiderRule.enable,
SpiderRule.cron).all()
for sr in spiderRules:
if sr.cron:
sched.add_job(crawl,
CronTrigger.from_crontab(sr.cron),
args=[sr],
name=sr.name,
id='%s' % sr.id)
# else:
# sched.add_job(crawl, 'date', args=[sr], name=sr.name, id='%s'%sr.id)
session.close()
class Simple(resource.Resource):
# count = 0
def __init__(self, scheduler):
self.scheduler = scheduler
# self.jobs = works
super(Simple, self).__init__()
isLeaf = True
def render_GET(self, request):
# self.count +=1
def check_smart_trades_for_user(user):
while True:
session = DBSession()
try:
account = session.query(Account).filter_by(user_name=user.username,
type='binance').first()
if account.active == False:
session.close()
continue
apiKey = account.api_key
apiSecret = account.api_secret
account_name = account.name.strip()
profile = session.query(Profile).filter_by(user_id=user.id).first()
if profile:
auto_close_timer = profile.auto_close_timer.split(":")
auto_close_timer = int(auto_close_timer[0]) * 60 + int(
auto_close_timer[1])
else:
auto_close_timer = 720 #minutes
bot = ThreeCommas(apiKey, apiSecret)
try:
smart_trades = bot.get_smart_trades(account_name)
except:
traceback.print_exc()
#send_debug_email("While fetching smart trades", user.user_name, traceback.format_exc())
if smart_trades is None:
print("Something wrong with: ", user.username)
time.sleep(5)
continue
for smart_trade in smart_trades:
if smart_trade['status'] == "buy_order_placed":
created_at = datetime.datetime.strptime(
smart_trade["created_at"], '%Y-%m-%dT%H:%M:%S.%fZ')
now = datetime.datetime.utcnow()
minutes_diff = (now - created_at).total_seconds() / 60
if minutes_diff >= auto_close_timer:
bot.cancel_smart_trade(smart_trade['id'])
continue
updated_targets = []
processed_target = None
for target in smart_trade['take_profit_steps']:
prev_target = {
'percent': target['percent'],
'price': target['price'],
'price_method': 'bid',
'position': target['position']
}
updated_targets.append(prev_target)
if target['status'] == "processed":
already_updated = session.query(
ProcessedTarget).filter_by(
user_name=user.username,
trade_id=smart_trade['id'],
step_id=target['id']).first()
if already_updated:
continue
processed_target = target
if processed_target is not None:
stop_loss = None
if processed_target['position'] == 1:
stop_loss = smart_trade['buy_price']
else:
for step in smart_trade['take_profit_steps']:
if processed_target['position'] - 1 == step[
'position']:
stop_loss = step['price']
break
update = bot.update_smart_trade(smart_trade['id'],
stop_loss, updated_targets)
try:
if update['id']:
processed = ProcessedTarget()
processed.user_name = user.username
processed.trade_id = update['id']
processed.step_id = processed_target['id']
session.add(processed)
session.commit()
#send_update_email(user.user_name, "trade_id = {}, step = {}, stop_loss = {}".format(update['id'], processed_target['position'], stop_loss))
except:
traceback.print_exc()
processed = ProcessedTarget()
processed.user_name = user.username
processed.trade_id = smart_trade['id']
processed.step_id = processed_target['id']
session.add(processed)
session.commit()
#send_debug_email("While updating stop loss after fetching smart trades", user.user_name, json.dumps(update) + "\n" + traceback.format_exc())
except:
traceback.print_exc()
pass
session.close()
time.sleep(5)
def create_trade():
session = DBSession()
pair = request.form.get('pair')
if pair.endswith("BTC"):
pair = pair.split("_")
pair = pair[1] + "_" + pair[0]
buy_price = request.form.get('buy_price')
stop_loss = request.form.get('stop_loss')
targets = []
tp1 = request.form.get('tp1')
tp2 = request.form.get('tp2')
tp3 = request.form.get('tp3')
tp4 = request.form.get('tp4')
note = request.form.get('note')
code = request.form.get('code')
if tp1 is not None and tp1 is not "":
targets.append(tp1)
else:
return jsonify({"status": "error", "message": "Target 1 is required."})
if tp2 is not None and tp2 is not "":
targets.append(tp2)
if tp3 is not None and tp3 is not "":
targets.append(tp3)
if tp4 is not None and tp4 is not "":
targets.append(tp4)
signal = session.query(Signal).filter_by(pair=pair,
buy_price=buy_price,
stop_loss=stop_loss,
tp1=tp1,
tp2=tp2,
tp3=tp3,
tp4=tp4,
note=note,
channel=code).first()
if signal:
return jsonify({"status": "error", "message": "Trade already taken"})
signal = Signal(pair=pair,
buy_price=buy_price,
stop_loss=stop_loss,
tp1=tp1,
tp2=tp2,
tp3=tp3,
tp4=tp4,
note=note,
channel=code)
session.add(signal)
session.commit()
users = session.query(User).filter_by(is_active=True).all()
threads = []
stepSize = get_buy_step_size(pair.split("_")[1])
for user in users:
if len(threads) >= NUM_WORKER_THREADS:
print("waiting for threads to join")
for thread in threads:
thread.join()
threads = []
thread = Thread(target=create_smart_trade,
args=(user, pair, buy_price, targets, stop_loss, note,
signal.id, code, stepSize))
thread.daemon = True
thread.start()
threads.append(thread)
session.close()
return jsonify({
"status": "ok",
"message": "Creating smart orders started."
})
def create_smart_trade(user, pair, buy_price, targets, stop_loss, note,
signal_id, code, stepSize):
try:
session = DBSession()
account = session.query(Account).filter_by(user_name=user.username,
type='binance').first()
if account.active == False:
session.close()
return
apiKey = account.api_key
apiSecret = account.api_secret
bot = ThreeCommas(apiKey, apiSecret)
account_name = account.name.strip()
channel = session.query(Channel).filter_by(user_name=user.username,
code=code).first()
if channel.active == False:
session.close()
return
profile = session.query(Profile).filter_by(user_id=user.id).first()
if profile:
max_trades_per_coin = profile.max_trades_per_coin
coin = pair.split("_")[-1]
total_trades = bot.get_total_trades(coin, account_name)
if total_trades >= max_trades_per_coin:
db_trade = Trade(
signal_id=signal_id,
channel=code,
user_name=user.username,
response=json.dumps({
"status":
"Ignored",
"message":
"max_trades_per_coin is reached for {}".format(pair)
}))
session.add(db_trade)
session.commit()
session.close()
return
else:
session.close()
return
risk = channel.risk_percent
allowed = channel.allowed_percent
base_asset = pair.split("_")[0]
balance = bot.get_balance(account_name, base_asset)
total_value = float(balance['total_btc_value']) * (allowed / 100)
if float(buy_price) > 0.0001:
buy_amount_total_potfolio = math.floor(
((total_value * (float(risk) / 100)) /
(abs((float(stop_loss) / float(buy_price)) - 1)) /
float(buy_price)) * 100) / 100
buy_amount_available_btc = math.floor(
(float(balance['total_available']) / float(buy_price)) *
100) / 100
min_amount = round(0.0011 * len(targets) / float(buy_price), 2)
else:
buy_amount_total_potfolio = math.floor(
(total_value * (float(risk) / 100)) /
(abs((float(stop_loss) / float(buy_price)) - 1)) /
float(buy_price))
buy_amount_available_btc = math.floor(
float(balance['total_available']) / float(buy_price))
min_amount = round(0.0011 * len(targets) / float(buy_price), 0)
buy_amount = buy_amount_total_potfolio
if float(balance['total_available']
) < buy_amount_total_potfolio * float(buy_price):
buy_amount = buy_amount_available_btc
buy_amount = max(buy_amount, min_amount)
if user.username == "bot_refrence_user":
if float(buy_price) > 0.00011:
buy_amount = round((0.0011 * len(targets)) / float(buy_price),
2)
else:
buy_amount = math.ceil(
(0.0011 * len(targets)) / float(buy_price))
buy_amount = format_value(buy_amount, stepSize)
trade = bot.create_smart_trade(account_name=account_name,
pair=pair,
units_to_buy=buy_amount,
buy_price=buy_price,
targets=targets,
stop_loss=stop_loss,
note=note)
db_trade = Trade(signal_id=signal_id,
channel=code,
user_name=user.username,
response=json.dumps(trade))
session.add(db_trade)
session.commit()
session.close()
except:
traceback.print_exc()
session.close()
def subscribe(message):
template_id = 'SO8Yjl0gcmNI0HW-pzgkpJqlPz0GV28llZNVoBjsspA'
user = myrobot.client.get_user_info(message.source)
if user:
session = DBSession()
wechat = session.query(Wechat).filter(
Wechat.openid == user['openid']).one_or_none()
if wechat:
wechat.subscribe = True
wechat.nickname = user['nickname']
wechat.sex = user.get('sex', 0)
wechat.city = user.get('city')
wechat.country = user.get('country')
wechat.province = user.get('province')
wechat.language = user.get('language')
wechat.headimgurl = user.get('headimgurl')
wechat.subscribe_time = datetime.datetime.fromtimestamp(
int(user['subscribe_time']))
wechat.unionid = user.get('unionid')
wechat.remark = user.get('remark')
wechat.groupid = user.get('groupid')
wechat.tagid_list = ','.join(
[str(x) for x in user.get('tagid_list', [])])
wechat.subscribe_scene = user.get('subscribe_scene')
wechat.qr_scene_str = user.get('qr_scene_str')
else:
wechat = Wechat(
openid=user['openid'],
nickname=user['nickname'],
subscribe=user['subscribe'],
sex=user.get('sex', 0),
city=user.get('city'),
country=user.get('country'),
province=user.get('province'),
language=user.get('language'),
headimgurl=user.get('headimgurl'),
subscribe_time=datetime.datetime.fromtimestamp(
int(user['subscribe_time'])),
unionid=user.get('unionid'),
remark=user.get('remark'),
groupid=user.get('groupid'),
tagid_list=','.join([str(x)
for x in user.get('tagid_list', [])]),
subscribe_scene=user.get('subscribe_scene'),
qr_scene_str=user.get('qr_scene_str'),
create_time=datetime.datetime.now()
)
session.add(wechat)
session.commit()
session.close()
r = myrobot.client.post(
url="https://api.weixin.qq.com/cgi-bin/message/template/send",
data={
"touser": message.source,
"template_id": template_id,
"data": {
"first": {
"value": "欢迎关注'千济方开发者开台'公众号",
"color": "#173177"
},
"keyword1": {
"value": "你可点击进入,进行账号绑定.",
"color": "#173177"
},
"keyword2": {
"value": "13888888888",
"color": "#173177"
},
"remark": {
"value": "如有疑问，请联系小孟",
"color": "#173177"
}
},
"miniprogram": {
"appid": "wx79edc80703771261",
#"pagepath": "pages/monitor/monitor"
}
}
)
return SuccessReply()
# return 'Hello %s!' % user['nickname']
else:
return 'Hello My Friend!'
