async def 공격(self, ctx, arg='NONE'):
""" '!공격 @멘션'처럼 사용하여 다른 유저를 공격하는 명령어 예시예요! """
# 멘션을 ID로 변환
defender_id = arg.replace('<@', '').replace('>', '').replace('!', '')
if not defender_id.isdigit():
return await ctx.send(f"공격 대상을 알 수 없습니다 : `{defender_id}`")
defender = User(int(defender_id))
attacker = User(ctx.author)
# 유저의 체력이 이미 없는 경우
if attacker.hp == 0:
return await ctx.send("쓰러진 상태에서는 공격할 수 없어...")
# 이미 공격 대상의 체력이 0이면
if defender.hp == 0:
return await ctx.send("이미 쓰러진 사람을 공격하는 건 매너 위반이야...")
logs = attacker.attack_to(defender)
logdata = logs[0]
window = await ctx.send(f"```diff\n{logdata}```",
reference=ctx.message)
for i in logs[1:]:
logdata += '\n' + i
await asyncio.sleep(1.5)
await window.edit(content=f"```diff\n{logdata}```")
def register(self):
"""Get, validate and convert user input data"""
first_name = self.first_name_entry.get()
insertion = self.insertion_entry.get()
last_name = self.last_name_entry.get()
zip_code = self.zip_entry.get()
streetnumber = self.streetnumber_entry.get()
email = self.email_entry.get()
# Validate input
if self.is_valid(first_name, last_name, zip_code, streetnumber, email):
d = self.convert(first_name, insertion, last_name, zip_code,
streetnumber, email)
check = User(self.ov).register(d['first_name'], d['insertion'],
d['last_name'], d['zip_code'],
d['streetnumber'], d['email'])
if check:
user = User(self.ov)
self.frame.pack_forget()
MainScreen(self.master, user)
return True
else:
return False
def test_signup_user_returns_correct_id(self):
self.app.signup_user(self.user)
self.assertEqual(len(self.app.users), 1)
self.user = User('*****@*****.**', 'henry123', 'Henry', 'Kato')
self.app.signup_user(self.user)
self.assertEqual(len(self.app.users), 2)
self.user = User('*****@*****.**', 'henry0009', 'Henry', 'Mutunji')
self.app.signup_user(self.user)
self.assertEqual(len(self.app.users), 3)
def searchBooksBy(section, filt):
result = auth.checkData()
if result['auth']:
words = json.loads(request.data)['words']
if section == 'explore':
result['books'] = sql.searchBooks(filt, words)
elif section == 'readlater':
user = User()
result['books'] = sql.searchReadLater(words, user.idUser)
elif section == 'readings':
user = User()
result['books'] = sql.searchPendings(words, user.idUser)
return jsonify({'result': result})
def load_user(email):
"""Returns an object of class User based on provided unique identifier
if user in the database, otherwise None
"""
if user_exists(email):
return User(email)
return None
def user_handle(email_address):
body = {"email": email_address}
user_object = User(body)
result = user_object.get_user()
if result['statusCode'] == 200:
return result['response'], 200
return result['response'], 400
def register():
"""
"""
if request.method == "POST":
# read the posted values from the UI
email = request.form.get('inputEmail', None)
password = request.form.get('inputPassword', None)
# validate received values
if email and password and not user_exists(email):
with db.ConnectionInstance() as queries:
key = random_key(10) + email
# TODO delete or merge previously created user if exists
#adds new user to the database
added = queries.add_user(datetime.utcnow(), email,
hash_password(password), key)
if (added):
user = User(email)
#adds default calendar to that user
queries.add_calendar(datetime.utcnow(), user.user_id)
#send verfication email
send_verification(email, key)
return render_template("verify_send.html", email=email)
# reload if something not right
# TODO maybe some error messages
return redirect('/')
def signup():
"""Renders signup page
Returns:
signup page template for user
"""
if 'logged_in' in session:
return redirect(url_for('index'))
if request.method == 'GET':
return render_template('signup.html', title='Sign Up')
else:
# getting form variables
firstname = request.form['firstname']
lastname = request.form['lastname']
email = request.form['email']
password = request.form['password']
# creating user object
global current_user
current_user = User(email, password, firstname, lastname)
recipe_app.signup_user(current_user)
flash(
'You have successfully created your account, \
please login into your account', 'success')
return redirect(url_for('index'))
def index():
"""Renders index or home page
Returns:
an index page template
"""
if request.method == 'POST':
# getting form variables
email = request.form['email']
password = request.form['password']
# signing in user
global current_user
current_user = User(email, password)
# creating session
session['id'] = recipe_app.signin_user(current_user)
if session['id']:
session['logged_in'] = True
return redirect(url_for('dashboard'))
else:
error = 'Wrong email or password combination'
return render_template('index.html', title='Home', error=error)
return render_template('index.html', title='Home')
def create_event(self, users):
self.name_event = input("Nome do evento: ")
self.title = input("Digite uma sigla: ")
self.description = input("De uma breve descricao do evento: ")
self.local = input("Informe o local: ")
self.start_date = input("Data de inicio: ")
self.end_date = input("Data do fim do evento: ")
self.cpf_admin_event = input(
"Informe o CPF do adiministrador do evento: ")
from classes.user import verify_event_adm_user_cpf
from classes.user import User
while not verify_event_adm_user_cpf(users, self.cpf_admin_event):
print(
"Não existe administrador de evento com esse CPF cadastrado!")
print("Deseja cadastra-lo? ")
print("SIM//NÂO")
resposta = input()
if resposta[0].upper() == "S":
new_admim_event = User()
new_admim_event.create_account(users)
users.append(new_admim_event)
else:
break
self.cpf_admin_event = input(
"Informe o CPF do adiministrador do evento: ")
self.value_pro = input(
"Informe o valor para participantes profissional: ")
self.value_est = input("Informe o valor para estudantes: ")
self.participants = []
def loginEvent(self):
try:
# create user object and validate
user = User()
user.setUsername(self.usernameEntry.get())
user.setPassword(self.passwordEntry.get())
if user.validate():
self.parent.destroy()
root = tk.Tk()
app = MainPage(root, user)
app.focus_force()
else:
messagebox.showerror(
"Login Failed!!!",
"Somthing is wrong, could not login. Please check your username and password and try again."
)
self.secondLabel["text"] = "Incorrect username or password"
self.secondLabel["fg"] = "red"
except:
messagebox.showwarning(
"Login Failed!!!",
"Username and Password field can not be emplty, If you do not have account then press 'Signup' button to register."
)
self.secondLabel["text"] = "Username or password cannot be empty"
self.secondLabel["fg"] = "red"
def initialize_users():
# Need to create a datastructure that stores the user
users = []
transactions = []
for i in range(utils.number_of_users):
coinsList = []
newUser = User(i)
for j in range(10):
cID = str(i * 10 + j)
signature = sign_message(scrooge_private, str(cID))
encoded = base64.b64encode(signature)
no_bytes = encoded.decode('utf-8')
coin_dict = {}
coin_dict[cID] = no_bytes
newUser.add_coin(coin_dict)
transaction = {}
transaction['previous_transaction'] = None
transaction['sender'] = 'scrooge'
transaction['receiver'] = newUser.user_id
transaction['coin_id'] = json.dumps(coin_dict)
transactions.append(transaction)
utils.printLog(
"User " + str(i) + "\n" +
str(newUser.private_key.public_key().public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo)))
utils.printLog("10 coins")
users.append(newUser)
return users, transactions
def sign_in():
"""
Signs in user to their account
"""
if request.method == 'POST':
# Pick form values
email = request.form['email']
password = request.form['password']
user = User(email, password)
# start session
session['id'] = bucketApp.sign_in(user)
if session['id']:
global current_user
user = [
user for user in bucketApp.all_users
if user.id == session['id']
]
current_user = user[0]
return redirect(url_for('buckets'))
return render_template('signIn.html',
error='Invalid username or password')
else:
return render_template('signIn.html')
def register_submit():
username = request.form.get("username")
firstname = request.form.get("firstname")
lastname = request.form.get("lastname")
password = request.form.get("password")
password_confirm = request.form.get("passwordConfirm")
if ((not len(username)) or (not len(firstname)) or (not len(lastname))
or (not len(password)) or (not len(password_confirm))):
return error_found("A field is empty")
valid_username = unique_user(db, username)
if valid_username is False:
return error_found("Username already exists")
valid_password = password_compare(password, password_confirm)
if valid_password is False:
return error_found("Passwords are not identical")
user = User(username, firstname, lastname)
create_user(db, user, password)
return render_template("submit.html",
username=username,
firstname=firstname,
lastname=lastname)
async def exec(self, ctx, *args):
if ctx.author.id not in Config.admin:
return await ctx.send(
'권한이 부족해!'
'\n`❗ 봇 관리자라면 config.py의 admin 리스트에 자신의 디스코드 id가 있는지 확인해 봐!`')
text = ' '.join(args)
me = User(ctx.author)
logger.info(f'{me.name}이(가) exec 명령어 사용 : {text}')
try:
exec(text)
except Exception as e:
embed = discord.Embed(color=0x980000,
timestamp=datetime.datetime.today())
embed.add_field(name="🐣 **Cracked!**",
value=f"```css\n[입구] {text}\n[오류] {e}```",
inline=False)
logger.err(e)
else:
embed = discord.Embed(color=0x00a495,
timestamp=datetime.datetime.today())
embed.add_field(name="🥚 **Exec**",
value=f"```css\n[입구] {text}```",
inline=False)
embed.set_footer(text=f"{ctx.author.name} • exec",
icon_url=str(
ctx.author.avatar_url_as(static_format='png',
size=128)))
await ctx.send(embed=embed, reference=ctx.message)
def updateAlines(idbook, alines):
result = auth.checkData()
if result['auth']:
user = User()
result['update'] = sql.updateAlines(idbook, user.idUser, alines)
return jsonify({'result': result})
def next_clock_tick(self, users_clock_ticks):
for user in range(users_clock_ticks):
self.customer_management.allocate_user(User(self.ttask))
self.customer_management.remove_timeout_users()
self.customer_management.optimize_servers()
self.customer_management.save_state()
self.customer_management.update_ttime()
def get_users(self):
users = []
for user in self.get_data(self.USER_TABLE):
user = User(user[0], user[1])
users.append(user)
return users
def __set_user(self, name, login, pwd):
"""
Metoda przypisująca dane logowania do pola user.
:param name: podpis
:param login: login
:param pwd: hasło
"""
self.user = User(login, pwd, name)
def __init__(self, port, username):
super().__init__()
self._s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.username = username
ip = socket.gethostbyname(socket.gethostname())
while True:
try:
self._s.bind((ip, port))
break
except:
port += 1
self._users = {}
self._host_user = User(self._s, ip, port, self.username)
self._system_user = User(self._s, ip, port, "系统提示")
self._lock = threading.Lock()
th = threading.Thread(target=self.new_conn_handler)
th.start()
def get_or_add_user(self, user_name):
log.debug(f"Fetching user: {user_name}")
user = self.session.query(User).filter_by(name=user_name).first()
if user is None:
log.debug(f"Creating user: {user_name}")
user = User(user_name)
self.session.add(user)
return user
def simulate_scan(self):
"""Simulate OV card scan by entering the serial key"""
user = User(self.scan_simulation.get())
if user.is_registered():
self.frame.pack_forget()
InfoScreen(self.master, user)
else:
self.frame.pack_forget()
RegisterScreen(self.master, user.get_ov())
def login():
email_id = request.form['email']
password = request.form['password']
logged_in = User().login(email_id, password)
if logged_in[0] is True:
session['name'] = logged_in[1]['name']
session['email_id'] = logged_in[1]['email_id']
return redirect(url_for('mail'))
else:
session['error'] = logged_in[1]
return redirect(url_for('index'))
def reset_password():
"""
function to reset a user password
"""
if not request.json or not 'username' in request.json:
abort(400)
username = request.json.get('username')
new_password = request.json.get(new_password)
user = User(username, email, password)
if user:
return jsonify({'message': 'Successfully changed password'})
def updateUser():
result = auth.checkData()
if result['auth']:
section = json.loads(request.data)['section']
data = json.loads(request.data)['data']
user = User()
print(section, data)
result['update'] = sql.updateUser(data, section, user.idUser)
return jsonify({'result': result})
def eReader(idbook, lang):
result = auth.checkData()
if result['auth']:
user = User()
result['alines'] = sql.getAlines(idbook, user.idUser)[0]['alines']
bfile = sql.getBfile(idbook)[0]['bfile']
bookcontent = BookContent(bfile, lang)
result['content'] = bookcontent.content
return jsonify({'result': result})
def create_account(username=None, email=None, password=None):
"""
function to register a user
"""
username = request.json['username']
email = request.json['email']
password = request.json['password']
confirm_password = request.json['confirm']
if password == confirm_password:
user = User(username, email, password)
users[user.email] = user
return jsonify({'message': 'You are successfully registered'})
def scan(self, static_ov=None):
"""Scan OV card with RFID-RC522 chip"""
global ov_read
if static_ov:
ov = static_ov
user = User(ov)
ov_read = False
if user.is_registered():
self.frame.pack_forget()
InfoScreen(self.master, user)
else:
self.frame.pack_forget()
RegisterScreen(self.master, user.get_ov())
else:
reader = MFRC522()
# Hook the SIGINT, Scan for cards
signal.signal(signal.SIGINT, self.end_read)
reader.MFRC522_Request(reader.PICC_REQIDL)
# Get the UID of the card
(status, uid) = reader.MFRC522_Anticoll()
# If we have the UID, continue
if status == reader.MI_OK:
ov = '{}:{}:{}:{}'.format(uid[0], uid[1], uid[2], uid[3])
user = User(ov)
ov_read = False
if user.is_registered():
self.frame.pack_forget()
InfoScreen(self.master, user)
else:
self.frame.pack_forget()
RegisterScreen(self.master, user.get_ov())
else:
self.master.after(200, self.scan)
def add_user(self):
"""Search new users via central server."""
user_id = self.search_idLE.text()
if not utils.is_valid_id(user_id):
QMessageBox.information(None, 'warning', 'Invalid ID!',
QMessageBox.Ok)
return
if user_id == self.me_user.user_id:
QMessageBox.information(None, 'warning',
'Why searching for yourself?',
QMessageBox.Ok)
return
if self.get_user_via_id(user_id) is not None:
QMessageBox.information(None, 'info',
'User is already your friend!',
QMessageBox.Ok)
return
# check whether online
result = self.central_server_connector.search_user(user_id)
if result == 'n':
QMessageBox.information(None, 'info', 'User not online!',
QMessageBox.Ok)
return
# update user
if self.use_my_central_server:
new_user = User(user_id=user_id,
name=None,
ip=result[0],
port=result[1],
icon=utils.get_icon())
else:
new_user = User(user_id=user_id,
name=None,
ip=result,
port=config.GENERAL_PORT,
icon=utils.get_icon())
self.update_user(new_user, sock=None)
self.search_idLE.setText('')
def login():
print("Enter username : "******"Enter password : "******"Welcome - Access Granted")
while True:
menu()
else:
print('Invalid Creditails...')
