def auction_bid(auction, user):
'''
Performs a single bid on the given auction on behalf of the specified user.
'''
# Perform Bid:
UserController.use_bids(user, 1)
AuctionController.bids(auction, user)
def decorated(*args, **kwargs):
token = request.headers.get('Authorization', None)
if not token:
raise ValidationError(message='error',
status_code=401,
payload={'message': 'No auth token'})
try:
data = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])
controller = UserController()
user = controller.find_one(email=data.get('email'))
if not user:
raise ValidationError(message='error',
status_code=401,
payload={'message': 'Invalid token'})
request.user = user
except Exception as error:
raise ValidationError(
message=str(error),
status_code=401,
payload={
'message': 'AN error occurred when checking credential'
})
return f(*args, **kwargs)
def users(query=None,
tag=None,
flags=None,
page=1,
next_page_url=None,
prev_page_url=None,
scroll=False,
selected=None):
current_user = UserController().current_user
template = TEMPLATE_USERS
users, relationship_types = UserController().get_users(query=query,
tag=tag,
page=page)
chips = {
'tags':
_parse_chip([{
'chip_name': k,
'selected': k in tag if tag else False
} for k in relationship_types],
key='t',
mode=Tag.EXCLUSIVE,
display_name='Type')
}
vargs = {'users': users, 'selected': selected, 'chips': chips}
if request.is_xhr:
return render_template(template, vargs=vargs, **vargs)
return render_template(TEMPLATE_MAIN,
template=template,
vargs=vargs,
**vargs)
def decorated(*args, **kwargs):
token = request.headers.get("Authorization", None)
if not token:
raise ValidationError(
message="error",
status_code=401,
payload={"message": "No auth token"},
)
try:
data = jwt.decode(token,
current_app.config["SECRET_KEY"],
algorithms=["HS256"])
controller = UserController()
user = controller.find_one(email=data.get("email"))
if not user:
raise ValidationError(
message="error",
status_code=401,
payload={"message": "Invalid token"},
)
request.user = user
except Exception as error:
raise ValidationError(
message=str(error),
status_code=401,
payload={
"message": "AN error occurred when checking credential"
},
)
return f(*args, **kwargs)
def handle(self, message: Message):
user_id = message.chat.id
UserController.set_state(message.chat.id,
UserStateMachine.meeting_date)
self.bot.send_message(
user_id, "Укажите дату для встречи.\n\n"
"Например, 10:00 22.05.2021")
def main():
db_connection = sqlite3.connect("blog_db.sqlite3")
sample_text = """Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras vehicula malesuada turpis, id tempus ligula eleifend vel. Vivamus ante ligula, tincidunt at egestas bibendum, fringilla non lorem. Fusce venenatis urna quis nibh ullamcorper sed consequat arcu blandit. In hac habitasse platea dictumst. Nullam nibh leo, eleifend eget cursus eget, sagittis vel mi. Sed consectetur massa et nulla iaculis pretium. Nullam fringilla euismod quam, ac aliquet erat pharetra non. Fusce commodo sagittis nisi interdum molestie. Fusce odio tortor, dapibus non dictum vitae, bibendum nec nulla."""
post_title = "Test Post"
post_controller = PostController(db_connection)
user_controller = UserController(db_connection)
post_author = user_controller.get_user("Test2")
test_post = Post(post_title, str(datetime.now()), post_author, post_text=sample_text)
saved_post = post_controller.add_post(test_post)
print "Saved Post ID: %d" % saved_post.get_id()
def handle(self, message: Message):
bio = message.text
user_id = message.chat.id
UserController.fill_bio(user_id, bio)
UserController.set_state(user_id, UserStateMachine.main_menu)
self.bot.send_message(user_id, "Вы успешно зарегистрированы")
self.bot.send_message(user_id,
"Главное меню:",
reply_markup=MainKeyboard.build())
def post(self):
request_data = api.payload
api.schema_model('User', {**user_login_schema}).validate(request_data)
controller = UserController()
user = controller.find_one(email=request_data.get('email'))
if user and check_password_hash(user.password,
request_data['password']):
token = generate_token(user)
return {'token': token, **user._asdict()}, 200
raise ValidationError(message='error',
status_code=401,
payload={'message': 'Invalid credentials'})
def close_auction(auction):
auction.auction_end = datetime.datetime.now()
auction.active = False
auction.put()
for autobidder in auction.autobidders:
owner = User.get_by_id(autobidder.user_id)
UserController.add_bids(owner, autobidder.remaining_bids)
owner.put()
autobidder.remaining_bids = 0
autobidder.put()
db.session.delete(autobidder)
db.session.commit()
def post(self):
user = api.payload
api.schema_model('User', {**user_schema}).validate(user)
user['password'] = generate_password_hash(user['password'],
method='sha256')
controller = UserController()
if not controller.find_one(email=user.get('email')):
user = controller.insert(user)
return user, 201
raise ValidationError(
message='error',
status_code=400,
payload={'message': 'User with email already exists'})
def post(self):
request_data = api.payload
api.schema_model("User", {**user_login_schema}).validate(request_data)
controller = UserController()
user = controller.find_one(email=request_data.get("email"))
if user and check_password_hash(user.password,
request_data["password"]):
token = generate_token(user)
return {"token": token, **user._asdict()}, 200
raise ValidationError(
message="error",
status_code=401,
payload={"message": "Invalid credentials"},
)
def post(self):
user = api.payload
api.schema_model("User", {**user_schema}).validate(user)
user["password"] = generate_password_hash(user["password"],
method="sha256")
controller = UserController()
if not controller.find_one(email=user.get("email")):
user = controller.insert(user)
return user, 201
raise ValidationError(
message="error",
status_code=400,
payload={"message": "User with email already exists"},
)
def update_ticket(ticket_id):
"""Update a specific ticket."""
ticket_data = request.get_json()
user_by_id = None
response = None
# get ticket by id
ticket_by_id = TicketController.get_ticket_by_id(ticket_id)
# check if there is assignee key provided in request
if "ticket_assignee" in ticket_data:
user_by_id = UserController.get_users_by_id(
ticket_data["ticket_assignee"])
if user_by_id is None:
return (error_response(404, "Resource Not Found")
) # return not found response if wrong user provided
# check if ticket was found and update accordingly
if ticket_by_id:
TicketController.update_ticket(ticket_by_id, ticket_data, user_by_id)
response = success_response_body(ticket_data)
else:
# return no user error
response = error_response(404, "Resource Not Found")
return response
def handle(self, message: Message):
user_id = message.chat.id
info = UserController.get_info(user_id)
self.bot.send_message(user_id,
info,
reply_markup=MainKeyboard.build())
def update_event(self, event_id, interest_key):
user_id = UserController().current_user_id
if user_id:
user_event = UserEvent.query.filter(
and_(UserEvent.user_id == user_id,
UserEvent.event_id == event_id)).first()
if user_event:
if interest_key == UserEvent.DONE:
if user_event.interest_key == interest_key:
user_event.interest = user_event.interest - 2
else:
user_event.interest = user_event.interest + 2
elif user_event.interest_key == interest_key:
user_event.interest = None
else:
user_event.interest = UserEvent.interest_level(
interest_key)
db_session.merge(user_event)
else:
user_event = UserEvent(
user_id=user_id,
event_id=event_id,
interest=UserEvent.interest_level(interest_key))
db_session.add(user_event)
db_session.commit()
return self.get_event(event_id)
return None
def register():
request_data = request.get_data()
try:
user_data = json.loads(request_data)
user_fname = user_data['first_name']
user_lname = user_data['last_name']
user_name = user_data['username']
user_email = user_data['email']
user_pass = user_data['password']
if len(user_name) < 3 or len(user_name) > 50:
raise error.LenUserError
if len(user_email) < 3 or len(user_email) > 255:
raise error.LenEmailError
if len(user_pass) < 5 or len(user_pass) > 10 or ' ' in user_pass:
raise error.LenPassError
exist_user_email = User.query.filter_by(email=user_email).first()
if exist_user_email:
raise error.ExistError2
except error.LenUserError:
return json.dumps({'Message': 'Invalid name'}), 400
except error.LenEmailError:
return json.dumps({'Message': 'Invalid email'}), 400
except error.LenPassError:
return json.dumps({'Message': 'Invalid password'}), 400
except error.ExistError2:
return json.dumps({'Message': 'Email existed'}), 400
user_pass = User.set_password(user_pass)
user = UserController.create(user_fname, user_lname, user_name, user_email,
user_pass)
def auth_callback():
if 'state' not in session:
return redirect('/')
state = session['state']
flow = get_oauth2_config(state=state)
flow.redirect_uri = get_oauth2_callback()
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
credentials = flow.credentials
session['credentials'] = {
'token': credentials.token,
'refresh_token': credentials.refresh_token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes
}
if 'state' in session:
del session['state']
UserController()._request_user_info()
ref_parsed = urlparse(request.referrer)
app_parsed = urlparse(url_for('events'))
redirect_url = '/'
if (ref_parsed.scheme == app_parsed.scheme
and ref_parsed.netloc == app_parsed.netloc):
redirect_url = request.referrer
return redirect(redirect_url)
def get_event(self, event_id):
event = Event.query.filter(Event.event_id == event_id).first()
if not event: return None
user = UserController().current_user
if user:
user_event = UserEvent.query.filter(
and_(UserEvent.event_id == event.event_id,
UserEvent.user_id == user.user_id)).first()
if user_event:
event.current_user_event = user_event
following_event_users = db_session.query(User).filter(
and_(UserEvent.event_id == event.event_id,
UserEvent.user_id == User.user_id,
Follow.user_id == user.user_id,
Follow.follow_id == User.user_id,
User.user_id != user.user_id, Follow.active == True))
event.card_event_users = [{
"user_id": u.user_id,
"username": u.username,
"image_url": u.image_url
} for u in following_event_users]
user_event_count = UserEvent.query.filter(
and_(UserEvent.event_id == event_id,
UserEvent.interest > UserEvent.interest_level(UserEvent.SKIP),
UserEvent.interest <= (max(UserEvent.DONE_LEVELS)))).count()
event.card_user_count = user_event_count
return event
def handle(self, message: Message):
user_id = message.chat.id
UserController.set_state(user_id, UserStateMachine.find_meeting)
candidate = UserController.find_meeting(user_id)
MeetingController.delete_not_is_ready(initiator_id=user_id)
if candidate is None:
UserController.set_state(user_id, UserStateMachine.main_menu)
self.bot.send_message(user_id,
"Кандидатов для встречи нет",
reply_markup=MainKeyboard.build())
else:
MeetingController.create_meeting(initiator_id=user_id,
companion_id=candidate.id)
self.bot.send_message(user_id,
f"{candidate.name}\n\n{candidate.bio}",
reply_markup=ViewingKeyboard.build())
def update_user(user_id):
"""Update a user."""
user_data = request.get_json()
response = None
# get user by id
user_by_id = UserController.get_users_by_id(user_id)
if user_by_id:
UserController.update_user(user_by_id, user_data)
response = success_response_body(user_data)
else:
# return no user error
response = error_response(404, "Resource Not Found")
return response
def register(cls):
username, password = cls.take_username_and_password()
try:
return UserController.register(username, password)
except InvalidUserInformation as e:
cls.show_message(str(e))
return None
def user_update(identifier):
current_user = UserController().current_user
current_user_id = UserController().current_user_id
action = request.form.get('action')
active = request.form.get('active') == 'true'
if action == 'block':
u = UserController().block_user(identifier, active)
elif action == 'follow':
u = UserController().follow_user(identifier, active)
if u:
events = []
if not Block.blocks(u.user_id, current_user_id):
events = EventController().get_events_for_user_by_interested(
user=u, interested=UserEvent.INTERESTED)
return redirect(request.referrer or '/')
def handle(self, message: Message):
user_id = message.chat.id
date = message.text
UserController.set_state(message.chat.id, UserStateMachine.main_menu)
meeting = MeetingController.set_time(user_id, date)
self.bot.send_message(user_id,
"Запрос на проведение встречи отправлен")
date = meeting.meeting_time.strftime("%H:%M %d.%m.%Y")
self.bot.send_message(meeting.companion_id.id,
f"C Вами хотят встретиться.\n\nВремя: {date}\n\n"
f"{meeting.initiator_id.name}\n"
f"{meeting.initiator_id.bio}",
reply_markup=MeetingKeyboard.build(meeting))
self.bot.send_message(user_id,
"Главное меню:",
reply_markup=MainKeyboard.build())
def get_active_meeting(_id: int) -> str:
query = ((Meeting.initiator_id == _id) | (Meeting.companion_id == _id)) \
& ((Meeting.status == MeetingStatus.planned) | (Meeting.status == MeetingStatus.planned))
meeting: Meeting = Meeting.get(query)
if _id == meeting.initiator_id.id:
companion: User = User.get(User.id == meeting.companion_id)
else:
companion: User = User.get(User.id == meeting.initiator_id)
meeting_time = meeting.meeting_time.strftime("%H:%M %d.%m.%Y")
return f"Время:\n{meeting_time}\n\n" + UserController.get_info(companion.id)
def get_events(self,
query=None,
categories=None,
tags=None,
cities=None,
flags=None,
page=1,
future_only=False):
current_user = UserController().current_user
selected_categories = set(categories.split(',') if categories else [])
selected_tags = set(tags.split(',') if tags else [])
events_with_counts = db_session.query(
Event,
func.count(func.distinct(
UserEvent.user_id)).label('ct')).outerjoin(
UserEvent, UserEvent.event_id == Event.event_id).group_by(
Event.event_id).order_by(desc('ct'))
if current_user:
current_user_events_table = alias(current_user.user_events(),
'current_user_events_table')
events_with_counts = events_with_counts.filter(~Event.event_id.in_(
db_session.query(
current_user_events_table.c.user_events_event_id)))
results, categories, tags, event_cities, results_table = self._process_events(
events=events_with_counts,
cities=cities,
page=page,
query=query,
user=current_user,
selected_categories=selected_categories,
selected_tags=selected_tags,
flags=flags,
future_only=future_only)
return results, categories, tags, event_cities
def login():
login_form = LoginForm()
if login_form.validate_on_submit():
user_login = UserController.login(username=login_form.username.data)
# Verifica se o usuário está autenticado
if current_user.is_authenticated and user_login == True:
return redirect(url_for('calculator'))
print(current_user.is_authenticated)
return "Você precisa acessar uma conta para ver essa página!"
return render_template('index.html', form=login_form)
def events(query=None,
category=None,
tag=None,
cities=None,
flags=None,
page=1,
next_page_url=None,
prev_page_url=None,
lat=None,
lon=None,
scroll=False,
selected=None):
selected_categories = category
current_user = UserController().current_user
if tag == Tag.TVM:
cities = None
events, categories, tags, event_cities = EventController().get_events(
query=query,
categories=category,
tags=tag,
cities=cities,
flags=flags,
page=page)
chips = _parse_chips(selected_categories=selected_categories,
categories=categories,
tags=tags,
cities=event_cities,
flags=flags)
vargs = {
'current_user': current_user,
'events': events,
'selected': selected,
'chips': chips,
'page': page,
'next_page_url': next_page_url,
'prev_page_url': prev_page_url
}
return _render_events_list(request,
events,
vargs,
scroll=scroll,
template=TEMPLATE_EXPLORE)
def register():
# Instancia o formulario de registro
register_form = RegistrationForm()
# Valida o formulário
if register_form.validate_on_submit():
# Chama o controller que irá registar
user = UserController.register(username=register_form.username.data,
password=register_form.password.data)
if user == True:
print('Registrado com sucesso! ')
return redirect(url_for('login'))
return render_template('register.html', form=register_form)
def save_seat(cls, user_id, projection_id, row, col):
if UserController.check_id(user_id) is False:
raise UserError('There is no user with id = {}!'.format(user_id))
if ProjectionController.check_id(projection_id) is False:
raise ProjectionException(
'There is no projection with id = {}!'.format(projection_id))
if cls.check_if_seat_is_taken(projection_id, row, col):
raise SeatError('The seat is taken!')
session.add(
Reservation(user_id=user_id,
projection_id=projection_id,
row=row,
col=col))
def event_update(event_id):
current_user = UserController().current_user
is_card = request.form.get('card') == 'true'
choice = request.form.get('choice')
if choice in UserEvent.interest_keys():
interest_key = choice
else:
interest_key = None
callback = request.form.get('cb')
if callback == "/": callback = 'events'
event = EventController().update_event(event_id=event_id,
interest_key=interest_key)
if event:
template = TEMPLATE_EVENT_CARD if is_card else TEMPLATE_EVENT_PAGE
categories_set = set()
tag_chips = []
for t in event.tags:
categories_set.add(t.tag_type)
tag_chips.append({'chip_name': t.tag_name})
category_chips = [{'chip_name': c} for c in categories_set]
chips = _parse_chips(categories=category_chips, tags=tag_chips)
vargs = {
'current_user': current_user,
'event': event,
'chips': chips,
'card': is_card
}
if request.is_xhr:
if template == TEMPLATE_EVENT_PAGE:
template = TEMPLATE_EVENT_PAGE_BODY
return render_template(template, vargs=vargs, **vargs)
if callback:
return redirect(callback)
return render_template(TEMPLATE_MAIN,
template=template,
vargs=vargs,
**vargs)
return redirect(request.referrer or '/')
def event(event_id):
event = EventController().get_event(event_id=event_id)
current_user = UserController().current_user
if event:
template = TEMPLATE_EVENT_PAGE
vargs = {
'title': event.display_name,
'current_user': current_user,
'event': event
}
if request.is_xhr:
return render_template(template, vargs=vargs, **vargs)
return render_template(TEMPLATE_MAIN,
template=template,
vargs=vargs,
**vargs)
return redirect(request.referrer or '/')
import sys
sys.path.insert(0, r'../..')
from models.connection import connection
from controllers.user_controller import UserController
user_controller = UserController(connection)
#access_token = '091e304b-1a3f-4406-ac3a-cf8afd8cd647'; # alex.ough
#access_token = '3ab4ae48-97fe-4420-8cb1-b1e3c62737f5'; # cloud_test_user
#params = {};
#role_id = '435a6417-6c1f-4d7c-87dd-e8f6c0effc7a'; # public
role_id = '3867c370-552f-43b8-bed9-6aa00ffc41b4'; # Awesome Role
access_token = '3ab4ae48-97fe-4420-8cb1-b1e3c62737f5'; # cloud_test_user
params = {'role_id': role_id};
print user_controller.find_all(access_token, params)
class Game(object):
def __init__(self, game_name, cursor_lib):
self.game_name = game_name
self.ai = AI()
self.turn_counter = 0
self.time = 0
self.world = get_world()
self.io, self.user_controller = self.init_nonserializable_objects(cursor_lib)
def init_nonserializable_objects(self, cursor_lib_callback):
self.io = WindowSystem(cursor_lib_callback())
self.user_controller = UserController(GameActions(self, self.player))
register_status_texts(self.io, self, self.player)
return self.io, self.user_controller
player = property(lambda self: self.world.player)
active_level = property(lambda self: self.world.player.level)
def main_loop(self):
ai_game_actions = GameActions(self)
self.io.msg("{0} for help menu".format(Bind.Help.key))
while True:
creature, time_delta = self.active_level.turn_scheduler.advance_time()
self.time += time_delta
if creature is self.player:
self.update_view(creature)
self.user_controller.actions._clear_action()
self.user_controller.act()
action_cost = self.user_controller.actions.action_cost
if action_cost > 0:
self.turn_counter += 1
else:
ai_game_actions._clear_action(and_associate_creature=creature)
self.ai.act(ai_game_actions, self.player.coord)
action_cost = ai_game_actions.action_cost
assert action_cost >= 0, \
"Negative cost actions are not allowed (yet at least).{}".format(action_cost)
creature_check, time_delta = self.active_level.turn_scheduler.addpop(creature, action_cost)
assert creature is creature_check
assert time_delta == 0
def move_creature_to_level(self, creature, world_point):
try:
target_level = self.world.get_level(world_point.level_key)
except LevelNotFound:
return False
creature.level.remove_creature(creature)
target_level.add_creature_to_location(creature, world_point.level_location)
try:
creature.vision.clear()
except AttributeError:
pass
if creature is self.player:
self.redraw()
return True
def creature_death(self, creature):
self.ai.remove_creature_state(creature)
if creature is self.player:
self.io.get_key("You die...", keys=Bind.Cancel)
self.endgame()
creature.level.remove_creature(creature)
def endgame(self):
exit()
def savegame(self):
try:
raw, compressed = state_store.save(self, self.game_name)
except IOError as e:
msg_str = str(e)
else:
msg_str = "Saved game '{}', file size: {:,} b, {:,} b compressed. Ratio: {:.2%}"
msg_str = msg_str.format(self.game_name, raw, compressed, raw / compressed)
return msg_str
def update_view(self, creature):
"""
Update the vision set of the creature.
This operation should only be done on creatures that have the .vision
attribute ie. AdvancedCreatures for instance.
"""
if not isinstance(creature, RemembersVision):
raise ValueError("Creature {} doesn't have the capacity to remember its vision.")
lvl = creature.level
new_vision = ShadowCast.get_light_set(lvl.is_see_through, creature.coord,
creature.sight, lvl.rows, lvl.cols)
creature.vision, old_vision = new_vision, creature.vision
potentially_modified_vision = new_vision | old_vision
if Debug.show_map:
vision_info = lvl.get_vision_information(lvl.tiles.coord_iter(), new_vision,
always_show_creatures=True)
else:
vision_info = lvl.get_vision_information(potentially_modified_vision, new_vision)
self.io.draw(vision_info)
if GameConf.clearly_show_vision:
reverse_data = lvl.get_vision_information(new_vision, new_vision)
self.io.draw(reverse_data, True)
def redraw(self):
self.io.level_window.clear()
lvl = self.active_level
if Debug.show_map:
draw_coords = lvl.tiles.coord_iter()
vision_info = lvl.get_vision_information(draw_coords, self.player.vision,
always_show_creatures=True)
else:
draw_coords = self.player.get_visited_locations() | self.player.vision
vision_info = lvl.get_vision_information(draw_coords, self.player.vision)
self.io.draw(vision_info)
if GameConf.clearly_show_vision:
reverse_data = lvl.get_vision_information(self.player.vision, self.player.vision)
self.io.draw(reverse_data, True)
def __getstate__(self):
exclude_state = ('user_controller', 'io')
state = vars(self).copy()
for item in exclude_state:
del state[item]
return state
def __setstate__(self, state):
vars(self).update(state)
def init_nonserializable_objects(self, cursor_lib_callback):
self.io = WindowSystem(cursor_lib_callback())
self.user_controller = UserController(GameActions(self, self.player))
register_status_texts(self.io, self, self.player)
return self.io, self.user_controller
