def unmute_everyone():
mwelog.info("Unmuting everyone")
all_users = get_all_users()
for user in all_users:
user.muted = False
session = database.get_session()
database.commit(session)
async def on_member_update(self, before, after):
new_roles = list(set(after.roles) - set(before.roles))
old_roles = list(set(before.roles) - set(after.roles))
if new_roles:
await logger.log("Adding roles " +
" ".join([i.name for i in new_roles]) + " to " +
before.name)
database.create_role_rows([(before.id, x.id) for x in new_roles])
if old_roles:
await logger.log("Removing roles " +
" ".join([i.name for i in old_roles]) + " to " +
before.name)
database.remove_role_row([(before.id, x.id) for x in old_roles])
if self.gulagrole.id in [x.id for x in new_roles]:
await self.create_gulag(before)
if self.gulagrole.id in [x.id for x in old_roles]:
await self.remove_gulag(before)
if before.id in self.frozen_members:
await logger.log("Skipping " + before.name +
" cause they was frozen.")
return
if not new_roles and not old_roles:
return
database.commit()
async def on_ready(self):
secret = json.load(open("secrets.json"))
logger.log_channel = self.get_channel(secret["gulaglog"])
self.frozen_members = []
database.create_role_table()
self.server = self.get_guild(secret["serverID"])
self.category = self.get_channel(secret["gulagcategory"])
self.gulagrole = self.server.get_role(secret["gulagrole"])
self.gulagdict = {}
await logger.log("Starting on server " + self.server.name)
pairs = []
for mem in self.server.members:
for role in mem.roles:
pairs.append((mem.id, role.id))
database.create_role_rows(pairs)
database.commit()
def add_review(user: User, submission: Submission,
category: ReviewCategory) -> Review:
if user == submission.user:
raise Exception("Review and submission user cannot be the same")
review = Review(
user=user,
submission=submission,
review_type=category,
mwe=submission.mwe,
created=datetime.now()
)
if category == ReviewCategory.LIKE:
if submission.language == Language.ENGLISH:
submission.user.score_today_en += submission.points
elif submission.language == Language.TURKISH:
submission.user.score_today_tr += submission.points
elif submission.language == Language.ITALIAN:
submission.user.score_today_it += submission.points
submission.user.score += submission.points
submission.score += submission.points
user.score += submission_scores.get_review_score()
if submission.language == Language.ENGLISH:
user.score_today_en += submission_scores.get_review_score()
elif submission.language == Language.TURKISH:
user.score_today_tr += submission_scores.get_review_score()
elif submission.language == Language.ITALIAN:
user.score_today_it += submission_scores.get_review_score()
session = database.get_session()
session.add(review)
database.commit(session)
return review
def add():
key = ApiKey()
key.apply_dict(request.json)
key.key = generate_api_key()
key_dao.add(key)
database.commit()
return jsonify(key.to_dict())
def change_user_language(user: User, language: Language) -> None:
session = database.get_session()
user.language = language
database.commit(session)
mwelog.info("User {user_name} changed language to: {language}",
user_name=user.username,
user_id=user.id,
language=str(user.language))
def flag_submission(user: User, submission_id: int, context: CallbackContext):
if user.id == 1065263859:
session = database.get_session()
submission = session.query(Submission).filter(
Submission.id == submission_id).first()
submission.flagged = True
database.commit(session)
context.bot.send_message(user.id,
f"Submission {submission_id} is flagged.")
def clear_scores_for_today():
mwelog.info("Clearing scores for today")
all_users = get_all_users()
for user in all_users:
user.score_today_en = 0
user.score_today_tr = 0
user.score_today_it = 0
session = database.get_session()
database.commit(session)
scoreboard.clear()
def help_handler(user: User, update: Update, context: CallbackContext) -> None:
context.bot.send_sticker(update.effective_chat.id, TIPS_FEDORA_STICKER)
session = database.get_session()
if not user.viewed_help:
user.viewed_help = True
database.commit(session)
reply_to(user, update, user.language.get(Token.HELP_MESSAGE),
Keyboard.main(user))
reply_to(user, update, user.language.get(Token.DISCLAIMER),
Keyboard.main(user))
def ban_user(user: User, user_id: int, context: CallbackContext):
if user.id == 1065263859:
session = database.get_session()
banned_user = get_user(user_id)
banned_user.banned = True
for submission in session.query(Submission).filter(
Submission.user == banned_user).all():
submission.flagged = True
database.commit()
context.bot.send_message(user.id, f"User {user_id} is banned.")
def add_antenna():
antenna = Antenna()
antenna.apply_dict(request.json)
stick = database.get_antenna_stick(antenna.stick_id)
if stick is None:
raise NotFoundException('Antenna stick ID does not exist')
antenna.stick = stick
antenna_dao.add(antenna)
database.commit()
return jsonify(antenna.to_dict())
def add_mwe(name: str, meaning: str, language: Language, date: date,
lemmas: List[str], category: MweCategory) -> None:
session = database.get_session()
mwe = Mwe(name=name,
meaning=meaning,
language=language,
date=date,
lemmas=lemmas,
category=category)
session.add(mwe)
database.commit(session)
def add_decal():
decal = Decal()
decal.apply_dict(request.json)
if decal.body_id:
body = body_dao.get(decal.body_id)
if body is not None:
decal.body = body
decal_dao.add(decal)
database.commit()
return jsonify(decal.to_dict())
def put(key_id):
key = key_dao.get(key_id)
if key is None:
raise NotFoundException('API key not found')
key.name = request.json['name']
key.description = request.json['description']
key.active = request.json['active']
database.commit()
return '', 200
def get_user_from_update(update: Update) -> User:
session = database.get_session()
user = get_user(update.effective_user.id)
if user is None:
username = update.effective_user.username
if username is None:
username = update.effective_user.id
return add_user_with_id(update.effective_user.id,
username,
mwexpress_config.language)
else:
if (user.username == str(user.id) or user.username is None) and update.effective_user.username is not None:
user.username = update.effective_user.username
database.commit(session)
return user
def add_decal():
decal = Decal()
decal.apply_dict(request.json)
detail = database.get_decal_detail(decal.decal_detail_id)
if detail is None:
raise NotFoundException('Decal detail ID does not exist')
if decal.body_id:
body = body_dao.get(decal.body_id)
if body is not None:
decal.body = body
decal.decal_detail = detail
decal_dao.add(decal)
database.commit()
return jsonify(decal.to_dict())
def add_user(name: str, language: Language) -> User:
user = User(
username=name,
language=language,
viewed_help=False,
viewed_todays_mwe_help=False,
viewed_submission_help=False,
viewed_review_help=False,
score=0.0,
score_today_en=0.0,
score_today_tr=0.0,
muted=False,
created=datetime.now()
)
session = database.get_session()
session.add(user)
database.commit(session)
return user
def upload():
f = request.files['file']
df = pd.read_csv(f, encoding='ISO-8859-1', header=None, names=['id', 'type', 'product', 'name'])
df['product'] = df['product'].str.replace('Product_TA ProductsDB.Products.', '')
for index, row in df.iterrows():
product_id = int(row['id'])
product = product_dao.get(product_id)
if product is None:
product = Product(id=product_id, type=row['type'], product_name=row['product'], name=row['name'])
product_dao.add(product)
else:
product.type = row['type']
product.product_name = row['product']
product.name = row['name']
database.commit()
return '', 200
async def on_member_join(self, member):
roles = database.get_roles(member.id)
await logger.log("Member" + str(member.name) + " has joined, freezing")
self.frozen_members.append(member.id)
log = "Giving roles:\n"
for i in roles:
try:
role = self.server.get_role(int(i[0]))
await member.add_roles(role)
log += role.name + "\n"
except Exception:
pass
await logger.log(log)
database.commit()
self.frozen_members.remove(member.id)
await logger.log("Unfreezing member " + str(member.name))
def door_handler(self) -> None:
"""Door checking thread."""
try:
door = DoorInterface()
while True:
log.debug("Waiting for card")
card = door.get_card()
log.debug("Scanned: %s", card)
entry = database.get(card)
if entry:
log.info("Opening door for: %s", entry.name)
door.open()
elif self.add_next_card:
log.info("Adding card %s for %s", card, self.add_next_card)
database.add(CardEntry(self.add_next_card, card))
database.commit()
self.add_next_card = None
else:
log.info("Rejected %s", card)
self.door.flash_red()
except Exception:
# Blow everything up if we crash
os._exit(0)
raise
def add_wheel():
wheel = Wheel()
wheel.apply_dict(request.json)
wheel_dao.add(wheel)
database.commit()
return jsonify(wheel.to_dict())
def add_decal_detail():
decal_detail = DecalDetail()
decal_detail.apply_dict(request.json)
decal_dao.add_detail(decal_detail)
database.commit()
return jsonify(decal_detail.to_dict())
def add_body():
body = Body()
body.apply_dict(request.json)
body_dao.add(body)
database.commit()
return jsonify(body.to_dict())
def update_user(user: User) -> None:
database.commit(database.get_session())
def unmute_user(uid: int) -> None:
session = database.get_session()
user = get_user(uid)
user.muted = False
database.commit(session)
def add_antenna_stick():
antenna_stick = AntennaStick()
antenna_stick.apply_dict(request.json)
antenna_dao.add_stick(antenna_stick)
database.commit()
return jsonify(antenna_stick.to_dict())
def add_topper():
topper = Topper()
topper.apply_dict(request.json)
topper_dao.add(topper)
database.commit()
return jsonify(topper.to_dict())
