def member_actions(condition=None):
#1. 处理创建
if request.method == 'POST':
tel = request.form['tel']
mem_info = Member.add_member(tel)
ret_dic = {
"return_code": 200,
"return_msg": "add member success",
"member": mem_info
}
return jsonify(ret_dic)
elif request.method == 'GET':
if condition.startswith("tel_"):
tel = condition.split("_")[-1]
ret_dic = Member.search_by_tel(tel)
ret_dic['return_code'] = 200
ret_dic['return_msg'] = "Get Member by tel success"
return jsonify(ret_dic)
elif request.method == 'PATCH':
uid = int(condition.split("_")[-1])
score = int(request.form['score'])
ret_dic = Member.update_member_score(uid, score)
ret_dic['return_code'] = 200
ret_dic["return_msg"] = "update score success"
return jsonify(ret_dic)
class TestMember(unittest.TestCase):
def setUp(self):
member_doc = {
'id': 123,
'innocence': 0.1,
'experience': 0.5,
'charisma': 0.2,
'recruited': [],
'money': 1000,
'week_joined': 3
}
self.member = Member(member_doc)
def test_get_max_weeks(self):
result = self.member.get_max_weeks()
self.assertEqual(result, 4)
def test_get_recruit_probability_with_recruit(self):
for i in range(1, 11):
self.member.recruited.append(i)
result = self.member.get_recruit_probability()
self.assertEqual(result, 0)
def test_get_recruit_probability(self):
result = self.member.get_recruit_probability()
self.assertEqual(result, 0.1)
def test_get_current_karma(self):
with patch.object(
Karma, "get_current_net_karma_for_recipient") as test_method:
m = Member(TestMember.test_username)
m.get_current_karma()
test_method.assert_called_once_with(TestMember.test_username)
def execute(self):
# Check if username is unique, otherwise barf
member_exists = len(list(Member.objects.raw({'_id': self.username}))) != 0
if member_exists:
return
# instantiate & save new member
m = Member(username=self.username, slack_id=self.slack_id)
m.save()
def test_get_current_karma_with_net(self):
# Arrange
m = Member(default_karma_list())
# Act
net_karma = m.get_current_karma()
# Assert
self.assertEqual(0, net_karma)
def test_get_karma_reasons_all_default(self):
# Arrange
m = Member(default_karma_list())
# Act
karma_reasons = m.get_karma_reasons()
# Assert
self.assertEqual(len(default_karma_list()), karma_reasons['reasonless'])
self.assertEqual(0, len(karma_reasons['reasoned']))
def test_add_new_karma(self):
# Arrange
m = Member(default_karma_list())
k = Karma(karma_type=KarmaType.POZZYPOZ)
# Act
m.add_karma(k)
# Assert
self.assertEqual(1, m.get_current_karma())
def setUp(self):
member_doc = {
'id': 123,
'innocence': 0.1,
'experience': 0.5,
'charisma': 0.2,
'recruited': [],
'money': 1000,
'week_joined': 3
}
self.member = Member(member_doc)
def create_users(self):
owner = Member(key_name='*****@*****.**', name='Brandon Bell', role='owner', phone='(617)-840-0716')
manager = Member(key_name='*****@*****.**', name='Jose Martinez', role='manager', phone='(410)-245-7053')
manager2 = Member(key_name='*****@*****.**', name='CP Shankar', role='manager', phone='(410)-245-7053')
owner.put()
manager.put()
manager2.put()
return [owner, manager, manager2]
def post(self):
if self.any_previous_sessions():
return
user_deets = self.get_user_details_from_fb()
member = Member.get_by_key_name(user_deets['email'])
if not member:
member = Member(key_name=user_deets['email'], name=user_deets['name'])
member.put()
self.session['email'] = user_deets['email']
self.session['name'] = user_deets['name']
self.session['fb_id'] = user_deets['id']
self.session['role'] = member.role
def test_get_karma_reasons_one_non_default(self):
# Arrange
karma_list = default_karma_list()
karma_with_reason = Karma(reason="This is a silly reason")
karma_list.append(karma_with_reason)
m = Member(karma_list)
# Act
karma_reasons = m.get_karma_reasons()
# Assert
self.assertEqual(len(default_karma_list()), karma_reasons['reasonless'])
self.assertEqual(list([karma_with_reason]), karma_reasons['reasoned'])
def test_get_current_karma_with_expired(self):
# Arrange
newly_awarded = datetime.today()
award_ages_ago = datetime.today() - timedelta(days=31)
new_karma = Karma(awarded=newly_awarded)
old_karma = Karma(awarded=award_ages_ago)
karma_list = list([new_karma, old_karma])
m = Member(karma_list)
# Act
current_karma = m.get_current_karma()
# Assert
self.assertEqual(1, current_karma)
def create_member(self, email, name, phone, role_name):
member = Member.get_or_insert(key_name = email)
member.name = name
member.role = role_name
member.phone = phone
member.put()
return member
def __simulate_one_week__(self):
"""
Makes the program being simulated to advance in one week.
This method will search all active members and apply the rules of the program.
"""
self.__set_week__(self.current_week + 1)
members = self.db_controller.get_members()
filtered = filter(lambda x: (len(x['recruited']) < 10) & x['active'],
members)
members = list(filtered)
if not members:
self.db_controller.end_program()
self.continue_simulation = False
return
for member_doc in members:
member = Member(member_doc)
# 3.b of the document actually says "If the number is greater than the member's probability..."
# I'm going to use "less than", to make sense. The bigger the probability, the more likely the statement to be true
if get_random_number() < member.get_recruit_probability():
candidate = Investor(self.db_controller.get_random_investor())
self.logger.log(
'Member {} will try to recruit investor {}'.format(
member.id, candidate.id))
# Same problem with 3.c of the document
if get_random_number() < candidate.get_accept_probability():
self.logger.log(
'Investor {} will join the program invited by member {}'
.format(candidate.id, member.id))
member.money += 100
self.db_controller.add_member(candidate.id, member.id,
self.current_week)
else:
self.logger.log(
'Investor {} will not join the program'.format(
candidate.id))
else:
self.logger.log(
'Member {} will not recruit a new investor'.format(
member.id))
lasted_weeks = self.current_week - member.week_joined
if (member.money < 500) & (lasted_weeks >= member.get_max_weeks()):
self.logger.log(
'Member {} did not recover the investment in {} weeks and will be eliminated from the program with MM${}.'
.format(member.id, lasted_weeks, member.money))
self.db_controller.eliminate_member(member.id,
self.current_week)
def _member_logged_in(handler):
if not 'member' in handler.session:
handler.redirect('/members/login?' + urllib.urlencode({'redirect_url': handler.request.url}))
return False
member = Member.get_by_email(handler.session['member'])
if not member:
return False
return True
def _provider_logged_in(handler):
if not 'email' in handler.session:
return False
member = Member.get_by_key_name(handler.session['email'])
if not member:
return False
if member.role != 'provider':
return False
return True
def init_member(member: dict, context: Context) -> None:
from model.member import Member
from util import natus_util
context.reset()
member_id = member['MemberId']
age = natus_util.age(member['DOB'], context.run_date)
is_female = True if member['Gender'] == 'F' else False
context.member = Member(member_id, age, is_female)
def _insert_username(slack_event):
try:
member = Member.get_member_by_slack_id(slack_event["user"])
slack_event["user_id"] = slack_event["user"]
slack_event["user"] = member.username
except Exception:
logger.exception("Error loading user id from event: " +
str(slack_event))
def _member_logged_in(handler):
if not 'email' in handler.session:
set_redirect_url(handler)
handler.redirect("/")
return False
member = Member.get_by_key_name(handler.session['email'])
if not member:
set_redirect_url(handler)
handler.redirect("/")
return False
return True
def _process_slack_reaction(**e):
try:
slack_event = e["data"]
if not _is_subscribed_reaction(slack_event):
return
slack_event["channel"] = slack_event["item"]["channel"]
slack_event["reactor"] = Member.get_member_by_slack_id(
slack_event["user"]).username
slack_event["reactee"] = Member.get_member_by_slack_id(
slack_event["item_user"]).username
logger.info(str(slack_event))
_reaction_handlers[0].handle(slack_event)
except SlackApiError:
logger.exception("Slack API Error processing slack reaction")
except Exception as ex:
logger.exception("General error processing slack reaction: " + str(ex))
def test_slack_id_is_replaced(self):
slack_id = 'U12345'
slack_token = '<@' + slack_id + '>'
expected_member = Member(username="******")
with patch.object(Member,
"get_member_by_slack_id",
return_value=expected_member) as test_method:
actual = parser.replace_slack_id_tokens_with_usernames(slack_token)
self.assertEqual(expected_member.username, actual)
test_method.assert_called_once_with(slack_id)
def test_reasonless_command_one_word_slack_user_recipient(self):
m = Member(username="******", slack_id="slack_id")
with patch.object(Member, "get_member_by_slack_id", return_value=m):
# Arrange
command_message = "++ <@slack_id>"
expected = {
"recipient": "recipient",
"reason": "",
"karma_type": KarmaType.POZZYPOZ
}
# Act & Assert
self._check_parsing(command_message, expected)
def test_reasoned_command_slack_id_recipient_with_for(self):
# Arrange
m = Member(username="******", slack_id="slack_id")
with patch.object(Member, "get_member_by_slack_id", return_value=m):
command_message = "++ <@slack_id> for being sexy"
expected = {
"recipient": "username",
"reason": "being sexy",
"karma_type": KarmaType.POZZYPOZ
}
# Act & Assert
self._check_parsing(command_message, expected)
def test_slack_ids_replaced_in_long_message(self):
slack_id = 'U12345'
expected_member = Member(username="******")
message = "Hello this a longer message with a <@U12345> slack id in it."
expected = "Hello this a longer message with a test_username slack id in it."
with patch.object(Member,
"get_member_by_slack_id",
return_value=expected_member) as test_method:
actual = parser.replace_slack_id_tokens_with_usernames(message)
self.assertEqual(expected, actual)
test_method.assert_called_once_with(slack_id)
def post(self):
success = False
url = '/'
member = Member.get_by_key_name(self['email'])
error = ''
if member:
if member.role != 'provider':
self.session['email'] = member.key().name()
self.session['name'] = member.name
self.session['fb_id'] = "123"
self.session['role'] = member.role
success = True
url = self.session['redirect_url'] if 'redirect_url' in self.session else '/appliance/list'
else:
error = "Access for users of role 'Provider' is not allowed"
else:
error = 'User not found'
self.write(json.dumps({'success':success, 'url':url, 'error':error}))
def test_persistence(self):
# Arrange
Config().connect_to_db()
m = Member(TestMember.test_username)
# Act
m.save()
# Assert
retrieved_members = Member.objects.raw(
{'_id': TestMember.test_username})
self.assertEqual(1, retrieved_members.count())
self.assertEqual(m, retrieved_members[0])
# Tear down
m.delete()
def do_register():
"""
:desc: 登陆
:url: /m/sign/register
:method: POST
:param:
- login_name: 用户名
- password: 密码
"""
# 将新用户的注册信息插入
# 将密码加密
try:
message = ''
status = 0
insert_dict = g.params
#判断该用户是否已经注册
if check_member_exists(login_name=insert_dict['phone']) or \
check_member_exists(login_name=insert_dict['email']):
message = u'该用户已存在!'
status = 1
return
#得到加密后密码
insert_dict['password_crypt'] = get_md5(insert_dict['password'])
#删除未加密密码值,才能插入到member表
insert_dict.pop('password')
g.db.add(Member(**insert_dict))
g.db.commit()
except Exception, e:
message = repr(e)
status = 1
g.db.rollback()
def save_member_do(source):
try:
if request.method == "POST":
member = Member()
member.name = request.form["name"]
member.id_no = request.form["id_no"]
member.card = request.form["card"]
member.phone = request.form["phone"]
member.email = request.form["email"]
hierarchy_service.add_or_update_member(member)
if source == LIST_MEMBER:
return list_member()
else:
return index()
except TemplateNotFound:
# TODO 将这里的try except放入装饰器中，并打印日志
abort(404)
def create_pair(index: CombinationIndex, member_dict_list: List[dict]) -> Pair:
return Pair(index=index,
memberList=[
Member.from_dict(member_dict=member_dict)
for member_dict in member_dict_list
])
def fancha():
yesterday = request.form.get('fancha_yesterday', "ooo")
today = request.form.get('fancha_today', "ooo")
member = Member('泛槎', yesterday, today)
save(member)
return 'ok'
"user": "******"
}
valid_event_slack_id_recipient = {
"text": test_prefix + "reasons <@slack_id>",
"user": "******"
}
valid_event_slack_id_recipient_trailing_stuff = {
"text": test_prefix + "reasons <@slack_id> some extra guff",
"user": "******"
}
valid_event_no_recipient = {
"text": test_prefix + "reasons",
"user": "******"
}
invalid_event = {'text': '_g test'}
fake_member = Member(username="******", slack_id="slack_id")
help_event = {"text": test_prefix + "reasons -?"}
command_result = {
"reasonless":
10,
"reasoned":
list([
Karma(reason="reason1",
karma_type=KarmaType.POZZYPOZ,
awarded_by_username="******"),
Karma(reason="reason2",
karma_type=KarmaType.POZZYPOZ,
awarded_by_username="******"),
Karma(reason="reason3",
karma_type=KarmaType.NEGGYNEG,
awarded_by_username="******")
def jiufeng():
yesterday = request.form.get('jiufeng_yesterday', "ooo")
today = request.form.get('jiufeng_today', "ooo")
member = Member('九风', yesterday, today)
save(member)
return 'ok'
def add_member(self, member: gitlab) -> None:
self.__memberList.append(Member(member))
def _convert_slack_id_to_username(slack_id):
m = Member.get_member_by_slack_id(slack_id)
if m is not None:
return m.username
raise Exception("User not found")
def _init_member(self):
# y
w_member = Member()
w_member.id("y")
w_member.name("Yaiba (Y)")
w_member.role("Guitar / Vocals / Lead")
w_member.band("yblues")
self._manager_member.up_sert(w_member.id, w_member)
# marmotte
w_member = Member()
w_member.id("marmotte")
w_member.name("Marmotte")
w_member.role("Bass")
w_member.band("yblues")
self._manager_member.up_sert(w_member.id, w_member)
#spike
w_member = Member()
w_member.id("spike")
w_member.name("Spike")
w_member.role("Vocals")
w_member.band("yblues")
self._manager_member.up_sert(w_member.id, w_member)
#sereb
w_member = Member()
w_member.id("sereb")
w_member.name("Sereb")
w_member.role("Drums")
w_member.band("yblues")
self._manager_member.up_sert(w_member.id, w_member)
def fetch_users(self):
users = Member.all().fetch(100)
return [u for u in users]
def owner_user(self):
return Member.get_by_key_name(self.store.owner)
def manager_user(self):
return Member.get_by_key_name(self.store.manager)
def _username_is_known(username):
m = Member.get_member_by_username(username)
if m is not None:
return True
else:
return False
def create_single(index: CombinationIndex, member_dict: dict) -> Single:
return Single(index=index,
member=Member.from_dict(member_dict=member_dict))
