def delete_menu(restaurant_id: int, menu_id: int):
session = DBSession()
restaurant = session.query(Restaurant).filter_by(
id=restaurant_id).one_or_none()
item = (session.query(MenuItem).filter_by(
id=menu_id, restaurant_id=restaurant_id).one_or_none())
if restaurant is None:
return (
jsonify({"details": f"Restaurant {restaurant_id} does not exist"}),
404,
{},
)
if item is None:
return (
jsonify(
{
"details":
f"Menu item {menu_id} does not exist in restaurant {restaurant.name}",
}, ),
404,
{},
)
session.delete(item)
session.commit()
return (
None,
204,
{},
)
def delete_all_votes():
"""
WARNING: Sending a DELETE request to /delete-votes deletes ALL votes.
"""
# this query deletes all votes
DBSession.query(Vote).delete()
DBSession.commit()
return json.dumps({"result": "OK", "message" : "All votes have been deleted."})
def show_menu(restaurant_id: int):
session = DBSession()
restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one_or_none()
items = session.query(MenuItem).filter_by(restaurant_id=restaurant_id).all()
return render_template(
"4_menu.html",
restaurant=restaurant,
items=items,
)
def oauth_redirect():
print(session)
if request.args.get('state') != app.config['SESSION_STATE']:
return 'Invalid state'
data = urllib.request.urlopen(
'https://www.googleapis.com/oauth2/v4/token',
urllib.parse.urlencode({
'code': request.args.get('code'),
'client_id': app.config['CLIENT_ID'],
'client_secret': app.config['CLIENT_SECRET'],
'redirect_uri': app.config['REDICET_URL'],
'grant_type': 'authorization_code'
}).encode('utf8')).read()
data = json.loads(data.decode('utf8'))
id_token = data['id_token'].split('.')[1]
id_token = id_token + '=' * (4 - len(id_token) % 4
) # パディングが足りなかったりするっぽいので補う
id_token = base64.b64decode(id_token, '-_')
id_token = json.loads(id_token.decode('utf8'))
session['user_id'] = id_token['sub']
users = DBSession.query(User)\
.filter(User.id == id_token['sub'])\
.all()
print(session)
print(users)
if len(users) != 0:
session['name'] = users[0].name
return redirect(url_for('application'))
return redirect(url_for('register'))
def connect_to_server(ip, port, system_id, password, system_type, recipient, message, sms_id, sender_number):
"""
This method is responsible to create client instance to communicate with destination network server as client.
"""
try:
client = SMPPClient(ip, port)
connection = False
notification = 0
while connection is False: # while connection is not established with server, try to connect.
if client.connect():
connection = True
# this thread is checking the socket for getting responses from other server and save in dictionary.
background_thread4 = threading.Thread(target=client.session.storing_recieved_pdus, args=()) # to recieve pdu response from other smpp server to whom it has sent the request.
background_thread4.start()
if client.login('TX', system_id, password, system_type): # if client successfully logins
client.session.send_sms(recipient, message, sender_number)
# till client receives no response for sending sms
while notification == 0:
notification = client.session.notifications_4_client()
client.session.processing_recieved_pdus()
smses = DBSession.query(Sms).filter_by(id=int(sms_id)).first()
if smses:
smses.status = 'delivered'
client.session.unbind()
while client.session.state != SessionState.UNBOUND:
client.session.processing_recieved_pdus()
client.sc.close()
transaction.commit()
background_thread4.join()
except:
pass
def list_votes():
"""
Get the list of all votes.
"""
votes = DBSession.query(Vote).order_by(Vote.id)
json_data = {'votes': [vote.as_dict() for vote in votes]}
return json.dumps(json_data)
def list_people():
"""
Get the list of all people ordered by name.
"""
people = DBSession.query(Person).order_by(Person.name)
# this is more compact, using a list comprehension.
json_data = {'people': [person.as_dict() for person in people]}
return json.dumps(json_data)
def fetch_incoming_sms(user_id):
"""
This method query database to retrieve pending incoming smses for logged in client..
"""
smses = DBSession.query(Sms).filter_by(sms_type='incoming', user_id=user_id, status='recieved').first()
if smses:
smses.status = 'delivered'
return(smses)
def DeleteProject(self, request, context):
client = create_client()
session = DBSession()
for user in session.query(ProjectUser).filter_by(
project_id=request.projectId):
delete_db_user(user, client)
session.delete(user)
session.commit()
return DeleteProjectResponse()
def DeleteUser(self, request: DeleteUserRequest,
context) -> DeleteUserResponse:
client = create_client()
session = DBSession()
for user in session.query(ProjectUser).filter_by(
user_id=request.userId):
delete_db_user(user, client)
session.delete(user)
session.commit()
return DeleteUserResponse()
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 delete_person_votes(person_id):
"""
This deletes all votes for a given Person.
"""
person = DBSession.query(Person).filter_by(id=person_id).first()
if person:
# Delete votes based on a filter queryset
DBSession.query(Vote).filter_by(person_id=person_id).delete()
DBSession.commit()
result = {
"result": "OK",
"message" : "All votes for person {} have been deleted.".format(person)
}
return json.dumps(result)
else:
result = {
"result": "ERROR",
"message": "Person with id {} does not exist.".format(person_id)
}
return json.dumps(result), 404
def list_movies():
"""
Get the list of all movies ordered by name.
"""
movies = DBSession.query(Movie).order_by(Movie.name)
movie_list = []
for movie in movies:
movie_list.append(movie.as_dict())
json_data = {'movies': movie_list}
return json.dumps(json_data)
def delete_plot(id):
if id == None:
return 'Invalid ID'
plot = DBSession.query(Restraurant)\
.filter(Restraurant.id == id)\
.first()
if plot == None:
return 'Invalid ID'
if plot.created_by != session['user_id']:
return 'Invalid ID'
DBSession.delete(plot)
DBSession.commit()
return 'ok'
def updating_status(sms_ids):
"""
This method is responsible to update status of messages from scheduled to delivered when messages are for server of
other network.
"""
if sms_ids:
sms_ids = sms_ids.splitlines()
print(sms_ids)
for sms_id in sms_ids:
smses = DBSession.query(Sms).filter_by(id=int(sms_id)).first()
smses.status = 'delivered'
transaction.commit()
def selected_packages(user_id):
"""
This method is used by server to ensure if logged in user has selected any package or not.
"""
total_selected_package = DBSession.query(Selected_package).filter_by(user_id=user_id).count()
if(total_selected_package > 0):
selected_package = DBSession.query(Selected_package).filter_by(user_id=user_id)[-1] # retrieve last selected package
else:
selected_package = None
if(selected_package is None):
package_name = None
rates = 1.5
else:
end_date = int(selected_package.end_date.strftime('%d'))
end_month = int(selected_package.end_date.strftime('%m'))
end_year = int(selected_package.end_date.strftime('%y'))
date = datetime.datetime.now()
today_date = int(date.strftime('%d'))
today_month = int(date.strftime('%m'))
today_year = int(date.strftime('%y'))
if(end_year > today_year and int(selected_package.smses) > 0):
package_name = selected_package.package_name
rates = 0.0
selected_package.smses = selected_package.smses-1
elif(end_year == today_year and end_month > today_month and int(selected_package.smses) > 0):
package_name = selected_package.package_name
rates = 0.0
selected_package.smses = selected_package.smses-1
elif(end_month == today_month):
if(end_date >= today_date and int(selected_package.smses) > 0):
package_name = selected_package.package_name
rates = 0.0
selected_package.smses = selected_package.smses-1
else:
package_name = None
rates = 1.5
return(dict(package_name=package_name, rates=rates))
def process_incoming_sms():
"""
This method is responsible for processing incoming smses.
"""
sms_ids = ''
smses = DBSession.query(Sms).filter_by(sms_type='incoming', status='recieved', target_network=None, user_id=None).all()
if smses:
for S in smses:
sms_to = S.sms_to
sms_from = S.sms_from
mnp = DBSession.query(Mnp).filter_by(cell_number=sms_to).first() # querying for mobile number conversion
if mnp:
target_network = mnp.target_network
S.sms_type = 'outgoing'
S.status = 'scheduled'
S.validity_period = datetime.date.today()+datetime.timedelta(days=1)
else:
source_prefix = sms_from[0:6] # extract prefix of sender number
dest_prefix = sms_to[0:6] # extract prefix of recipient
s_network = DBSession.query(Prefix_Match).filter_by(prefix=source_prefix).first()
source_network = s_network.network # refers to sender network, getting the network of source from prefixes
d_network = DBSession.query(Prefix_Match).filter_by(prefix=dest_prefix).first()
dest_network = d_network.network # refers to recipient network
user = DBSession.query(User_Number).filter_by(cell_number=sms_to).first() # user refers to normal user
if user:
S.user_id = user.user_id
target_network = None # bECAUSE IT IS FOR CLIENT
else:
# IF network is same or different.
target_network = dest_network # member variable
S.sms_type = 'outgoing'
S.status = 'scheduled'
S.validity_period = datetime.date.today()+datetime.timedelta(days=1)
S.target_network = target_network # from sms table
if target_network != source_network:
connect_info(sms_to, S.msg, dest_network, S.id, sms_from)
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 cancel_result(message_id, user_id):
"""
This method is responsible to cancel sending particular sms if it is not yet delivered.
"""
transaction.commit()
message_id = int(message_id.decode(encoding='ascii'))
smses = DBSession.query(Sms).filter_by(sms_type='outgoing', id=message_id, user_id=user_id).first()
if(smses is None):
return False
elif(smses.status == 'delivered'):
return command_status.ESME_RCANCELFAIL
else:
DBSession.delete(smses)
transaction.commit()
return True
def query_result(message_id, user_id):
"""
This method is responsible to query database for provided message id to view the status of Sms
"""
message_id = int(message_id.decode(encoding='ascii'))
smses = DBSession.query(Sms).filter_by(sms_type='outgoing', id=message_id, user_id=user_id).first() #check for all outgoing sms
if(smses is None):
return(command_status.ESME_RINVMSGID)
elif(smses.status == 'delivered'):
return(dict(state=message_state.DELIVERED, final_date=smses.validity_period))
elif(smses.status == 'scheduled' and smses.validity_period >= datetime.datetime.now()):
return(dict(state=message_state.SCHEDULED, final_date=smses.validity_period))
elif(smses.status == 'scheduled' and smses.validity_period < datetime.datetime.now()):
return(dict(state=message_state.EXPIRED, final_date=smses.validity_period))
def validate(system_id, password, system_type):
"""
This method is used by server to validate credentials provided by client against database
"""
system_id = system_id.decode(encoding='ascii')
passhash = hashlib.sha1(bytes(password.decode(encoding='ascii'), encoding="utf8")).hexdigest()
system_type = system_type.decode(encoding='ascii')
record = DBSession.query(User).filter_by(user_id=system_id, password=passhash, system_type=system_type).first()
if(record):
print("Credentials Validated successfully!!!")
return 'True'
else:
print("Validation failed")
return 'false'
def process_outgoing_sms(sender, user_id, recipient):
"""
This method is responsible for processing outgoing smses.
"""
if sender is not '':
sender_number = sender
else:
user = DBSession.query(User_Number).filter_by(user_id=user_id).first() # user refers to normal user
sender_number = user.cell_number # cell number of sender
source_prefix = sender_number[0:6] # extract prefix of sender number
s_network = DBSession.query(Prefix_Match).filter_by(prefix=source_prefix).first()
source_network = s_network.network # refers to sender network, getting the network of source from prefixes
dest_prefix = recipient[0:6] # extract prefix of recipient
d_network = DBSession.query(Prefix_Match).filter_by(prefix=dest_prefix).first()
dest_network = d_network.network # refers to recipient network
mnp = DBSession.query(Mnp).filter_by(cell_number=recipient).first() # querying for mobile number conversion
if mnp:
target_network = mnp.target_network
elif(source_network == dest_network):
target_network = dest_network
else:
target_network = dest_network
return(dict(sender_number=sender_number, source_network=source_network, target_network=target_network))
def delete_menu_item(restaurant_id: int, menu_id: int):
session = DBSession()
item_to_delete = session.query(MenuItem).filter_by(id=menu_id).one_or_none()
if request.method == "POST":
session.delete(item_to_delete)
session.commit()
flash(f"Menu item {item_to_delete.name} successfully deleted")
return redirect(url_for("show_menu", restaurant_id=restaurant_id))
else:
return render_template(
"7_delete_menu_item.html",
item=item_to_delete,
)
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 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()
def get_quotes():
response.content_type = "application/json"
limit = request.query.limit or 100
offset = request.query.offset or 0
try:
limit = int(limit)
offset = int(offset)
assert 0 <= int(limit) <= 1000 or 0 < int(offset)
except Exception:
return dumps({"Error": "Too much you wish."})
session = DBSession()
quotes = session.query(Quote).order_by(func.random()).limit(limit).offset(offset).all()
return dumps(list(map(lambda x: x.jsonify(), quotes)))
def get_plot():
data = DBSession.query(Restraurant,
User).join(Restraurant,
Restraurant.created_by == User.id).all()
resp = []
for plot in data:
resp.append({
'id': plot.Restraurant.id,
'name': plot.Restraurant.name,
'comment': plot.Restraurant.comment,
'x': plot.Restraurant.x,
'y': plot.Restraurant.y,
'createdBy': plot.User.name,
'isMine': plot.Restraurant.created_by == session['user_id']
})
print(resp)
return jsonify(resp)
def replace_result(message_id, message, user_id):
"""
This method is responsible to replace particular message which is not yet delivered.
"""
message_id = int(message_id.decode(encoding='ascii'))
message = message.decode(encoding='ascii')
smses = DBSession.query(Sms).filter_by(sms_type='outgoing', id=message_id, user_id=user_id).first()
if(smses is None):
return False
elif(smses.status == 'delivered'):
return(command_status.ESME_RREPLACEFAIL)
elif(smses.status == 'scheduled'):
smses.schedule_delivery_time = datetime.datetime.now()
smses. validity_period = datetime.datetime.now()+datetime.timedelta(days=1)
smses.msg = message
transaction.commit()
return True
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')
def delete_restaurant(restaurant_id: int):
session = DBSession()
restaurant_to_delete = (
session.query(Restaurant).filter_by(id=restaurant_id).one_or_none()
)
if request.method == "POST":
session.delete(restaurant_to_delete)
session.commit()
flash(f"Restaurant {restaurant_to_delete.name} successfully deleted")
return redirect(url_for("show_restaurants"))
else:
return render_template(
"3_delete_restaurants.html",
restaurant_id=restaurant_id,
restaurant=restaurant_to_delete,
)
def edit_menu_item(restaurant_id: int, menu_id: int):
session = DBSession()
item_to_edit = session.query(MenuItem).filter_by(id=menu_id).one_or_none()
if request.method == "POST":
if request.form["name"]:
item_to_edit.name = request.form["name"]
session.add(item_to_edit)
session.commit()
flash(f"Menu item successfully edited to {item_to_edit.name}")
return redirect(url_for("show_menu", restaurant_id=restaurant_id))
else:
return render_template(
"6_edit_menu_item.html",
restaurant_id=restaurant_id,
item=item_to_edit,
)
def edit_restaurant(restaurant_id: int):
session = DBSession()
restaurant_to_edit = (
session.query(Restaurant).filter_by(id=restaurant_id).one_or_none()
)
if request.method == "POST":
if request.form["name"]:
restaurant_to_edit.name = request.form["name"]
session.add(restaurant_to_edit)
session.commit()
flash(f"Restaurant successfully edited to {restaurant_to_edit.name}")
return redirect(url_for("show_restaurants"))
else:
return render_template(
"2_edit_restaurants.html",
restaurant_id=restaurant_id,
restaurant=restaurant_to_edit,
)
def put_patch_menu(restaurant_id: int, menu_id: int):
session = DBSession()
item = session.query(MenuItem).filter_by(id=menu_id).one_or_none()
if request.json.get("name") is not None:
item.name = request.json["name"]
if request.json.get("price") is not None:
item.price = request.json["price"]
if request.json.get("description") is not None:
item.description = request.json["description"]
if request.json.get("course") is not None:
item.course = request.json["course"]
session.commit()
return jsonify(
{
"name": item.name,
"description": item.description,
"id": item.id,
"price": item.price,
"course": item.course,
}, )
def connect_info(recipient, message, dest_network, sms_id, sender_number):
"""
This method is responsible to get connection paramters from database to communicate with server of destination network
in case when sender sends a message to some other network.
"""
# here we have to make client object
server = DBSession.query(Network).filter_by(network=dest_network).first()
if server:
print("Establishing Connection with " + server.network.upper() + " Server...")
system_id = server.username
password = server.password
system_type = server.system_type
ip = server.ip
port = server.port
# this thread is responsible for connecting with other smpp server.
background_thread3 = threading.Thread(target=connect_to_server,
args=(ip, port, system_id, password, system_type, recipient, message,
sms_id, sender_number))
background_thread3.start()
background_thread3.join()
def cast_vote(person_id, movie_id):
"""
Submit a vote, one user to one movie. Return whether the vote was cast.
"""
# this query returns None if no rows are returned
exists = DBSession.query(Vote).filter_by(person_id=person_id, movie_id=movie_id).first()
if exists:
result = {
"result": "ERROR",
"message": "Person has already voted for this movie."
}
# HTTP status code 409 means "conflict"
return json.dumps(result), 409
else:
# create a new Vote and save it to the database
vote = Vote(person_id=person_id, movie_id=movie_id)
DBSession.add(vote)
DBSession.commit()
result = {"result": "OK", "message": "Vote registered."}
return json.dumps(result)
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 db_storage(recipients, message, user_id, sender):
"""
This method is responsible to store Sms and related fields provided by client in database
"""
sms_ids = '' # contains all message ids that are sended by client to recipient of same or different network.
#smses_ids = '' # contains only message ids that are sended by client to recipient of some other network.
sender = sender.decode(encoding='ascii')
recipients = recipients.decode(encoding='ascii').splitlines()
selected_package = selected_packages(user_id)
for recipient in recipients:
processed_fields = process_outgoing_sms(sender, user_id, recipient)
# storing vaues to database
S = Sms()
S.sms_type = 'outgoing'
S.sms_from = processed_fields['sender_number']
S.sms_to = recipient
S.schedule_delivery_time = datetime.date.today()
S.validity_period = datetime.date.today()+datetime.timedelta(days=1)
S.msg = message
S.timestamp = datetime.date.today()
S.status = 'scheduled'
S.msg_type = 'text'
S.user_id = user_id
S.package_name = selected_package['package_name']
S.rates = selected_package['rates']
S.target_network = processed_fields['target_network'] # process sms file would use it to send to respective network of which server is.
S.client_type = 'smpp'
DBSession.add(S)
transaction.commit()
sms = DBSession.query(Sms)[-1] # to send id to the client for ancilliary operations and querying.
sms_ids = sms_ids + str(sms.id) + '\n'
if processed_fields['target_network'] != processed_fields['source_network']: # if destination and source network is different
connect_info(recipient, message, processed_fields['target_network'], sms.id,
processed_fields['sender_number']) # connect to the destination's smpp server.
#smses_ids = smses_ids + str(s) + '\n'
#updating_status(smses_ids)
return(sms_ids)
def DeleteInstance(self, request, context):
client = create_client()
# Get the server
server = client.connection.get_server_by_id(id=request.instanceId)
# Get the volume
# volume = server.volumes[0]
# Get the flavor
flavor = client.connection.get_flavor_by_id(server.flavor["id"])
resp = DeleteInstanceResponse()
resp.flavor.name = flavor.name
resp.flavor.cpu = flavor.vcpus
resp.flavor.memory = flavor.ram
resp.flavor.rootDisk = flavor.disk
# Delete the server
client.connection.delete_server(name_or_id=request.instanceId,
wait=True,
delete_ips=True)
# Get the server from db
session = DBSession()
instance = session.query(
models.Instance).filter_by(id=request.instanceId).one()
# Delete the volume.
volume = instance.volumes[0]
resp.volume = volume.size
client.connection.delete_volume(name_or_id=volume.id, force=True)
# Delete the instance from db
session.delete(instance)
session.commit()
return resp
'''This background process is responsible for reading the outgoing smses from database sent by client
and post them to the url on bottle server
'''
import urllib2
import urllib
import db
import transaction
from db import DBSession
from models import Sms, User
import datetime
import time
try:
db.bind_session()
while True:
smses = DBSession.query(Sms).filter_by(status='scheduled', sms_type='outgoing', target_network='zong').all()
if(smses):
for S in smses:
sms_to = S.sms_to
sms_from = S.sms_from
message = S.msg
post_data = {'sms_to': sms_to, 'sms_from': sms_from, 'message': message}
post_str = urllib.urlencode(post_data)
# urlencode converts the dict to a string suitable for POST
# Note when some data is specified in urlopen then HTTP request type
# POST is used instead of GET request type
result = urllib2.urlopen("http://192.168.5.34:50111/" + 'sendsms', post_str).read()
S.status = 'delivered'
S.timestamp = datetime.date.today()
print(result)
transaction.commit()
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 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."
})
from settings import get_scrapy_settings
from spiders.general_spider import GeneralSpider
from db import DBSession, Config, SpiderRule
# from twisted.internet import reactor, defer
from scrapy.crawler import CrawlerRunner
from scrapy.utils.log import configure_logging
from scrapy.utils.project import get_project_settings
from twisted.web import server, resource
from twisted.internet import reactor, endpoints, defer
configure_logging()
session = DBSession()
config = session.query(Config).filter(Config.id == 1).one()
runner = CrawlerRunner(get_scrapy_settings(config))
@defer.inlineCallbacks
def crawl(rule):
dot = rule.spider_clsass.rindex('.')
module, name = rule.spider_clsass[:dot], rule.spider_clsass[dot + 1:]
if (module == GeneralSpider.__module__ and name == GeneralSpider.__name__):
yield runner.crawl(GeneralSpider, rule)
sched = TwistedScheduler()
# sched.add_jobstore('sqlalchemy', url='mysql+pymysql://root:djejeUJ3qj^[email protected]:3306/apscheduler')
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)
