def user_page(uid, nickname=None):
user = User(uid=uid).get()
if not user:
return u'', 200
oauth = OAuth(user['mail']).get()
if 'profile' in user and 'badge_name' in user['profile']:
_nickname = user['profile']['badge_name']
else:
_nickname = oauth['data']['name']
_nickname = quote_plus(_nickname)
if nickname is None or nickname != _nickname:
return redirect(url_for('user.user_page', uid=uid, nickname=_nickname))
if 'profile' not in user:
badge_name = ''
intro = ''
else:
badge_name = user['profile']['badge_name']
intro = re.sub('<a href="javascript:.*"', '<a href="/"',
markdown(html.escape(user['profile']['intro'])))
participate_in = []
for p in Team.participate_in(uid):
p['_project'] = Project.get(p['pid'])
p['_title'] = '???'
if uid in p['chiefs']:
p['_title'] = 'chief'
elif uid in p['members']:
p['_title'] = 'member'
p['_action_date'] = arrow.get(
p['_project']['action_date']).format('YYYY/MM')
participate_in.append(p)
participate_in = sorted(participate_in,
key=lambda p: p['_project']['action_date'],
reverse=True)
mattermost_data = {}
mid = MattermostTools.find_possible_mid(uid=uid)
if mid:
mattermost_data['mid'] = mid
mattermost_data['username'] = MattermostTools.find_user_name(mid=mid)
return render_template(
'./user.html',
badge_name=badge_name,
intro=intro,
oauth=oauth,
user=user,
mattermost_data=mattermost_data,
participate_in=participate_in,
)
def test_update_profile():
''' Test update profile '''
_mail = '*****@*****.**'
OAuthDB().add_data(mail=_mail, data={})
created_user = User.create(mail=_mail)
data = {'nickname': 'nick coscup'}
updated_user = User(uid=created_user['_id']).update_profile(data=data)
assert updated_user['profile']['nickname'] == 'nick coscup'
real_data = {'name': 'COSCUP'}
updated_user = User(uid=created_user['_id']).update_profile_real(
data=real_data)
assert updated_user['profile_real']['name'] == 'COSCUP'
suspend_user = User(uid=created_user['_id']).property_suspend()
assert suspend_user['property']['suspend']
def profile_real():
if request.method == 'GET':
user = g.user['account']
default_code = '886'
if 'profile_real' not in user:
user['profile_real'] = {}
else:
try:
phone = phonenumbers.parse(user['profile_real']['phone'], None)
user['profile_real']['phone'] = phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.NATIONAL)
default_code = phone.country_code
except phonenumbers.phonenumberutil.NumberParseException:
pass
if 'bank' not in user['profile_real']:
user['profile_real']['bank'] = {}
phone_codes = sorted(phonenumbers.COUNTRY_CODE_TO_REGION_CODE.items(), key= lambda x: x[1][0])
return render_template('./setting_profile_real.html', user=user,
phone_codes=phone_codes, default_code=default_code)
elif request.method == 'POST':
try:
phone = phonenumbers.parse('+%(phone_code)s %(phone)s' % request.form)
phone = phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.E164)
except phonenumbers.phonenumberutil.NumberParseException:
phone = ''
data = {
'name': request.form['name'].strip(),
'phone': phone,
'birthday': request.form['birthday'].strip(),
'roc_id': request.form['roc_id'].strip(),
'company': request.form['company'].strip(),
'bank': {
'code': request.form['account_bank_code'].strip(),
'no': request.form['account_bank_no'].strip(),
'branch': request.form['account_bank_branch'].strip(),
'name': request.form['account_bank_name'].strip(),
}
}
User(uid=g.user['account']['_id']).update_profile_real(data)
MC.get_client().delete('sid:%s' % session['sid'])
return redirect(url_for('setting.profile_real', _scheme='https', _external=True))
def profile():
if request.method == 'GET':
user = g.user['account']
if 'profile' not in user:
user['profile'] = {}
return render_template('./setting_profile.html', user=user)
elif request.method == 'POST':
data = {
'badge_name': request.form['badge_name'],
'intro': request.form['intro'],
}
User(uid=g.user['account']['_id']).update_profile(data)
MC.get_client().delete('sid:%s' % session['sid'])
return redirect(url_for('setting.profile', _scheme='https', _external=True))
def team_edit_user_api(pid, tid):
team, project, _redirect = check_the_team_and_project_are_existed(pid=pid, tid=tid)
if _redirect:
return _redirect
is_admin = (g.user['account']['_id'] in team['chiefs'] or \
g.user['account']['_id'] in team['owners'] or \
g.user['account']['_id'] in project['owners'])
if not is_admin:
return redirect('/')
if request.method == 'GET':
user = User(uid=request.args['uid']).get()
user_waitting = WaitList.list_by_team(pid=pid, tid=tid, uid=user['_id'])
if not user_waitting:
return jsonify({})
users_info = User.get_info([user['_id'], ])
user_data = {
'badge_name': users_info[user['_id']]['profile']['badge_name'],
'picture': users_info[user['_id']]['oauth']['picture'],
'uid': user['_id'],
'note': user_waitting['note'],
'wid': u'%(_id)s' % user_waitting,
}
return jsonify(user_data)
elif request.method == 'POST':
all_members = len(team['members']) + len(team['chiefs'])
if 'headcount' in team and team['headcount'] and all_members >= team['headcount']:
return jsonify({'status': 'fail', 'message': 'over headcount.'}), 406
data = request.json
w = WaitList.make_result(wid=data['wid'], pid=pid, uid=data['uid'], result=data['result'])
if w and 'result' in w:
if w['result'] == 'approval':
Team.update_members(pid=pid, tid=tid, add_uids=[data['uid'], ])
elif w['result'] == 'deny':
TeamMemberChangedDB().make_record(pid=pid, tid=tid, deny_uids=(data['uid'], ))
return jsonify({'status': 'ok'})
def user_add() -> None:
''' Create an dev user '''
user_info = {
'id': '000000000000000000000',
'email': '*****@*****.**',
'verified_email': True,
'name': 'Volunteer Dev (testing)',
'given_name': 'Volunteer',
'family_name': 'Dev',
'picture': '',
'locale': 'en',
}
# ----- save oauth info ----- #
OAuth.add(mail=user_info['email'], data=user_info, token=Token())
# ----- Check account or create ----- #
owner = OAuth.owner(mail=user_info['email'])
if owner:
user = User(uid=owner).get()
else:
user = User.create(mail=user_info['email'])
user_session = USession.make_new(uid=user['_id'], header={})
click.echo(click.style('\n[!] Next step', bold=True))
click.echo(
click.style(' | Please visit these link to setup the cookie/session:',
fg='yellow',
bold=True))
click.echo(
click.style(
f' -> http://127.0.0.1/dev/cookie?sid={user_session.inserted_id}',
fg='green',
bold=True))
click.echo('')
click.echo(
click.style('Thank you for your contribution!', fg='cyan', bold=True))
click.echo('')
def service_sync_gsuite_memberchange(sender, **kwargs):
team_member_change_db = TeamMemberChangedDB()
sync_gsuite = None
for raw in team_member_change_db.find(
{
'done.gsuite_team': {
'$exists': False
},
'case': {
'$in': ('add', 'del')
}
},
sort=(('create_at', 1), )):
team = Team.get(raw['pid'], raw['tid'])
if 'mailling' not in team or not team['mailling']:
team_member_change_db.find_one_and_update(
{'_id': raw['_id']}, {'$set': {
'done.gsuite_team': True
}})
continue
if sync_gsuite is None:
sync_gsuite = SyncGSuite(credentialfile=setting.GSUITE_JSON,
with_subject=setting.GSUITE_ADMIN)
user = User(uid=raw['uid']).get()
if raw['case'] == 'add':
sync_gsuite.add_users_into_group(group=team['mailling'],
users=(user['mail'], ))
team_member_change_db.find_one_and_update(
{'_id': raw['_id']}, {'$set': {
'done.gsuite_team': True
}})
elif raw['case'] == 'del':
sync_gsuite.del_users_from_group(group=team['mailling'],
users=(user['mail'], ))
team_member_change_db.find_one_and_update(
{'_id': raw['_id']}, {'$set': {
'done.gsuite_team': True
}})
for raw in team_member_change_db.find(
{
'done.gsuite_staff': {
'$exists': False
},
'case': {
'$in': ('add', 'del')
}
},
sort=(('create_at', 1), )):
project = Project.get(raw['pid'])
if 'mailling_staff' not in project or not project['mailling_staff']:
team_member_change_db.find_one_and_update(
{'_id': raw['_id']}, {'$set': {
'done.gsuite_staff': True
}})
continue
if sync_gsuite is None:
sync_gsuite = SyncGSuite(credentialfile=setting.GSUITE_JSON,
with_subject=setting.GSUITE_ADMIN)
user = User(uid=raw['uid']).get()
if raw['case'] == 'add':
sync_gsuite.add_users_into_group(group=project['mailling_staff'],
users=(user['mail'], ))
team_member_change_db.find_one_and_update(
{'_id': raw['_id']}, {'$set': {
'done.gsuite_staff': True
}})
elif raw['case'] == 'del':
sync_gsuite.del_users_from_group(group=project['mailling_staff'],
users=(user['mail'], ))
team_member_change_db.find_one_and_update(
{'_id': raw['_id']}, {'$set': {
'done.gsuite_staff': True
}})
def team_edit_user(pid, tid):
team, project, _redirect = check_the_team_and_project_are_existed(pid=pid, tid=tid)
if _redirect:
return _redirect
is_admin = (g.user['account']['_id'] in team['chiefs'] or \
g.user['account']['_id'] in team['owners'] or \
g.user['account']['_id'] in project['owners'])
if not is_admin:
return redirect('/')
if request.method == 'GET':
waitting_list = list(WaitList.list_by_team(pid=pid, tid=tid))
uids = [u['uid'] for u in waitting_list]
users_info = User.get_info(uids)
for u in waitting_list:
u['_info'] = users_info[u['uid']]
u['_history'] = []
for w in WaitList.find_history(pid=pid, uid=u['uid']):
if 'result' not in w:
w['result'] = 'waitting'
u['_history'].append(w)
u['_mail'] = User(uid=u['uid']).get()['mail']
members = []
if team['members'] or team['chiefs']:
_all_uids = set(team['chiefs']) | set(team['members'])
users_info = User.get_info(list(_all_uids))
for uid in _all_uids:
members.append(users_info[uid])
for u in members:
u['chat'] = {}
mid = MattermostTools.find_possible_mid(uid=u['_id'])
if mid:
u['chat'] = {'mid': mid, 'name': MattermostTools.find_user_name(mid=mid)}
u['phone'] = {'country_code': '', 'phone': ''}
if 'phone' in u['profile_real'] and u['profile_real']['phone']:
phone = phonenumbers.parse(u['profile_real']['phone'])
u['phone']['country_code'] = phonenumbers.COUNTRY_CODE_TO_REGION_CODE[phone.country_code][0]
u['phone']['phone'] = phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.NATIONAL)
members = sorted(members, key=lambda u: u['profile']['badge_name'])
return render_template('./team_edit_user.html',
project=project, team=team, waitting_list=waitting_list, members=members)
elif request.method == 'POST':
data = request.json
if data['case'] == 'deluser':
Team.update_members(pid=pid, tid=tid, del_uids=[data['uid'], ])
elif data['case'] == 'history':
history = []
for raw in WaitList.find_history_in_team(uid=data['uid'], pid=pid, tid=tid):
raw['_id'] = str(raw['_id'])
history.append(raw)
return jsonify({'history': history})
return jsonify(data)
def profile_page() -> Union[Text, Response]:
''' profile '''
# pylint: disable=too-many-branches
if request.method == 'GET':
user = g.user['account']
if 'profile' not in user:
user['profile'] = {}
return render_template('./setting_profile.html', user=user)
if request.method == 'POST':
post_data = request.get_json()
if post_data['casename'] == 'get':
user = g.user['account']
if 'profile' not in user:
user['profile'] = {}
profile = {}
if 'profile' in user:
if 'badge_name' in user['profile'] and user['profile']['badge_name'].strip():
profile['badge_name'] = user['profile']['badge_name'].strip()
profile['intro'] = user['profile'].get('intro', '')
profile['id'] = user['_id']
return jsonify({
'profile': profile,
'team_enum': {key: item.value for key, item in TeamsEnum.__members__.items()},
'team_enum_desc': {key: item.value for key, item in
TeamsEnumDesc.__members__.items()},
'skill_enum': {key: item.value for key, item in
SkillEnum.__members__.items()},
'skill_enum_desc': {key: item.value for key, item in
SkillEnumDesc.__members__.items()},
'status_enum': {key: item.value for key, item in StatusEnum.__members__.items()},
'status_enum_desc': {key: item.value for key, item in
StatusEnumDesc.__members__.items()},
})
if post_data['casename'] == 'get_tobe_volunteer':
data = TobeVolunteer.get(uid=g.user['account']['_id'])
return jsonify({'tobe_volunteer': data})
if post_data['casename'] == 'save_tobe_volunteer':
data = TobeVolunteerStruct.parse_obj(post_data['data']).dict()
data['uid'] = g.user['account']['_id']
TobeVolunteer.save(data=data)
return jsonify({})
if post_data['casename'] == 'save':
data = {}
if 'badge_name' in post_data['data'] and post_data['data']['badge_name']:
data['badge_name'] = post_data['data']['badge_name'].strip()
if 'intro' in post_data['data'] and post_data['data']['intro']:
data['intro'] = post_data['data']['intro'].strip()
if data:
User(uid=g.user['account']['_id']).update_profile(data)
MC.get_client().delete(f"sid:{session['sid']}")
return jsonify({})
return jsonify({}), 404
def profile_real():
''' Profile real '''
# pylint: disable=too-many-branches
if request.method == 'GET':
return render_template('./setting_profile_real.html')
if request.method == 'POST':
post_data = request.get_json()
if post_data['casename'] == 'get':
default_code = '886'
if 'profile_real' in g.user['account']:
user = {'profile_real': g.user['account']['profile_real']}
try:
phone = phonenumbers.parse(
user['profile_real']['phone'], None)
user['profile_real']['phone'] = phonenumbers.format_number(
phone, phonenumbers.PhoneNumberFormat.NATIONAL)
default_code = phone.country_code
except phonenumbers.phonenumberutil.NumberParseException:
pass
else:
user = {'profile_real': {}}
if 'bank' not in user['profile_real']:
user['profile_real']['bank'] = {}
if 'address' not in user['profile_real']:
user['profile_real']['address'] = {}
if 'dietary_habit' not in user['profile_real']:
user['profile_real']['dietary_habit'] = []
phone_codes = sorted(
phonenumbers.COUNTRY_CODE_TO_REGION_CODE.items(), key=lambda x: x[1][0])
return jsonify({'profile': user['profile_real'],
'phone_codes': phone_codes,
'default_code': default_code,
'dietary_habit': list(DietaryHabit.ITEMS.items()),
})
if post_data['casename'] == 'update':
phone = ''
if 'phone' in post_data['data'] and post_data['data']['phone'] and \
'phone_code' in post_data['data'] and post_data['data']['phone_code']:
try:
phone = phonenumbers.parse(
f"+{post_data['data']['phone_code']} {post_data['data']['phone']}")
phone = phonenumbers.format_number(
phone, phonenumbers.PhoneNumberFormat.E164)
except phonenumbers.phonenumberutil.NumberParseException:
phone = ''
data = {
'name': post_data['data'].get('name', '').strip(),
'phone': phone,
'roc_id': post_data['data'].get('roc_id', '').strip(),
'company': post_data['data'].get('company', '').strip(),
'dietary_habit': DietaryHabit.valid(items_no=post_data['data']['dietary_habit']),
'bank': {
'code': post_data['data']['bank'].get('code', '').strip(),
'no': post_data['data']['bank'].get('no', '').strip(),
'branch': post_data['data']['bank'].get('branch', '').strip(),
'name': post_data['data']['bank'].get('name', '').strip(),
},
'address': {
'code': post_data['data']['address'].get('code', '').strip(),
'receiver': post_data['data']['address'].get('receiver', '').strip(),
'address': post_data['data']['address'].get('address', '').strip(),
}
}
birthday = post_data['data'].get('birthday', '').strip()
if birthday:
try:
birthday = arrow.get(birthday).format('YYYY-MM-DD')
except arrow.parser.ParserError:
birthday = ''
data['birthday'] = birthday
User(uid=g.user['account']['_id']).update_profile_real(data)
MC.get_client().delete(f"sid:{session['sid']}")
return jsonify(data)
return jsonify({}), 404
def test_get():
''' Test get '''
user = User(uid='coscup')
user.get()
def test_init(uid, mail): # pylint: disable=redefined-outer-name
''' test init '''
user = User(uid=uid, mail=mail)
assert user.uid == uid
assert user.mail == mail
def need_login():
''' need_login '''
# pylint: disable=too-many-return-statements
logging.info(
'[X-SSL-SESSION-ID: %s] [X-REAL-IP: %s] [USER-AGENT: %s] [SESSION: %s]',
request.headers.get('X-SSL-SESSION-ID'),
request.headers.get('X-REAL-IP'),
request.headers.get('USER-AGENT'),
session,
)
if request.path.startswith('/user') and request.path[-1] == '/':
return redirect(request.path[:-1])
if 'sid' in session and session['sid']:
mem_cahce = MC.get_client()
user_g_data = mem_cahce.get(f"sid:{session['sid']}")
if user_g_data:
g.user = user_g_data # pylint: disable=assigning-non-slot
else:
session_data = USession.get(session['sid'])
if session_data:
user_data = User(uid=session_data['uid']).get()
if 'property' in user_data and 'suspend' in user_data['property'] and \
user_data['property']['suspend']:
session.pop('sid', None)
return redirect(
url_for('index', _scheme='https', _external=True))
g.user = {} # pylint: disable=assigning-non-slot
g.user['account'] = User(uid=session_data['uid']).get()
if g.user['account']:
g.user['data'] = OAuth(
mail=g.user['account']['mail']).get()['data']
g.user['participate_in'] = sorted([{
'pid': team['pid'],
'tid': team['tid'],
'name': team['name']
} for team in Team.participate_in(uid=session_data['uid'])
],
key=lambda x: x['pid'],
reverse=True)
mem_cahce.set(f"sid:{session['sid']}", g.user, 600)
else:
session.pop('sid', None)
session['r'] = request.path
return redirect(
url_for('oauth2callback', _scheme='https', _external=True))
return None
if request.path in NO_NEED_LOGIN_PATH or request.path.startswith('/tasks'):
return None
if request.path not in NO_NEED_LOGIN_PATH:
# ----- Let user profile public ----- #
# if re.match(r'(\/user\/[a-z0-9]{8}).*', request.path):
# return
session['r'] = request.path
logging.info('r: %s', session['r'])
return redirect(
url_for('oauth2callback', _scheme='https', _external=True))
session.pop('sid', None)
session['r'] = request.path
return redirect(url_for('oauth2callback', _scheme='https', _external=True))
def oauth2callback():
''' oauth2callback '''
if 'r' in request.args and request.args['r'].startswith('/'):
session['r'] = request.args['r']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
'./client_secret.json',
scopes=(
'openid',
'https://www.googleapis.com/auth/userinfo.email',
'https://www.googleapis.com/auth/userinfo.profile',
),
redirect_uri=f'https://{setting.DOMAIN}/oauth2callback',
)
if 'code' not in request.args:
authorization_url, state = flow.authorization_url(
access_type='offline',
include_granted_scopes='true',
state=hashlib.sha256(os.urandom(2048)).hexdigest(),
)
session['state'] = state
return redirect(authorization_url)
url = request.url.replace('http://', 'https://')
url_query = parse_qs(urlparse(url).query)
if 'state' in url_query and url_query['state'] and \
url_query['state'][0] == session.get('state'):
flow.fetch_token(authorization_response=url)
auth_client = discovery.build('oauth2',
'v2',
credentials=flow.credentials,
cache_discovery=False)
user_info = auth_client.userinfo().get().execute()
# ----- save oauth info ----- #
OAuth.add(mail=user_info['email'],
data=user_info,
token=flow.credentials)
# ----- Check account or create ----- #
owner = OAuth.owner(mail=user_info['email'])
if owner:
user = User(uid=owner).get()
else:
user = User.create(mail=user_info['email'])
MailLetterDB().create(uid=user['_id'])
user_session = USession.make_new(uid=user['_id'],
header=dict(request.headers))
session['sid'] = user_session.inserted_id
if 'r' in session:
redirect_path = session['r']
logging.info('login r: %s', redirect_path)
session.pop('r', None)
session.pop('state', None)
return redirect(redirect_path)
return redirect(url_for('index', _scheme='https', _external=True))
session.pop('state', None)
return redirect(url_for('oauth2callback', _scheme='https', _external=True))
def need_login():
app.logger.info(
'[X-SSL-SESSION-ID: %s] [X-REAL-IP: %s] [USER-AGENT: %s] [SESSION: %s]'
% (
request.headers.get('X-SSL-SESSION-ID'),
request.headers.get('X-REAL-IP'),
request.headers.get('USER-AGENT'),
session,
))
if request.path.startswith('/user') and request.path[-1] == '/':
return redirect(request.path[:-1])
if 'sid' in session and session['sid']:
mc = MC.get_client()
user_g_data = mc.get('sid:%s' % session['sid'])
if user_g_data:
g.user = user_g_data
else:
session_data = USession.get(session['sid'])
if session_data:
user_data = User(uid=session_data['uid']).get()
if 'property' in user_data and 'suspend' in user_data[
'property'] and user_data['property']['suspend']:
session.pop('sid', None)
return redirect(
url_for('index', _scheme='https', _external=True))
g.user = {}
g.user['account'] = User(uid=session_data['uid']).get()
if g.user['account']:
g.user['data'] = OAuth(
mail=g.user['account']['mail']).get()['data']
g.user['participate_in'] = sorted([{
'pid': team['pid'],
'tid': team['tid'],
'name': team['name']
} for team in Team.participate_in(uid=session_data['uid'])
],
key=lambda x: x['pid'],
reverse=True)
mc.set('sid:%s' % session['sid'], g.user, 600)
else:
session.pop('sid', None)
session['r'] = request.path
return redirect(
url_for('oauth2callback',
_scheme='https',
_external=True))
else:
session.pop('sid', None)
session['r'] = request.path
return redirect(
url_for('oauth2callback', _scheme='https', _external=True))
else:
if request.path.startswith('/tasks'):
return
if request.path not in NO_NEED_LOGIN_PATH:
# ----- Let user profile public ----- #
#if re.match(r'(\/user\/[a-z0-9]{8}).*', request.path):
# return
session['r'] = request.path
app.logger.info('r: %s' % session['r'])
return redirect(
url_for('oauth2callback', _scheme='https', _external=True))
def team_edit_user(pid, tid):
''' Team edit user '''
# pylint: disable=too-many-locals,too-many-return-statements,too-many-branches,too-many-statements
team, project, _redirect = check_the_team_and_project_are_existed(pid=pid,
tid=tid)
if _redirect:
return _redirect
is_admin = (g.user['account']['_id'] in team['chiefs']
or g.user['account']['_id'] in team['owners']
or g.user['account']['_id'] in project['owners'])
if not is_admin:
return redirect('/')
if request.method == 'GET':
waitting_list = list(WaitList.list_by_team(pid=pid, tid=tid))
uids = [u['uid'] for u in waitting_list]
users_info = User.get_info(uids)
for user in waitting_list:
user['_info'] = users_info[user['uid']]
user['_history'] = []
for wait_info in WaitList.find_history(pid=pid, uid=user['uid']):
if 'result' not in wait_info:
wait_info['result'] = 'waitting'
user['_history'].append(wait_info)
user['_mail'] = User(uid=user['uid']).get()['mail']
return render_template('./team_edit_user.html',
project=project,
team=team,
waitting_list=waitting_list)
if request.method == 'POST':
data = request.json
if data['case'] == 'deluser':
Team.update_members(pid=pid, tid=tid, del_uids=[
data['uid'],
])
elif data['case'] == 'history':
history = []
for raw in WaitList.find_history_in_team(uid=data['uid'],
pid=pid,
tid=tid):
raw['_id'] = str(raw['_id'])
history.append(raw)
return jsonify({'history': history})
elif data['case'] == 'members':
result_members = []
if team['members'] or team['chiefs']:
_all_uids = set(team['chiefs']) | set(team['members'])
users_info = User.get_info(list(_all_uids))
for uid in _all_uids:
result_members.append(users_info[uid])
for user in result_members:
user['chat'] = {}
mid = MattermostTools.find_possible_mid(uid=user['_id'])
if mid:
user['chat'] = {
'mid': mid,
'name': MattermostTools.find_user_name(mid=mid)
}
user['phone'] = {'country_code': '', 'phone': ''}
if 'phone' in user['profile_real'] and user[
'profile_real']['phone']:
phone = phonenumbers.parse(
user['profile_real']['phone'])
user['phone']['country_code'] = phonenumbers.COUNTRY_CODE_TO_REGION_CODE[phone.country_code][0] # pylint: disable=line-too-long
user['phone']['phone'] = phonenumbers.format_number(
phone, phonenumbers.PhoneNumberFormat.NATIONAL)
result_members = sorted(
result_members, key=lambda u: u['profile']['badge_name'])
return jsonify({
'members':
result_members,
'tags':
team.get('tag_members', []),
'members_tags':
Team.get_members_tags(pid=pid, tid=tid),
})
elif data['case'] == 'add_tag':
result = Team.add_tag_member(pid=pid,
tid=tid,
tag_name=data['tag_name'])
return jsonify({'tag': result})
elif data['case'] == 'update_member_tags':
team_tags = [i['id'] for i in team.get('tag_members', [])]
team_members = set(team['members'] + team['chiefs'])
tag_datas = {}
for uid in team_members:
if uid in data['data']:
tag_datas[uid] = {
'tags': list(set(team_tags) & set(data['data'][uid]))
}
if tag_datas:
Team.add_tags_to_members(pid=pid, tid=tid, data=tag_datas)
return jsonify({'data': tag_datas})
elif data['case'] == 'del_tag':
Team.del_tag(pid=pid, tid=tid, tag_id=data['tag']['id'])
return jsonify({})
return jsonify(data)
return jsonify({})