def create_project(project_id, project_description):
"""Takes arguments and create a new project."""
db.connect()
Project.create(project_id=project_id, project_description=project_description)
db.close()
def new_task():
data: json = request.json
try:
db.connect()
task: Task = Task(
project=int(data['project_id']),
name=str(data['name']),
details=str(data['description']),
progress=int(data['status']),
start_date=datetime.datetime.strptime(data['start_date'],
'%m/%d/%Y').date()
if data['start_date'] else datetime.datetime.today().date(),
end_date=datetime.datetime.strptime(data['end_date'],
'%m/%d/%Y').date()
if data['end_date'] else datetime.datetime.today().date())
task.save()
except Exception as e:
print(e)
message = {"status": False, "error": str(e), "data": {}}
else:
message = {"status": True, "error": {}, "data": {}}
finally:
db.close()
return message
def causeStaffPicks(cause):
title = cause.capitalize()
causes_list = cause.split("+")
if request.args.get('staff') is None:
staff = "y"
else:
staff = request.args.get('staff')
quoted_causes = ['"' + str(cause) + '"' for cause in causes_list]
formatted_causes = ','.join(quoted_causes)
if cause != 'all':
q = queries.causeStaffPicks_formatted_causes % (staff,
formatted_causes)
else:
q = queries.causeStaffPicks_causes % (staff)
db_obj = openDB()
db = db_obj[0]
cur = db_obj[1]
j = queryToData(cur, q)
cur.close()
db.close()
if len(j) > 2:
return render_template('cause-campaigns.html',
title=title,
causes=cause,
j=j)
else:
return render_template('cause-campaigns-nodata.html',
title=title,
causes=cause)
def add_donations():
DONATION_AMT = 0
LAST_NAME = 1
donations = [(1.0, 'Halpert'), (1000.0, 'Beesley'), (2000.0, 'Beesley'),
(3000.0, 'Beesley'), (2.0, 'Shrute'), (3.0, 'Shrute'),
(10.0, 'Scott'), (20.0, 'Scott'), (30.0, 'Scott'),
(10.0, 'Bernard'), (20.0, 'Bernard'), (30.0, 'Bernard')]
try:
db.connect()
for donation in donations:
with db.transaction():
n = Donation.create( # noqa F403
donation=donation[DONATION_AMT],
donor=donation[LAST_NAME])
n.save()
logger.info('Donations added.')
except Exception as e:
logger.info(e)
finally:
logger.info('database closes')
db.close()
def causeStaffPicks(cause):
title = cause.capitalize()
causes_list = cause.split("+")
if request.args.get('staff') is None:
staff = "y"
else:
staff = request.args.get('staff')
quoted_causes = ['"'+str(cause)+'"' for cause in causes_list]
formatted_causes = ','.join(quoted_causes)
if cause != 'all':
q = queries.causeStaffPicks_formatted_causes % (staff,formatted_causes)
else:
q = queries.causeStaffPicks_causes % (staff)
db_obj = openDB()
db = db_obj[0]
cur = db_obj[1]
j = queryToData(cur,q)
cur.close()
db.close()
if len(j) > 2:
return render_template('cause-campaigns.html', title=title,causes=cause, j=j)
else:
return render_template('cause-campaigns-nodata.html', title=title,causes=cause)
def add_people():
FIRST_NAME = 0
LAST_NAME = 1
donors = [('Jim', 'Halpert'), ('Pam', 'Beesley'), ('Dwight', 'Shrute'),
('Michael', 'Scott'), ('Andy', 'Bernard')]
try:
db.connect()
for donor in donors:
code = base64.b32encode(os.urandom(8)).decode().strip('=')
with db.transaction():
n = Donor.create( # noqa F403
code=code,
first_name=donor[FIRST_NAME],
last_name=donor[LAST_NAME])
n.save()
logger.info('People added.')
except Exception as e:
logger.info(e)
finally:
logger.info('database closes')
db.close()
def getCausesdata(): db_obj = openDB() db = db_obj[0] cur = db_obj[1] data = queryToData(cur,queries.getCausesdata_causes) cur.close db.close() return data
def create_outgoing_stock(stock, project_id, date, quantity, username):
"""Takes arguments and create a new record for outgoing stocks."""
db.connect()
OutgoingStock.create(stock=stock, project_id=project_id, date=date, quantity=quantity,
username=username)
db.close()
def get_feeds(self, all = False):
"""Return feeds - defaults to returning enabled feeds only"""
if all:
result = [f for f in Feed.select()]
else:
result = [f for f in Feed.select(Feed.enabled == True)]
db.close()
return result
def get_group(self, title):
db.connect()
try:
g = Group.get(Group.title == title)
except Group.DoesNotExist:
g = Group.create(title = title)
db.close()
return g
def getCausesdata():
db_obj = openDB()
db = db_obj[0]
cur = db_obj[1]
data = queryToData(cur, queries.getCausesdata_causes)
cur.close
db.close()
return data
def add_feed(self, url, site_url = None, title = None, group = None):
"""Add a feed to the database"""
# existing feed?
try:
f = Feed.get(Feed.url == url)
except Feed.DoesNotExist:
f = Feed.create(url = url, title=title, site_url=site_url)
db.close()
return f
def create_incoming_stock(**kwargs):
"""Takes arguments and create a new record for incoming stocks."""
db.connect()
IncomingStock.create(stock=kwargs['stock'], date=kwargs['date'],
quantity=kwargs['quantity'], price=kwargs['price'],
cost=kwargs['quantity']*kwargs['price'])
db.close()
def monthly():
db_obj = openDB()
db = db_obj[0]
cur = db_obj[1]
data = queryToData(cur,queries.monthly_stats)
cur.close()
db.close()
return render_template('monthly-stats.html', data=data )
def db_connection():
memdb = CountingSqliteDatabase(":memory:")
models = [User, Post, Follow, Like]
db.initialize(memdb)
db.connect()
db.create_tables(models)
yield memdb
db.drop_tables(models)
db.close()
def monthly():
db_obj = openDB()
db = db_obj[0]
cur = db_obj[1]
data = queryToData(cur, queries.monthly_stats)
cur.close()
db.close()
return render_template('monthly-stats.html', data=data)
def after_request(response):
db.close()
if request.headers.get('origin'):
response.headers.add('access-control-allow-credentials', 'true')
response.headers.add('access-control-allow-headers', 'Authorization, Content-Type, X-Fingerprint')
response.headers.add('access-control-allow-methods', 'DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT, TRACE')
response.headers.add('access-control-allow-origin', '*')
response.headers.add('access-control-max-age', '300')
response.headers.add('cache-control', 'no-cache, no-store')
return response
def inner(*args, **kwargs):
db.connect()
try:
response = view(*args, **kwargs)
except:
raise
else:
return response
finally:
db.close()
def use_db():
db.connect()
db.drop_tables(app_models)
db.create_tables(app_models)
yield db
db.close()
def index(request):
requestdata = {}
pageindex = 1
if 'pageindex' in request.query:
pageindex = int(request.query['pageindex'])
requestdata['pageindex'] = pageindex
pagesize = 15
if 'pagesize' in request.query:
pagesize = int(request.query['pagesize'])
requestdata['pagesize'] = pagesize
ps = fanhao.select()
if 'downed' in request.query and request.query['downed']:
downed = request.query['downed']
ps = ps.where(fanhao.downed == downed)
requestdata['downed'] = downed
if 'code' in request.query and request.query['code']:
code = request.query['code']
ps = ps.where(fanhao.code == code)
requestdata['code'] = code
if 'ma' in request.query and request.query['ma']:
ma = request.query['ma']
if ma == '0' or ma == '1' or ma == '2':
ps = ps.where(fanhao.ima == ma)
requestdata['ma'] = ma
if 'star' in request.query and request.query['star']:
star = request.query['star']
if star == '-1':
star = ''
ps = ps.where(fanhao.star == star)
requestdata['star'] = star
count = ps.count()
allcode = fanhao.select(fanhao.code).order_by(fanhao.code.asc())
allstar = fanhao.select(fanhao.star).group_by(fanhao.star)
ps = ps.order_by(fanhao.id.desc()).paginate(pageindex, pagesize)
pager = Pager(count, pageindex, pagesize)
html = render(
'index.html', {
'allcode': allcode,
'allstar': allstar,
'ps': ps,
'requestdata': requestdata,
'dbweb': getconfig('dbweb', 'url'),
'pagehtml': pager.render()
})
db.close()
return web.Response(body=bytes(html, encoding="utf-8"),
content_type='text/html')
def test_remove_book_for_rent_automated():
driver.get(HOST + ":" + PORT + "/dashboard/rentals")
login_helper()
assert "Your Rentals | Textrade" in driver.title
driver.find_element_by_id("remove-rent-" + str(
BookToRent.select().order_by(BookToRent.id.desc()).get().id)).click()
time.sleep(2)
driver.switch_to_active_element()
driver.find_element_by_id("remove-rent-book").click()
time.sleep(2)
driver.close()
db.close()
def main():
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))
try:
db.connect()
sched.start()
except (KeyboardInterrupt, SystemExit):
pass
except Exception:
logging.error(traceback.print_exc())
finally:
sched.shutdown(wait=False)
db.close()
def get_feeds_with_counts(self, enabled = True):
"""Return feeds - defaults to returning enabled feeds only"""
def _merge(i):
r = i.fields()
r.update({'item_count': i.item_count})
return r
result = [i for i in Feed.select().annotate(Item,fn.Count(Item.id).alias('item_count')).where(Feed.enabled == enabled)]
db.close()
result = map(_merge, result)
return result
def make_task(server_id, status):
sleep(10)
db.connect()
try:
server = Server.get(Server.server_id == server_id)
except Server.DoesNotExist:
db.close()
return False
server.status = status
server.save()
db.close()
return True
def get_project(project_id: int):
try:
db.connect()
project: Project = Project.get(Project.id == int(project_id))
except Exception as e:
print(e)
message = {"status": False, "error": str(e), "data": {}}
else:
message = {"status": True, "error": {}, "data": project.dict()}
finally:
db.close()
return message
def get_projects():
projects: List[Project] = []
try:
db.connect()
for project in Project.select():
projects.append(project.dict())
except Exception as e:
print(e)
message = {"status": False, "error": str(e), "data": {}}
else:
message = {"status": True, "error": {}, "data": projects}
finally:
db.close()
return message
def get_project_tasks(project_id: int):
tasks: List[Task] = []
try:
db.connect()
for task in Task.select(Task.project.id == int(project_id)):
tasks.append(task.dict())
except Exception as e:
print(e)
message = {"status": False, "error": str(e), "data": {}}
else:
message = {"status": True, "error": {}, "data": tasks}
finally:
db.close()
return message
def campaignDataEnpoint(nid):
try:
nid = int(nid)
q_metadata = queries.campaignDataEnpoint_basic_campaign_metadata % (nid)
db_obj = openDB()
db = db_obj[0]
cur = db_obj[1]
text = queryToData(cur,q_metadata)
cur.close()
db.close()
return text
except:
return json.dumps({'error':500})
def query_donors():
try:
db.connect()
query = (
Donor # noqa F403
.select(Donor, Donation) # noqa F403
.join(Donation, JOIN.INNER)) # noqa F403
for row in query:
logger.info(f'{row.last_name} {row.donation.donation}')
except Exception as e:
logger.info(e)
finally:
logger.info('database closes')
db.close()
def deimg(request):
if 'pid' not in request.query:
return jsonres(-1, 'pid err')
pid = request.query['pid']
try:
rs = fanhao.get(fanhao.id == pid)
rs.delete_instance()
if os.path.exists(os.path.join(PHOTO_PATH, rs.code + '.jpg')):
os.remove(os.path.join(PHOTO_PATH, rs.code + '.jpg'))
db.close()
return jsonres(0, 'ok', '删除成功')
except fanhao.DoesNotExist:
pass
def campaignDataEnpoint(nid):
try:
nid = int(nid)
q_metadata = queries.campaignDataEnpoint_basic_campaign_metadata % (
nid)
db_obj = openDB()
db = db_obj[0]
cur = db_obj[1]
text = queryToData(cur, q_metadata)
cur.close()
db.close()
return text
except:
return json.dumps({'error': 500})
def test_add_book_for_rent_automated():
driver.get(HOST + ":" + PORT + "/dashboard/rentals/")
login_helper()
assert "Your Rentals | Textrade" in driver.title
driver.find_element_by_id("add-book").click()
time.sleep(2)
driver.switch_to_active_element()
driver.find_element_by_id("book").send_keys("C How to Program")
driver.find_element_by_id("isbn").send_keys("9780133976892")
select = Select(driver.find_element_by_id("condition"))
select.select_by_index(3)
driver.find_element_by_id("condition_comment").send_keys(
"This is an automated test.")
driver.find_element_by_id("marks").click()
time.sleep(2)
driver.find_element_by_id("send-request").send_keys(Keys.ENTER)
db.close()
def _saveInf(infoData):
try:
fhinfo = fanhao.get(fanhao.code == infoData['code'])
except fanhao.DoesNotExist:
fhinfo = fanhao()
# try:
fhinfo.code = infoData['code']
fhinfo.title = infoData['title']
fhinfo.star = infoData['star'] or '-暂无'
fhinfo.starcode = infoData['starcode']
fhinfo.img = infoData['imgsrc']
fhinfo.fname = infoData['filename']
# fhinfo.ima = 0
# fhinfo.updateTime = int(time.time())
fhinfo.save()
db.close()
return json(0)
def check_donor(key):
try:
db.connect()
query = (
Donor # noqa F403
.select(Donor, Donation) # noqa F403
.join(Donation, JOIN.INNER) # noqa F403
.where(Donor.last_name == key)) # noqa F403
if query.exists():
return True
except Exception as e:
logger.info(e)
finally:
logger.info('database closes')
db.close()
def expand_links(feed, links):
"""Try to expand a link without locking the database"""
result = {}
for l in links:
(schema, netloc, path, params, query, fragment) = urlparse.urlparse(l)
if netloc and schema in ['http','https']:
try:
link = Link.get(url = l)
result[l] = link.expanded_url
db.close()
except Link.DoesNotExist:
expanded_url = expand(l)
Link.create(url = l, expanded_url = expanded_url, when = time.time())
db.close()
result[l] = expanded_url
else:
result[l] = l
return result
def create_db():
"""
Re-creates the entire database from the scratch.
"""
import inspect
import os
import models
from models import DATABASE, db
def is_model(obj):
return (inspect.isclass(obj) and
issubclass(obj, models.BaseModel) and
obj is not models.BaseModel)
models = [value for (name, value) in inspect.getmembers(models, is_model)]
os.remove(DATABASE)
db.connect()
db.create_tables(models)
db.close()
def getSpecificCampaign(cause,campaign):
#when redoing this function, don't need to break it down so far. because there are no longer tables for each campaign
#if there si no data it will just be blank. the decsionibg happens for conversion rate, report backs, and impact.
# campaign=str(request.form['vals']).replace(" ","_").lower()
name=str(campaign).replace("+","_").lower()
db_obj = openDB()
db = db_obj[0]
cur = db_obj[1]
data = queryToData(cur,queries.getSpecificCampaign_campaign_info.format(name),need_json=0)
is_sms = data[0]['is_sms']
is_staff_pick = data[0]['staff_pick']
data = {}
def query(name,query):
info = queryToData(cur,query)
data[name]=info
if is_sms=='n' and is_staff_pick=='y':
query('signups',queries.getSpecificCampaign_staff_sign_up.format(name))
query('newmembers',queries.getSpecificCampaign_staff_new_members.format(name))
query('sources',queries.getSpecificCampaign_staff_sources.format(name))
query('traffic',queries.getSpecificCampaign_traffic_regular.format(name))
query('overall', queries.getSpecificCampaign_overall.format(name))
if is_sms=='n' and is_staff_pick=='n':
query('signups',queries.getSpecificCampaign_nonstaff_sign_up.format(name))
query('newmembers',queries.getSpecificCampaign_nonstaff_new_members.format(name))
query('sources',queries.getSpecificCampaign_nonstaff_sources.format(name))
query('traffic',queries.getSpecificCampaign_traffic_regular.format(name))
query('overall', queries.getSpecificCampaign_overall.format(name))
if is_sms=='y' and is_staff_pick=='y':
query('signups',queries.getSpecificCampaign_staff_sign_up.format(name))
query('newmembers',queries.getSpecificCampaign_staff_new_members.format(name))
query('sources',queries.getSpecificCampaign_staff_sources.format(name))
query('traffic',queries.getSpecificCampaign_traffic_sms.format(name))
query('overall', queries.getSpecificCampaign_overall.format(name))
cur.close()
db.close()
return render_template('campaign-specific.html',campaign=campaign.replace("+"," ").upper(),signups=data['signups'],newmembers=data['newmembers'],sources=data['sources'],traffic=data['traffic'],overall=data['overall'])
def run():
gs = GSData()
db.connect()
with open('data.txt', encoding='utf-8') as f:
for line in f:
wx_name = line.split(' ')[0]
try:
data = gs.query(wx_name)
except GSException as ex:
print(str(ex))
continue
else:
for item in data:
url = 'https://{0}'.format(item['url'].split('://', 1)[1])
md5s = hashlib.md5(url.encode('utf-8')).hexdigest()
if Paper.select().where(Paper.url_hash == md5s).count():
continue
print(item)
p = Paper.create(
wx_name=item['wx_name'],
name=item['name'],
title=item['title'],
author=item['author'],
content=item['content'],
url=url,
url_hash=md5s,
post_time=datetime.strptime(item['posttime'],
'%Y-%m-%d %H:%M:%S'),
add_time=datetime.strptime(item['add_time'],
'%Y-%m-%d %H:%M:%S'))
if type(item['readnum_newest']) == int:
p.read_num = item['readnum_newest']
if type(item['likenum_newest']) == int:
p.like_num = item['likenum_newest']
if item['picurl']:
p.pic_url = item['picurl']
p.save()
sleep(3)
db.close()
def loggings():
import os
import psycopg2
db = psycopg2.connect(database='brewasis',
host="127.0.0.1",
port="5432",
password="******",
user="******")
c = db.cursor()
c.execute('select * from loggings')
# loggings = [dict(id=row[0],users=row[1],password=row[2],time=row[3])for row in reversed(c.fetchall())]
loggings = [
dict(id=row[0], users=row[1], entered=row[3], time=row[2])
for row in reversed(c.fetchall())
]
db.close()
return render_template('loggings.html', loggings=loggings)
def set(request):
type = request.match_info.get('type')
id = request.match_info.get('id')
val = request.match_info.get('val')
if not type or not id or not val:
return jsonres(1, 'args err')
try:
f = fanhao.get(fanhao.id == id)
if type == 'starnum':
f.starnum = int(val)
if type == 'downed':
f.downed = int(val)
if type == 'iface':
f.iface = int(val)
if type == 'ima':
f.ima = int(val)
f.save()
db.close()
return jsonres(0, 'ok')
except fanhao.DoesNotExist:
return jsonres(1, 'not exist')
def store_json_data(self, json_data_list):
# start = time.clock()
try:
db.connect()
trump_twitter_id = "25073877"
for json_data in json_data_list:
is_trump_activity = json_data['user'][
'id_str'] == trump_twitter_id
if is_trump_activity:
self.trump_twitter_analyzer.trump_statuses(json_data)
else:
is_retweet = json_data.get('retweeted_status', False)
if is_retweet:
self.trump_twitter_analyzer.retweets_of_trump_data(
json_data)
else:
self.trump_twitter_analyzer.replies_to_trump_statuses(
json_data)
except Exception as e:
print(e)
finally:
db.close()
def fetch_feed(self, feed):
socket.setdefaulttimeout(settings.fetcher.timeout)
if not feed.enabled:
return
(schema, netloc, path, params, query, fragment) = urlparse.urlparse(feed.url)
now = time.time()
if feed.last_checked:
if feed.ttl:
if (now - feed.last_checked) < (feed.ttl * 60):
log.info("%s - throttled (TTL)" % netloc)
return
if (now - feed.last_checked) < settings.fetcher.min_interval:
log.info("%s - throttled (interval)" % netloc)
return
if feed.last_modified:
if (now - feed.last_modified) < settings.fetcher.min_interval:
log.info("%s - throttled (last-modified)" % netloc)
return
modified = http_time(feed.last_modified)
else:
modified = None
try:
res = feedparser.parse(feed.url, etag = feed.etag, modified = modified)
except Exception, e:
log.error("Could not fetch %s: %s" % (feed.url, e))
socket.setdefaulttimeout(None)
feed.last_checked = now
feed.save()
db.close()
return
def login():
if current_user.is_authenticated:
return redirect(url_for('bkapp_page'))
error = None
if request.method == 'POST':
userN = request.form['username']
passwN = request.form['password']
import os
# DATABASE_URL = os.environ['DATABASE_URL']
import psycopg2
db = psycopg2.connect(database='brewasis',
host="127.0.0.1",
port="5432",
password="******",
user="******")
c = db.cursor()
c.execute("select users from login where users= '{}'".format(userN))
userN1 = c.fetchone()
c.execute("select password from login where users= '{}'".format(userN))
passwN1 = c.fetchone()
try:
if (userN != userN1[0]) or not (bcrypt.check_password_hash(
passwN1[0], passwN)):
# if (userN != userN1[0]) or (passwN != passwN1[0]):
error = 'Invalid Credentials. Please try again.'
c.execute(
"insert into loggings(users, entered)values('{}', '{}')".
format(userN, 'unsuccessful'))
db.commit()
db.close()
else:
userlogin = Login.query.filter(Login.users == userN).first()
login_user(userlogin)
# next = flask.request.args.get('next')
# # is_safe_url should check if the url is safe for redirects.
# # See http://flask.pocoo.org/snippets/62/ for an example.
# if not is_safe_url(next):
# return flask.abort(400)
# session['logged_in'] = True
c.execute(
"insert into loggings(users, entered)values('{}', '{}')".
format(userN, 'successful'))
db.commit()
db.close()
return redirect(url_for('bkapp_page'))
except Exception as e:
logging.error("Exception occurred", exc_info=True)
error = 'Invalid Credentials. Please try again .'
c.execute("insert into loggings(users, entered)values('{}', '{}')".
format(userN, 'unsuccessful'))
db.commit()
db.close()
return render_template('login.html', error=error)
def after_request(response):
db.close()
return response
def __del__(self):
db.close()
def create_role(role_name):
"""Takes the role name as an argument and create it."""
db.connect()
Role.create(role_name=role_name)
db.close()
def get_json_files(path_to_directory):
concat_paths = lambda x: path_to_directory + '/' + x
file_filter = lambda x: '~lock' not in x and '.json' in x
files = os.listdir(path_to_directory)
files = filter(file_filter, files)
files = map(concat_paths, files)
return files
#get dictionary for looking up team objects by team code
def get_team_dict():
team_dict = {}
for team in Team.select():
team_dict[team.code] = team
return team_dict
def sanitize_string(string):
string = string.strip()
return string
if __name__ == '__main__':
drop_tables()
create_tables()
db.connect()
create_team_records()
create_athlete_records()
team_dict = get_team_dict()
import_games(PATH_TO_GAME_LIST, team_dict)
db.close()
def get_users(self):
result = [u for u in User.select()]
db.close()
return result
def process_response(self, req, res, resource):
if not db.is_closed():
db.close()
def drop_tables(): db.connect() db.drop_tables([Athlete, Team, Game, Play, Collaboration, Action, Observation]); db.close()
def write_event(msg):
db.connect()
event = Event(message=msg)
event.save()
db.close()
def get_user(self, username):
result = User.get(User.username == username)
db.close()
return result
def after_request():
response.headers['Content-Type'] = 'application/json'
db.close()
def _db_close(exc):
if not db.is_closed():
db.close()
def tearDown(self): cleanDB() db.close()
def create_tables(): db.connect() db.create_tables([Athlete, Team, Game, Play, Collaboration, Action, Observation]) db.close()
def checkin_db(exc):
try:
db.close()
except AttributeError:
pass
def get_subscriptions_for(self, user):
result = [s for s in Subscriptions.select(user = user)]
db.close()
return result
def db_close(http_resp):
""" Disconnect and close database """
db.close()
return http_resp
def add_feed_to_group(self, user, feed, group):
s = Subscription.create(user = user, feed = feed, group = group)
db.close()
return s
