def courses(message):
user_id = message.from_user.id
is_active[user_id] = True
state[message.from_user.id] = 0
database.write_to_db('state', 0, message.from_user.id)
bot.send_message(user_id,
text.request_text,
reply_markup=keyboards.courses())
def cabinet(message):
ind = int(
sub.get(message.from_user.id,
database.get_sub(message.from_user.id)['sub']))
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
bot.send_message(message.from_user.id,
text.success,
reply_markup=keyboards.registered_menu(ind))
def main():
"""
Monitor a website and upload analytics to a database.
"""
message_value = consumer()
logger.info(message_value)
message_value = _byte_to_dict()
message_value["id"] = secrets.randbelow(15)
write_to_db(message_value)
return create_http_response(statuscode, body)
def sub_1(message):
user_id = message.from_user.id
if user_id not in is_registered or user_id not in sub:
is_registered[user_id] = database.is_registered(user_id)
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
sub[user_id] = database.get_sub(message.from_user.id)['sub']
sub[user_id] = 0
database.write_to_db('sub', 0, user_id)
bot.send_message(user_id,
text.sub_off,
reply_markup=keyboards.registered_menu(0))
def contact_for_order(message):
user_id = message.from_user.id
message_text = message.contact.phone_number
if len(message_text) == 12:
message_text = "+" + message_text
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
database.add_module_order_unregistered(stock.get(user_id,
[]), message_text,
message.from_user.first_name)
stock[user_id] = []
bot.send_message(user_id, text.send_text, reply_markup=keyboards.go_main())
def start_message(message):
user_id = message.from_user.id
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
registered = is_registered.get(user_id, database.is_registered(user_id))
if registered:
is_registered[user_id] = True
bot.send_message(user_id,
text.hello_2,
reply_markup=keyboards.main_2())
else:
is_registered[user_id] = False
bot.send_message(user_id,
text.hello_1,
reply_markup=keyboards.main_1())
def send(message):
user_id = message.from_user.id
registered = is_registered.get(user_id, database.is_registered(user_id))
print(registered)
if registered:
database.add_module_order(stock.get(user_id, []), user_id,
message.from_user.first_name)
stock[user_id] = []
bot.send_message(user_id,
text.send_text,
reply_markup=keyboards.go_main())
else:
database.write_to_db('state', 3, message.from_user.id)
state[message.from_user.id] = 3
bot.send_message(user_id,
text.send_number,
reply_markup=keyboards.contact())
def get_contact_text(message):
message_text = message.text
if not database.is_dublicate(message_text):
if database.is_number_exist(message_text, message.from_user.id):
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
ind = int(
sub.get(message.from_user.id,
database.get_sub(message.from_user.id)['sub']))
bot.send_message(message.from_user.id,
text.success,
reply_markup=keyboards.registered_menu(ind))
else:
bot.send_message(message.from_user.id,
text.failed,
reply_markup=keyboards.contact())
else:
bot.send_message(message.from_user.id, text.number_in_use)
def marks(message):
user_id = message.from_user.id
marks = database.get_marks(user_id)
if user_id not in is_registered or user_id not in sub:
is_registered[user_id] = database.is_registered(user_id)
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
sub[user_id] = database.get_sub(message.from_user.id)['sub']
if len(marks) != 0:
message_text = text.marks
name = ""
for mark in marks:
date = datetime.strftime(mark["event_date"], r"%d-%m-%Y")
if mark['u.name'] != name:
message_text += f'{mark["u.name"]}\n{date}: {mark["name"]} - <b>{mark["mark"]}</b>\n'
name = mark['u.name']
else:
message_text += f'{date}: {mark["name"]} - <b>{mark["mark"]}</b>\n'
bot.send_message(user_id, message_text, parse_mode="HTML")
else:
bot.send_message(user_id, text.no_marks)
def payment(message):
user_id = message.from_user.id
payments = database.get_payment(user_id)
if user_id not in is_registered or user_id not in sub:
is_registered[user_id] = database.is_registered(user_id)
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
sub[user_id] = database.get_sub(message.from_user.id)['sub']
if len(payments) != 0:
message_text = text.payment_text
name = ""
for pay in payments:
date = datetime.strftime(pay["created_at"], r"%d-%m-%Y")
if pay['u.name'] != name:
message_text += f"{pay['u.name']}\n{date}: {pay['name']} - {pay['amount']*(-1)}\n"
name = pay['u.name']
else:
message_text += f"{date}: {pay['name']} - {pay['amount']*(-1)}\n"
bot.send_message(user_id, message_text)
else:
bot.send_message(user_id, text.no_payment)
def balans(message):
user_id = message.from_user.id
if user_id not in is_registered or user_id not in sub:
is_registered[user_id] = database.is_registered(user_id)
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
sub[user_id] = database.get_sub(message.from_user.id)['sub']
balans = database.get_balans(user_id)
if len(balans) > 1:
message_text = ""
name = ""
for bal in balans:
if bal['name'] != name:
message_text += (bal['name'] + "\n" +
text.show_balans.format(bal['money']))
name = bal['name']
else:
message_text += text.show_balans.format(bal['money'])
bot.send_message(user_id, message_text)
else:
bot.send_message(user_id, text.balans_kol.format(balans[0]['money']))
def gaps(message):
user_id = message.from_user.id
gapps = database.get_gaps(user_id)
if user_id not in is_registered or user_id not in sub:
is_registered[user_id] = database.is_registered(user_id)
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
sub[user_id] = database.get_sub(message.from_user.id)['sub']
if len(gapps) < 1:
bot.send_message(user_id, text.no_gaps)
else:
message_text = text.gaps.format(len(gapps))
name = ""
for gap in gapps:
date = datetime.strftime(gap["event_date"], r"%d-%m-%Y")
if gap['u.name'] != name:
message_text += f'{gap["u.name"]}\n{date}: {gap["name"]}\n'
name = gap['u.name']
else:
message_text += f'{date}: {gap["name"]}\n'
bot.send_message(user_id, message_text)
def debt(message):
user_id = message.from_user.id
debts = database.get_debt(user_id)
if user_id not in is_registered or user_id not in sub:
is_registered[user_id] = database.is_registered(user_id)
database.write_to_db('state', 0, message.from_user.id)
state[message.from_user.id] = 0
sub[user_id] = database.get_sub(message.from_user.id)['sub']
message_text = ""
if len(debts) == 0:
bot.send_message(user_id, text.no_debt, parse_mode="HTML")
else:
name = ""
for d in debts:
date = datetime.strftime(d["created_at"], r"%d-%m-%Y")
if d['u.name'] != name:
message_text += (
d['u.name'] + "\n" +
text.debt_text.format(d["amount"], date, d['name']))
name = d['u.name']
else:
message_text += text.debt_text.format(d["amount"], date,
d['name'])
bot.send_message(user_id, message_text, parse_mode="HTML")
def registry(message):
state[message.from_user.id] = 1
database.write_to_db('state', 1, message.from_user.id)
bot.send_message(message.from_user.id,
text.number_request,
reply_markup=keyboards.contact())
def create_user():
print('creating user')
request_data = request.get_json()
errors_array = []
#Error checking: See if there is a missing field in the json data
if not ('username' in request_data and 'firstname' in request_data
and 'lastname' in request_data and 'password1' in request_data
and 'password2' in request_data and 'email' in request_data):
errors_array.append(
{"message": "You did not provide the necessary fields"})
return jsonify(errors=errors_array), 422
#Check that all fields contained something
user = request_data['username']
first = request_data['firstname']
last = request_data['lastname']
pass1 = request_data['password1']
pass2 = request_data['password2']
email = request_data['email']
rating = request_data['rating']
city = request_data['city']
state = request_data['state']
if user == '' or first == '' or last == '' or pass1 == '' or pass2 == '' or email == '' or rating == '' or city == '' or state == '':
errors_array.append(
{'message': 'You did not provide the necessary fields'})
return jsonify(errors=errors_array), 422
#Check length requirements
if len(user) > 20:
errors_array.append(
{'message': 'Username must be no longer than 20 characters'})
if len(first) > 20:
errors_array.append(
{'message': 'First name must be no longer than 20 characters'})
if len(last) > 20:
errors_array.append(
{'message': 'Last name must be no longer than 20 characters'})
if len(pass1) > 256 or len(pass2) > 256:
errors_array.append(
{'message': 'Password must be no longer than 256 characters'})
if len(pass1) < 8 or len(pass2) < 8:
errors_array.append(
{'message': 'Password must be longer than 8 characters'})
if len(email) > 40:
errors_array.append(
{'message': 'Email must be no longer than 40 characters'})
if len(rating) > 3:
errors_array.append(
{'message': 'Rating must be no longer than 3 characters'})
if len(city) > 20:
errors_array.append(
{'message': 'City must be no longer than 20 characters'})
if len(state) > 20:
errors_array.append(
{'message': 'State must be no longer than 20 characters'})
#Check if userna is taken
get_user = '******' % (user)
user_taken = database.read_from_db(get_user)
if user_taken:
errors_array.append({
'message':
'This username is taken. Please try a different username.'
})
#Check for punctuation in usernames and passwords. Usernames can contain letters, numbers, and underscores
acceptable = list(string.ascii_letters)
acceptable.extend(list(string.digits))
acceptable.extend(['_'])
for letter in user:
if not letter in acceptable:
errors_array.append({
'message':
'Invalid username. Usernames can only contain letters, numbers, and underscores.'
})
break
for letter in pass1:
if not letter in acceptable:
errors_array.append({
'message':
'Invalid password. Passwords can only contain letters, numbers, and underscores.'
})
break
#Check for at least one letter and number in acceptable
#Check for one letter and number in a password
count_letter = 0
count_digit = 0
for char in pass1:
if char.isdigit():
count_digit += 1
if char.isalpha():
count_letter += 1
if count_digit == 0 or count_letter == 0:
errors_array.append({
"message":
"Passwords must contain at least one letter and one number"
})
#Check that the passwords are equal
if pass1 != pass2:
errors_array.append({'message': 'Passwords must match'})
#Check that email is valid
if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
errors_array.append({"message": "Email address must be valid"})
if len(errors_array) > 0:
return jsonify(errors=errors_array), 422
#At this point, all inputs are correctly formatted.
#Hash the password and insert these values into the database
algorithm = "sha512"
salt = uuid.uuid4().hex
m = hashlib.new(algorithm)
m.update(str(salt + pass1).encode('utf-8'))
password_hash = m.hexdigest()
real_pass = "******".join([algorithm, salt, password_hash])
#Insert values into database
create_new_user = '******' % (
user, first, last, real_pass, email, rating, city, state)
print(create_new_user)
database.write_to_db(create_new_user)
#Start new session for the user
session['username'] = user
#Returns a json object with the same fields that it came with
return jsonify(username=user,
firstname=first,
lastname=last,
password1=pass1,
password2=pass2,
email=email,
rating=rating,
city=city,
state=state), 201
def full_analysis(gas, ens, op1, op2, directory, beams, gantry_name, acq_date,
acq_time, comment, outputdir):
"""Analsysis of full data set"""
acq_datetime = acq_date + " " + acq_time
result_dir = outputdir
print("Analyzing BEV spot shifts...")
results_shifts = {}
results_shifts = xan.analyse_shifts(gas, ens, directory, beams)
############## IMAGE TO BEV CONVERSION ########################
# The analyse_shifts method works in image coordinate system.
# IMG-Y = -BEV-Y hence if we want results in BEV coords:
for key in results_shifts:
results_shifts[key][1] *= -1
##############################################################
print("Saving and printing shift results...")
with open(join(result_dir, "results_shifts.txt"), "w") as json_file:
json.dump(results_shifts, json_file)
# 2D plot of shifts (x,y) grouped by GA
xplot.plot_shifts_by_gantry(gas,
ens,
results_shifts,
imgname=join(result_dir,
"shifts_by_gantry.png"))
# 2D plot of shifts (x,y) grouped by ENERGY
xplot.plot_shifts_by_energy(gas,
ens,
results_shifts,
imgname=join(result_dir,
"shifts_by_energy.png"))
# x & y shifts plotted separately vs GA (for each E)
xplot.plot_xyshifts_vs_gantry(gas,
ens,
results_shifts,
imgname=join(result_dir,
"xy_shifts_vs_gantry.png"))
# x & y shifts plotted separately vs E (for each GA)
xplot.plot_xyshifts_vs_energy(gas,
ens,
results_shifts,
imgname=join(result_dir,
"xy_shifts_vs_energy.png"))
# Histogram of shifts
xplot.shifts_histogram(results_shifts,
imgname=join(result_dir, "shifts_histo.png"))
# Polar plot of shifts
xplot.shifts_polar(gas,
ens,
results_shifts,
imgname=join(result_dir, "shifts_polar.png"))
"""
## 3D SHIFTS VECTORS IN LOGOS COORDINATES - not using this
print("Calculating 3D shifts (presence of ball bearing will reduce accuracy)...")
results_3d_shifts = xan.shift_vector_logos_coords(directory, beams, GANTRY, ENERGY, TARGET)
with open(join(result_dir,"results_3d_shifts.txt"),"w") as json_file:
json.dump(results_3d_shifts, json_file)
xplot.shifts_3d_histogram(results_3d_shifts, imgname=join(result_dir,"shifts_3d_histo.png"))
"""
results_spot_diameters = {}
results_sigmas = {}
print("Reading spot diameters...")
results_spot_diameters = xan.read_spot_diameters(gas, ens, directory,
beams)
with open(join(result_dir, "results_spot_diameters.txt"),
"w") as json_file:
json.dump(results_spot_diameters, json_file)
## Spot diameter plots
xplot.plot_spot_diameters_by_gantry(gas,
ens,
results_spot_diameters,
imgname=join(result_dir,
"diameter_by_gantry.png"))
xplot.plot_spot_diameters_by_energy(gas,
ens,
results_spot_diameters,
imgname=join(result_dir,
"diameter_by_energy.png"))
print("Analzying spot sigmas...")
results_sigmas = xan.analyse_spot_profiles(gas, ens, directory, beams)
with open(join(result_dir, "results_spot_sigmas.txt"), "w") as json_file:
json.dump(results_sigmas, json_file)
## Spot sigma (method can do either "image" or "spot" coordinate systems
xplot.plot_spot_sigmas(gas,
ens,
results_sigmas,
imgname=join(result_dir, "sigmas_xy.png"))
print("Reading arc and radial entry spot widths...")
results_arc_radial = xan.read_arc_radial_widths(gas, ens, directory, beams)
with open(join(result_dir, "results_arc_radial.txt"), "w") as json_file:
json.dump(results_arc_radial, json_file)
## Arc and radial widths from entry spot
xplot.plot_spot_sigmas(gas,
ens,
results_arc_radial,
imgname=join(result_dir, "arc_radial.png"),
arc_radial=True)
print("Generating summary PDF report...")
xreport.summary_reportlab(gas,
ens,
op1,
op2,
results_shifts,
acq_datetime,
gantry_name,
images=[
join(result_dir, "shifts_by_gantry.png"),
join(result_dir, "shifts_by_energy.png"),
join(result_dir, "shifts_histo.png"),
join(result_dir, "shifts_polar.png"),
join(result_dir, "diameter_by_energy.png")
],
output=join(result_dir, "Summary report.pdf"))
print("Generating data for database...")
# Store x and y shifts plus Logos-diameter for each spot
db_results = join(result_dir, "db_results.csv")
# need newline to avoid blank lines
with open(db_results, 'w', encoding='UTF8', newline='') as f:
writer = csv.writer(f)
header = [
"ADate", "Operator 1", "Operator 2", "MachineName", "GA", "Energy",
"x-offset", "y-offset", "Diameter"
]
writer.writerow(header)
for key in results_shifts:
ga = key.split("GA")[1].split("E")[0]
e = key.split("E")[1]
xoff, yoff = results_shifts[key]
diam = results_spot_diameters[key]
data = [
acq_datetime, op1, op2, gantry_name, ga, e, xoff, yoff, diam
]
writer.writerow(data)
print("Attempting to write to database...")
df = pd.read_csv(db_results)
db.write_to_db(df, comment)