def start_lottery(self):
global d
d = Database()
idLotto = d.get_last_lottery_id()
if not idLotto:
d.create_lotto()
idLotto = d.get_last_lottery_id()
while True:
if (time.localtime().tm_sec == 0
and time.localtime().tm_min % lottery_time == 0):
numbers = []
result = []
for i in range(6):
x = False
while (x == False):
r = random.randint(1, 49)
if r not in numbers:
numbers.append(r)
result.append(str(r))
x = True
d = Database()
result.sort(key=int)
d.create_lotto()
d.update_lotto_after_lottery(str(idLotto), result)
idLotto = d.get_last_lottery_id()
del d
time.sleep(2)
class Vote(Database().DynamicDocument):
''' class to store vote data '''
number = Database().IntField()
symbol = Database().StringField(max_length=5)
ticker = Database().StringField(max_length=40)
created_at = Database().DateTimeField(default=datetime.now())
class Action(Database().DynamicDocument):
''' class to hold the different possible actions of a pitch '''
name = Database().StringField(max_length=500)
vote_count = Database().IntField(default=0)
vote_numbers = Database().ListField()
vote_symbol = Database().StringField(max_length=10)
ticker = Database().StringField(max_length=50)
action = Database().StringField(max_length=50)
amount = Database().IntField()
action_id = Database().IntField()
created_at = Database().DateTimeField(default=datetime.now())
def test_add_user_blank_first_name(self, setup_db,
test_input_bad_first_name,
test_input_good_first_name,
test_input_last_name, test_input_email,
test_input_password, expected):
test_db = Database(setup_db)
user = UserController(test_db)
set_keyboard_input([
test_input_bad_first_name, test_input_good_first_name,
test_input_last_name, test_input_email, test_input_password,
test_input_password
])
user.addNewUser()
output = get_display_output()
assert output == [
"Enter new user information, all information is case-sensitive.",
"First Name: ",
"First name can not be blank. Please enter a first name.",
"First Name: ", "Last Name: ", "E-Mail Address: ", "Password: "******"Re-Enter Password: "******"\n New User was successfully added"
]
result = test_db.query_user_db(
"SELECT EXISTS(SELECT * FROM Employee WHERE FirstName is '%s' AND LastName is "
"'%s' AND Email is '%s' AND Password is '%s')" %
(test_input_good_first_name, test_input_last_name,
test_input_email, test_input_password))
assert result[0] == expected
def documets():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
result = {}
if request.method == "GET":
pk = str(crypto_file.generate_public_key()).split('\\n')
result = {
"document_type": {},
"public_key": ''.join(i for i in pk[1:-1])
}
for row in database.select_data(
"SELECT id, title FROM document_type;"):
result["document_type"][row[0]] = row[1]
elif request.method == "POST":
json = request.get_json(silent=True)
if not json:
return jsonify({"message": "JSON не найден"}), 400
fields = ["hash", "document_type_id", "photo"]
for field in fields:
if not json.get(field):
return jsonify({"message": f"Поле {field} не найдено"}), 400
hash_md5 = hashlib.md5()
hash_md5.update(str(json.get("photo")).encode())
if not hash_md5.hexdigest() == json.get("hash").lower():
return jsonify({"message": f"hash не совпадает"}), 406
query = "INSERT INTO {table}({fields}) VALUES ({values}, now())"
values = {
"table":
sql.Identifier("public", "documents"),
"fields":
sql.SQL(",").join(
sql.Identifier(i) for i in
["hash", "user_id", "document_type_id", "photo", "dt_upload"]),
"values":
sql.SQL(",").join(
sql.Literal(i) for i in [
json.get("hash"),
user.get_id(),
json.get("document_type_id"),
json.get("photo"),
])
}
result = database.insert_data(sql.SQL(query).format(**values))
database.close()
return jsonify(result)
def db(config, event):
db = Database(config)
for _ in range(1000):
e = Event(**event)
with Session(db._engine, future=True) as sess, sess.begin():
sess.add(e)
return db
def ingest_latest_obs(self):
with Database(DATABASE_PATH) as db:
file_content = self.api.get_latest_obs()
if file_content:
df = file_content_to_dataframe(file_content)
obs_list = []
timestamp = int(df.ta.index[0][1].timestamp())
if (latest_timestamp := db.get_latest_timestamp()
) and latest_timestamp == timestamp:
print(
f'timestep already in database: {datetime.fromtimestamp(timestamp).isoformat()}'
)
return
for row in df.itertuples():
station_id = int(row.Index[0])
station = Station(
id=station_id,
name=row.stationname,
latitude=row.lat,
longitude=row.lon,
height=row.height,
)
db.add_station(station)
obs = Observation(
timestamp=int(row.Index[1].timestamp()),
station_id=station_id,
)
for element_name, mapping in mappings.items():
setattr(obs, element_name,
getattr(row, mapping.knmi_alias, None))
obs_list.append(obs)
db.add_observations(obs_list)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-c",
"--clear_db",
action="store_true",
help="Clear database")
parser.add_argument("-d",
"--daemon",
action="store_true",
help="Run as daemon")
parser.add_argument("-g",
"--initialize_geolocation",
action="store_true",
help="(Re-)Initialize geolocation module")
parser.add_argument(
"-u",
"--initialize_unsafe",
action="store_true",
help="Initialize a new set of unsafe URLs, domains and IPs")
args = parser.parse_args()
if args.clear_db:
config = json.load(open("config.json"))
db = Database(config["database"]["user"],
config["database"]["password"],
config["database"]["host"], config["database"]["port"],
config["database"]["db"])
db.clear_db()
if args.initialize_unsafe:
initialize_unsafe_connections_list()
if args.initialize_geolocation:
GeoLocation.initialize()
if args.daemon:
Scheduler.run()
def auth_api():
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
number_phone = request.get_json(silent=True).get("number_phone")
password = request.get_json(silent=True).get("password")
user_data = database.login({"number_phone": number_phone})
if user_data:
if time() - user_data[4].timestamp() >= 300:
update_password(database, user_data[0], "")
return jsonify({'message': 'Время пароля истекло'}), 401, {
'ContentType': 'application/json'
}
if check_password_hash(user_data[1], password):
if user_data[3] == True:
user = User(id=user_data[0],
number_phone=number_phone,
role=user_data[2])
authorize[user.get_token()] = user
update_password(database, user_data[0], "")
return jsonify({
"UserToken": user.get_token(),
"role": user.get_role()
})
return jsonify({'message': 'Пользователь заблокирован'}), 401, {
'ContentType': 'application/json'
}
return jsonify({'message': 'Неправильный логин или пароль'}), 401, {
'ContentType': 'application/json'
}
def create_app(*config_cls) -> Flask:
# preprocess.preprocess_deepec()
# preprocess.preprocess_ecpred()
# preprocess.preprocess_ecami()
# preprocess.preprocess_detect_v2()
if len(config_cls) == 0:
config_cls = (ProductionLevelConfig, RemoteConfig)
config_cls = [
config() if isinstance(config, type) else config
for config in config_cls
]
log(
message="Flask application initialized with {}".format(", ".join(
[config.__class__.__name__ for config in config_cls])),
keyword="INFO",
)
flask_app = Flask(__name__)
for config in config_cls:
flask_app.config.from_object(config)
register_extensions(flask_app)
register_views(flask_app)
register_hooks(flask_app)
with flask_app.app_context():
c = flask_app.config
Database(c['DB_HOST'], c['DB_USER'], c['DB_PASSWORD'],
c['DB_DATABASE'])
return flask_app
def get_password():
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
result = {}
if not request.get_json(silent=True):
return jsonify({"message": "JSON не найден"}), 400
number_phone = request.get_json(silent=True).get("number_phone")
if not number_phone:
return jsonify({"error": "Телефон не найден"}), 404
isFind = database.select_data(
sql.SQL("SELECT id FROM users WHERE number_phone={number_phone}").
format(number_phone=sql.Literal(number_phone)))
if not isFind:
isFind = create_user(database, number_phone)
if isFind:
password = generate_password()
update_password(database, isFind[0],
generate_password_hash(password, method='sha256'))
send_password(password, number_phone)
update_connection_log(database, isFind[0], request.remote_addr)
database.close()
return "Ok"
def main():
try:
config = cp.ConfigParser()
config.read('./app/conf/main.ini')
# database section
user = config.get('database', 'user')
password = config.get('database', 'password')
database = config.get('database', 'database')
host = config.get('database', 'host')
# other section
wall = config.get('other', 'wall')
update = config.getfloat('other', 'update')
except:
logger.error('Config file error')
sys.exit()
logger.info('Cakes thief: trying to connect to PostgreSQL database')
logger.info('User: %s' % user)
logger.info('Password: %s' % password)
logger.info('Database: %s' % database)
logger.info('Host: %s' % host)
logger.info('Wall: %s' % wall)
logger.info('Update in seconds: %s' % update)
db = Database(user=user,
password=password,
database=database,
host=host)
parser = Parser(wall, update, db)
parser.start()
parser.idle()
def main_prize_action(self, params=None):
database = Database()
try:
response = database.get_next_lottery_main_prize()
self.send_request(response['response'])
except:
self.send_request('UNEXPECTED_ERROR')
del database
def won_list_action(self, params=None):
database = Database()
try:
response = database.get_won_list()
self.send_request(response['response'])
except:
self.send_request('UNEXPECTED_ERROR')
del database
def get_balance_action(self, params=None):
database = Database()
if self.userID:
response = database.get_balance(self.userID)
self.send_request(response['response'])
else:
self.send_request('NO_LOGIN')
del database
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.db = Database(test=True)
self.input_cases =\
(Stock("Apple", "AAPL", "united states",
"01/01/2018", "17/10/2020"),
Etf("WIG 20 ETF", "Beta ETF WIG20TR Portfelowy FIZ",
"poland", "01/01/2018", "17/10/2020", "Warsaw"))
def __init__(self):
self.username = None
self.password = None
self.session = None
self.language = None
self.vocab = []
self.wordHash = {}
self.flagHash = {}
self.db = Database()
def timeseries(self, station_id: int, history_hours: int) -> List[dict]:
with Database(DATABASE_PATH, read=True) as db:
start_timestamp = int((datetime.utcnow() -
timedelta(hours=history_hours)).timestamp())
obs = db.get_observations_for_station(station_id, start_timestamp)
obs_list = self._post_process_obs(obs)
return obs_list
def setUpClass(self):
from app import config
self.app = start_app(config.Test)
# connect to the test db
from mongoengine.connection import connect, disconnect, get_connection
disconnect()
from app.database import Database
self.db = Database(app=self.app)
def create_app(config_name):
app = FlaskAPI(__name__, instance_relative_config=True)
app.config.from_object(app_config[config_name])
app.config.from_pyfile('config.py')
message_factory = MessageFactory(app.config["SECRET"])
db = Database(MongoClient(app.config["DATABASE_URI"]))
@app.route('/messages/<string:user_id>/<string:message_cvs>',
methods=['GET', 'DELETE'])
def message(user_id, message_cvs):
message_ids = message_cvs.split(',')
if request.method == "GET":
messages = db.get_messages(user_id, message_ids)
if len(messages) > 0:
return jsonify(messages)
else:
abort(404)
else:
count = db.delete_messages(user_id, message_ids)
if count >= 1:
response = jsonify()
response.status_code = 204
return response
else:
abort(404)
@app.route('/messages/<string:user_id>', methods=['POST', 'GET'])
def messages(user_id):
if request.method == "POST":
user_input = str(request.data.get('message', ''))
message = message_factory.create(user_id, user_input)
response = jsonify(id=db.save_message(message))
response.status_code = 201
return response
else:
try:
start = parse_date_time(request.args.get('start'),
datetime.min)
stop = parse_date_time(request.args.get('stop'), datetime.max)
messages = db.get_messages_between(user_id, start, stop)
if len(messages) != 0:
return jsonify(messages)
else:
abort(404) # Not sure if I should return 404 or 204
except (ValueError, OverflowError):
abort(400)
@app.route('/messages/<user_id>/unread', methods=['GET'])
def unread(user_id):
return jsonify(db.get_unread_messages(user_id))
@app.route('/status', methods=['GET'])
def status():
return jsonify(db.status())
return app
def handle_disconnection():
# handles disconnection from the server
print("DISCONNECT")
db = Database()
msg = {"name": session[NAME_KEY], "message": " has left the chat"}
db.insert_message(session[NAME_KEY], " has left the chat")
result = db.get_messages_by_name(1, session[NAME_KEY])
result = trim_seconds_from_message(result)
socketio.emit("message response", result)
def handle_event(json, methods=["GET", "POST"]):
if len(json["name"]) >= 2:
db = Database()
db.insert_message(json["name"], json["message"])
result = db.get_messages_by_name(
1, json["name"]
) # getting the last message from the database( the one that was just inserted above)
result = trim_seconds_from_message(result)
socketio.emit("message response",
result) # sending it back to the clients
def test_login_success(self, setup_db, test_input_name,
test_input_password):
test_db = Database(setup_db)
set_keyboard_input([test_input_name, test_input_password])
result = login(test_db).login()
output = get_display_output()
assert output == [
"Please enter email: ", "Please enter password: "******"\nLogin Successful"
]
assert result == True
def last_won_action(self, params=None):
database = Database()
try:
if params and len(params) == 1:
response = database.get_last_lotto(int(params[0]))
self.send_request(response['response'])
else:
self.send_request('PARAMS_COUNT')
except:
self.send_request('UNEXPECTED_ERROR')
del database
def search_nearest(self, **kwargs):
mongodb = Database().get_connection()
point_util = PointUtil()
coordinate = point_util.convert_point(kwargs['coordinate'])
pdvs = Pdv.objects(address__near=coordinate,
address__max_distance=float(kwargs['max_distance']))
data = list()
for pdv in pdvs:
data.append(pdv.to_json())
return data
def my_coupons_action(self, params=None):
database = Database()
try:
userID = self.userID
if self.userID:
response = database.get_user_coupons_list_with_lottery(userID)
self.send_request(response['response'])
else:
self.send_request('NO_LOGIN')
except:
self.send_request('UNEXPECTED_ERROR')
del database
def __init__(self, *args, **kwargs):
self.window = MainWindow()
## Build
self.db = Database('tcc')
self.staff = self.build_staff()
self.login_layout = self.build_login_layout()
## Engine
self.window.add_page(self.login_layout)
def add_balance_action(self, params=None):
database = Database()
try:
if params and len(params) == 1:
userID = self.userID
if self.userID:
response = database.add_balance(userID, float(params[0]))
self.send_request(response['response'])
else:
self.send_request('NO_LOGIN')
except:
self.send_request('UNEXPECTED_ERROR')
del database
def setUp(self):
self.client = app.test_client(self)
# RUN 'set APP_SETTINGS=testing' to set testing environment (for database)
self.database_obj = Database(app)
# get Authorization token (used for all protected endpoints)
signup_response = self.client.post('/api/v1/auth/signup',
data=json.dumps(
TestData.user_data2),
content_type='application/json')
token_json_dict = json.loads(signup_response.data.decode())
self.access_token = token_json_dict['access_token']
def test_insert_user_db(self, setup_db, employee_id, first_name, last_name,
email, password):
db = Database(setup_db)
insert_statement = "INSERT INTO Employee (EmployeeID, FirstName, LastName, Email, Password) " + \
"VALUES (" + str(employee_id) + ",'" + first_name + "','" + last_name + "','" + email + \
"','" + password + "')"
query_statement = "SELECT EXISTS(SELECT * FROM Employee WHERE EmployeeID is " + str(employee_id) + \
" AND FirstName is '" + first_name + "' AND LastName is '" + last_name + \
"' AND Email is '" + email + "' AND Password is '" + password + "')"
insert_results = db.insert_user_db(insert_statement)
query_results = db.query_user_db(query_statement)
assert insert_results == True
assert query_results[0] == 1
