def on_new_message(bot, update):
logger.info('new message in %d from %d', update.message.chat_id,
update.message.from_user.id)
Member.upsert(update.effective_chat.id, update.effective_user)
if update.message.reply_to_message:
Member.upsert(update.effective_chat.id,
update.message.reply_to_message.from_user)
def add_entry():
userId = request.form['id']
userPasswd = request.form['passwd']
for member in Member.all():
if userId == member.getId():
return "failed"
member = Member(userId=userId, userPasswd=userPasswd)
member.put()
return "OK"
class MemberQuery(object):
def __init__(self, router):
self._member = Member(router)
def get(self, key):
return self._member.get(key)
@tuplevalue
def put(self, key, value):
self._member.put(key, value)
@tuplevalue
def delete(self, key, value):
self._member.delete(key, value, regex=True)
def get_top_members_per_num_characters(self, top_n=20):
query = Member.select(Member, fn.SUM(fn.LENGTH(Message.content)).alias('length')) \
.join(Message, JOIN.RIGHT_OUTER) \
.group_by(Member) \
.order_by(SQL('length').desc()) \
.limit(top_n)
return list(query)
def get(self):
members = Member.query(Member.active == True).order(Member.username)
#Identify the slackers for future shaming
double_list = []
kill_tracker = []
for person in members:
if person.double < 0:
double_list.append(person)
kill_list = person.kill_list
logging.debug("Type of kill_list: " + str(type(kill_list)))
kills7 = sum(kill_list[23:])
kills14 = sum(kill_list[16:])
kills30 = sum(kill_list)
kill_dict = {
'name': person.username,
'kills7': kills7,
'kills14': kills14,
'kills30': kills30
}
kill_tracker.append(kill_dict)
template = JINJA_ENVIRONMENT.get_template('admin.html')
self.response.write(
template.render(kills=kill_tracker, double=double_list))
def get(self):
root_url = 'https://lyrania.co.uk/api/accounts/public_profile.php?'
memberlist = []
members = Member.query(Member.active == True).order(Member.username)
for member in members:
#Form URL
params = {'search': str(member.key.id())}
encoded_params = urllib.urlencode(params)
url = root_url + encoded_params
#Fetch request and format response
response = urlfetch.fetch(url=url, validate_certificate=True)
result = json.loads(response.content)
list_addition = [result]
memberlist = memberlist + list_addition
#Do stuff with the database HERE
member.username = result['name']
member.level = int(result['level'])
member.quests = int(result['quests_complete'])
member.base_stats = int(result['base_stats'])
member.dp = int(result['earned_dp'])
if result['guild_name'] != 'Phoenix':
member.active = False
member.put()
#Write return
template = JINJA_ENVIRONMENT.get_template('stats.html')
self.response.write(template.render(data=memberlist))
def get_top_members_per_message_count(self, top_n=9):
query = Member.select(Member, fn.Count(Message.id).alias('count')) \
.join(Message, JOIN.RIGHT_OUTER) \
.group_by(Member) \
.order_by(SQL('count').desc()) \
.limit(top_n)
return list(query)
def on_someone(bot, update, groups):
msg = update.effective_message
if msg.chat_id < 0: # groups only
logger.info('@someone from %d in %d', msg.from_user.id, msg.chat_id)
active_users = Member.get_active(msg.chat_id)
if not active_users:
logger.info('no users for this chat: %d', msg.chat_id)
Member.upsert(msg.chat_id, msg.from_user)
return
rand_user = random.choice(active_users)
if '@' in groups[0]:
# mention with "@someone"
user_mention = mention_html(rand_user.user.user_id, '@someone')
elif '^' in groups[0]:
# mention by first name
user_mention = mention_html(rand_user.user.user_id,
rand_user.user.first_name)
elif '?' in groups[0]:
# non-clickable mention using zero-width char
user_mention = '<code>@someone</code>{}'.format(
mention_html(rand_user.user.user_id, u'\u200B'))
else:
if rand_user.user.alias: # alias
# mention by alias if set
user_mention = mention_html(rand_user.user.user_id,
rand_user.user.alias)
else:
# mention by username if present, otherwise user the first name
user_mention = '@' + rand_user.user.username if rand_user.user.username else mention_html(
rand_user.user.user_id, rand_user.user.first_name)
text = f'{user_mention} {html_escape(groups[1]) if groups[1] else ""}'
msg.reply_html(text,
disable_web_page_preview=True,
reply_to_message_id=msg.reply_to_message.message_id
if msg.reply_to_message else None)
# try to delete if the message starts with '!'
if msg.text.startswith('!'):
try:
msg.delete()
except (BadRequest, TelegramError) as e:
logger.info("can't delete message: %s", str(e))
def delete_member(self, member_id):
"""Deletes a member from the database.
Args:
member_id: Unique discord id for that member.
Returns:
Whether the member was succesfully deleted.
"""
return Member.delete().where(Member.member_id == member_id).execute()
def get_member(self, member_id):
"""Gets a member from the database.
Args:
member_id: Unique discord id for that member.
Returns:
A member record.
"""
return Member.select().where(Member.member_id == member_id).first()
def member_exists(self, member_id):
"""Checks whether the chosen member is present in the database.
Args:
member_id: Unique discord id for that member.
Returns:
Whether there is a member with that id in the database.
"""
query = Member.select().where(Member.member_id == member_id)
return query.exists()
def add_member(self, member_id, username):
"""Adds a member to the database.
Args:
member_id: Unique discord id for that member.
username: Membername and discriminator combination string.
Returns:
A member record.
"""
member = Member.create(member_id=member_id, username=username)
return member
def members():
"""Show full list of club members and add new club members to list and database"""
form = MemberForm()
members = db.query(Member).order_by(Member.member_id)
if form.validate_on_submit():
db.add(Member(name=form.name.data, id_type=form.id_type.data, id_number=form.id_number.data))
db.commit()
flash("Membro adicionado com sucesso", "success")
return redirect(url_for("members"))
return render_template("membros.html", form=form, members=members)
def get_cards_from_podio(podio_client, app_id):
p = podio_client
res = p.Item.filter(app_id, {'limit': 1, 'offset': 0})
count = res['total'] - 1
items = res['items']
offset = 1
errors = []
while count > 0:
res = p.Item.filter(app_id, {'limit': 50, 'offset': offset})
items.extend(res['items'])
offset += 50
count -= 50
data = dict()
for item in items:
i = {
'item_id': item['item_id'],
'app_item_id': item['app_item_id'],
'member': None,
'owner': None,
}
for f in item['fields']:
if f['field_id'] == config.podio_fid_uid:
i['uid'] = f['values'][0]['value'].replace(' ', '')
if f['field_id'] == config.podio_fid_access_level:
i['access_level'] = int(f['values'][0]['value']['text'])
if f['field_id'] == config.podio_fid_member:
i['member'] = Member(
item_id=f['values'][0]['value']['item_id'],
app_item_id=f['values'][0]['value']['app_item_id'],
title=f['values'][0]['value']['title'])
if f['field_id'] == config.podio_fid_owner:
i['owner'] = f['values'][0]['value']
if f['field_id'] == config.podio_fid_expiry_data:
i['expiry_date'] = datetime.date(
*map(int, f['values'][0]['start_date_utc'].split('-')))
c = Card(uid=i['uid'],
access_level=i['access_level'],
pin='0000',
owner=i['owner'],
member_o=i['member'],
item_id=i['item_id'],
app_item_id=i['app_item_id'],
expiry_date=i['expiry_date'] if 'expiry_date' in i else
datetime.date(year=2100, month=12, day=31))
if c.uid in data:
errors.append('ERROR: Double uid in Podio: "{}".\n{}\n{}'.format(
c.uid, str(c), str(data[c.uid])))
continue
data[c.uid] = c
return data, errors
def get_top_members_per_message_count(self, top_n=9):
"""Gets the most active members sorted by number of messages posted.
Args:
top_n: The maximum number of members to return.
Returns:
A list of the top n most active members.
"""
query = Member.select(Member, fn.Count(Message.id).alias('count')) \
.join(Message, JOIN.RIGHT_OUTER) \
.group_by(Member) \
.order_by(SQL('count').desc()) \
.limit(top_n)
return list(query)
def post(self):
action = self.request.get('action')
logging.info("Admin action: " + action)
if action == "newcontest":
contest_name = self.request.get('contestname')
start_date = self.parseDate(str(self.request.get('startdate')))
end_date = self.parseDate(str(self.request.get('enddate')))
#If dates could not be parsed, return error.
if start_date is None or end_date is None:
result = "Invalid date parameters: Please use DD-MM-YYYY or YYYY-MM-DD"
#Else proceed with database update.
else:
#Get a list of current members. API call unnecessary since baseline GDP won't be calculated until contest starts.
members = Member.query(Member.active == True).order(
Member.username)
score_list = []
#Set up a ContestScore entity for each member
for person in members:
new_score = ContestScore(member_id=person.key.id(),
member_name=person.username,
start_gdp=0,
current_gdp=0)
score_list = score_list + [new_score]
#Create new Contest
new_contest = Contest(active=False,
name=contest_name,
start=start_date,
end=end_date,
scores=score_list)
new_contest.put()
result = "Contest " + new_contest.name + " successfully created!"
else:
logging.warning("Admin action: Unable to resolve action type!")
result = "Error: Unknown action"
#Output
template = JINJA_ENVIRONMENT.get_template('admin_submit.html')
self.response.write(template.render(info=result))
def get_top_members_per_num_characters(self, top_n=20):
"""Gets the most active members sorted by the sum of the number of
characters in the messages they posted.
Args:
top_n: The maximum number of members to return.
Returns:
A list of the top n most active members.
"""
query = Member.select(Member, fn.SUM(fn.LENGTH(Message.content)).alias('length')) \
.join(Message, JOIN.RIGHT_OUTER) \
.group_by(Member) \
.order_by(SQL('length').desc()) \
.limit(top_n)
return list(query)
def addMemberToDatabase(): #member,event,event_Volenteers,Attendance
from database import Member, Club
if request.method == 'POST':
name = request.form['name']
USN = request.form['USN']
clubId = request.form['clubId']
email = request.form['email']
member = Member(clubId, name, USN, email)
db.session.add(member)
db.session.commit()
club = Club.query.filter_by(id=clubId).first()
msg = Message('Registration successful',
sender='*****@*****.**',
recipients=[email])
msg.body = "Dear Student\n You have been successfully registered for the club" + club.name + "."
mail.send(msg)
return 'Member added successfully!!'
else:
#Bad Request
abort(400)
def on_left_member(bot, update):
logger.info('left member in %d', update.message.chat.id)
member = Member.get(Member.user_id == update.message.left_chat_member.id,
Member.chat_id == update.effective_chat.id)
deleted_rows = member.delete_instance()
logger.info('rows deleted: %d', deleted_rows)
Base.metadata.create_all(engine)
# Read member's data from csv file
with open('/home/mfsd1809/Dev/FullStackWebDeveloper/GitRepos/membership/directory.csv', encoding="utf8") as fin:
# Read csv file as a dictionary
csv_reader = csv.DictReader(fin)
# Iterate through rows of csv file and insert each member into db
for row in csv_reader:
member = Member(
first_name=row['first_name'],
last_name=row['last_name'],
street_num=row['street_num'],
street_name=row['street_name'],
city=row['city'],
_state=row['_state'],
postal_code=row['postal_code'],
contact_num=row['contact_num'],
email=row['email'],
birthdate=row['birthdate'],
age=row['age'],
inserted_date=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
)
db.session.add(member)
db.session.commit()
print('Initial member data inserted into database!')
# Create initial user
user = User(
first_name='first name here',
last_name='last name here',
def get(self):
logging.info("Starting maintenance job...")
#Form URL
url = 'https://lyrania.co.uk/api/guilds/member_list.php?'
params = {'api_code': GUILD_SECRET}
encoded_params = urllib.urlencode(params)
url = url + encoded_params
#Fetch request and format response
response = urlfetch.fetch(url=url, validate_certificate=True)
result = json.loads(response.content)
contest_additions = []
#[START UPDATE GUILD CONTRIBUTIONS]
for member in result['members']:
#Attempt to fetch this member from the DB
candidate_key = try_key(member['id'])
entry = candidate_key.get()
#If member not found, create a new one and set aside for addition to ongoing contests
if entry is None:
logging.info("New member detected: " + member['username'])
kill_tracker = []
for x in xrange(0, 29):
kill_tracker.append(0)
kill_tracker.append(
int(member['kills']['kills']) -
int(member['kills']['yesterdays_kills']))
infant_member = Member(
id=member['id'],
username=member['username'],
rank="0",
active=True,
level=int(member['level']),
kills=int(member['kills']['kills']),
quests=0,
base_stats=0,
buffed_stats=0,
dp=0,
xp=int(member['donations']['exp_donated']),
xp_prev=0,
food=int(member['donations']['food']),
food_prev=0,
stone=int(member['donations']['stone']),
stone_prev=0,
iron=int(member['donations']['iron']),
iron_prev=0,
lumber=int(member['donations']['lumber']),
lumber_prev=0,
gems=int(member['donations']['gems']),
gems_prev=0,
money=int(member['donations']['money']),
money_prev=0,
jade=int(member['donations']['jade']),
jade_prev=0,
double=int(member['donations']['double']),
gdp=int(member['gdp']['dp']),
gdp_prev=0,
gdp_spent=int(member['gdp']['dp_spent']),
gdp_spent_prev=0,
weekly_gdp=int(member['gdp']['weekly_dp']),
last_weekly_gdp=int(member['gdp']['last_weekly_dp']),
rp=int(member['rp']['donated']),
rp_prev=0,
chc=0,
chd=0,
heroism=0,
leadership=0,
archaeology=0,
jc=0,
serendipity="",
epeen=0,
w1=0,
w2=0,
a1=0,
a2=0,
a3=0,
a4=0,
a5=0,
a6=0,
a7=0,
kill_list=kill_tracker)
infant_member.put()
new_member = [member['id']]
contest_additions = contest_additions + new_member
#Otherwise, update the existing entry
else:
entry.username = member['username']
entry.active = True
entry.level = int(member['level'])
entry.kills = int(member['kills']['kills'])
entry.xp = int(member['donations']['exp_donated'])
entry.food = int(member['donations']['food'])
entry.stone = int(member['donations']['stone'])
entry.iron = int(member['donations']['iron'])
entry.lumber = int(member['donations']['lumber'])
entry.gems = int(member['donations']['gems'])
entry.money = int(member['donations']['money'])
entry.jade = int(member['donations']['jade'])
entry.double = int(member['donations']['double'])
entry.gdp = int(member['gdp']['dp'])
entry.gdp_spent = int(member['gdp']['dp_spent'])
entry.weekly_gdp = int(member['gdp']['weekly_dp'])
entry.last_weekly_gdp = int(member['gdp']['last_weekly_dp'])
entry.rp = int(member['rp']['donated'])
kill_tracker = entry.kill_list
yesterdays_kills = int(member['kills']['kills']) - int(
member['kills']['yesterdays_kills'])
kill_tracker.append(yesterdays_kills)
kill_tracker = kill_tracker[1:]
entry.kill_list = kill_tracker
#Update the database
entry.put()
#[END UPDATE GUILD CONTRIBUTIONS]
#[START UPDATE STATS]
root_url = 'https://lyrania.co.uk/api/accounts/public_profile.php?'
memberlist = []
members = Member.query(Member.active == True).order(Member.username)
for person in members:
#Form URL
params = {'search': str(person.key.id())}
encoded_params = urllib.urlencode(params)
url = root_url + encoded_params
#Fetch request and format response
response = urlfetch.fetch(url=url, validate_certificate=True)
result = json.loads(response.content)
list_addition = [result]
memberlist = memberlist + list_addition
#Do stuff with the database HERE
person.username = result['name']
person.level = int(result['level'])
person.quests = int(result['quests_complete'])
person.base_stats = int(result['base_stats'])
person.dp = int(result['earned_dp'])
#If no longer a member, inactivate and store off previous stats
if result['guild_name'] != 'Phoenix':
logging.info("Member no longer in guild: " + person.username)
person.active = False
person.xp_prev = person.xp
person.money_prev = person.money
person.jade_prev = person.jade
person.gems_prev = person.gems
person.food_prev = person.food
person.iron_prev = person.iron
person.stone_prev = person.stone
person.lumber_prev = person.lumber
person.gdp_prev = person.gdp
person.gdp_spent_prev = person.gdp_spent
person.rp_prev = person.rp
person.put()
#[END UPDATE STATS]
#[START UPDATE CONTESTS]
#Get today and also yesterday, since contests up until yesterday are relevant
today = datetime.date.today()
date_adjust = datetime.timedelta(days=-1)
yesterday = today + date_adjust
contest_list = Contest.query(Contest.end >= yesterday)
if contest_list is None:
logging.info("No active contests")
else:
for item in contest_list:
logging.info("Updating contest: " + item.name)
if item.start <= today and item.end >= today:
item.active = True
else:
item.active = False
for score in item.scores:
candidate_key = try_key(score.member_id)
this_member = candidate_key.get()
if this_member is not None:
score.current_gdp = this_member.gdp
score.member_name = this_member.username
if item.start == today:
score.start_gdp = this_member.gdp
else:
logging.warning("Unable to retrieve member: " +
score.member_name)
for addition in contest_additions:
candidate_key = try_key(addition)
entity = candidate_key.get()
if entity is not None:
new_score = ContestScore(member_id=entity.key.id(),
member_name=entity.username,
start_gdp=entity.gdp,
current_gdp=entity.gdp)
item.scores = item.scores + [new_score]
else:
logging.warning("Unable to add contest addition: " +
str(addition))
item.put()
def show_entries():
members = Member.all()
return render_template("practice.html", members=members)
def __init__(self, router):
self._member = Member(router)
def on_new_member(bot, update):
logger.info('new members in %d: %d new members', update.message.chat.id,
len(update.message.new_chat_members))
# db.save_users(update.message.chat_id, update.message.new_chat_members)
Member.upsert_many(update.effective_chat.id,
update.message.new_chat_members)
