def test(loop):
yield from orm.create_pool(loop=loop, user='******', password='******', db='awesome')
u = User(name='Test', email='*****@*****.**', passwd='1234567890', image='about:blank')
yield from u.save()
def login():
"""Handle login response from hunch"""
key = request.args.get('auth_token_key')
user_id = request.args.get('user_id')
user = User(user_id=user_id, auth_token_key=key)
user.put()
return render_template('login.html',key=key, userid=user_id)
def get(self):
user = users.get_current_user()
if user:
subscriptions = CompanySubscription.all()
logoutUrl = users.create_logout_url("/")
appUser = User.all()\
.filter('openid =', user.federated_identity()).get()
if appUser == None:
appUser = User.all()\
.filter('email =', user.email()).get()
if appUser:
sub = appUser.subscription
appUsers = User.all().filter('subscription = ', sub)
template_values = { 'appUser' : appUser, \
'companyName' : sub.name, \
'edition' : sub.edition, \
'appUsers' : appUsers, \
'logoutUrl' : logoutUrl }
path = os.path.join(os.path.dirname(__file__), 'index.html')
self.response.out.write(template.render(path, template_values))
else:
# Send the user to AppDirect to purchase the app
self.redirect(appDirectLink)
else:
# Log this user in
self.redirect(users.create_login_url("https://www.appdirect.com/openid/id"))
def test(loop):
logging.error('1111111')
yield from orm.create_pool(loop=loop,user='******',password='******',db='pyblog')
logging.error('2222222')
u=User(name='Test',email='*****@*****.**',passwd='1234567890',image='blank')
logging.error('333333')
yield from u.save()
def after_login(resp):
if resp.email is None or resp.email == "":
flash('Invalid login. Please try again.')
redirect(url_for('login'))
user = User.query.filter_by(email = resp.email).first()
if user is None:
nickname = resp.nickname
if nickname is None or nickname == "":
nickname = resp.email.split('@')[0]
nickname = User.make_unique_nickname(nickname)
user = User(nickname = nickname, email = resp.email, role = ROLE_USER)
models.session.add(user)
models.session.commit()
models.session.add(user.follow(user))
models.session.commit()
remember_me = False
if 'remember_me' in session:
remember_me = session['remember_me']
session.pop('remember_me', None)
login_user(user, remember = remember_me)
return redirect(request.args.get('next') or url_for('demo'))
remember_me = False
if 'remember_me' in session:
remember_me = session['remember_me']
session.pop('remember_me', None)
login_user(user, remember = remember_me)
return redirect(request.args.get('next') or url_for('demo'))
def get_or_create_user():
user = users.get_current_user()
u = User.get_user(user)
if not u and users.is_current_user_admin():
u = User(user=user, role='admin')
u.put()
return u
def get_user_ranking(self, request):
"""Inefficient way to find ranking, for the user request
find the user and then compare win ratio with other users
if win ratio is equal, compare the number of losses"""
user = User.query(User.name == request.user_name).get()
if not user:
raise endpoints.NotFoundException(
'A User with the name {} does not exist!'.format(request.user_name))
users = User.query(User.name != request.user_name)
losses = user.losses
wins = user.wins
win_ratio = user.win_ratio
ranking = 0
total_users = 1
for other_user in users:
total_users = total_users + 1
if other_user.win_ratio < win_ratio:
ranking = ranking - 1
elif other_user.win_ratio == win_ratio:
if other_user.losses >= losses:
ranking = ranking - 1
ranking = total_users + ranking
#Create a ranking message
msg = "User {} Ranking {} Win Ratio {}".format(user.name, ranking, win_ratio)
return StringMessage(message = msg)
def register_user():
i = ctx.request.input(name="", email="", password="")
name = i.name.strip()
email = i.email.strip()
password = i.password
if not name:
raise APIValueError("name")
if not email or not _RE_EMAIL.match(email):
raise APIValueError("email")
if not password or not _RE_MD5.match(password):
raise APIValueError("password")
user = User.find_first("where email=?", email)
if user:
raise APIError("register:failed", "email", "Email is already in use.")
user = User(
name=name,
email=email,
password=password,
image="http://www.gravatar.com/avatar/%s?d=mm&s=120" % hashlib.md5(email).hexdigest(),
)
user.insert()
# make session cookie:
cookie = make_signed_cookie(user.id, user.password, None)
ctx.response.set_cookie(_COOKIE_NAME, cookie)
return user
def api_get_users():
total = User.count_all()
page = Page(total, _get_page_index())
users = User.find_by("order by created_at desc limit ?,?", page.offset, page.limit)
for u in users:
u.password = "******"
return dict(users=users, page=page)
def intermediate():
name = request.form['name']
email = request.form['email']
description = request.form['user_description']
user = User(name, email, description)
user.start()
return render_template("continue.html", user=user)
def add_user():
mobile = request.form.get('mobile')
username = request.form.get('username')
password = request.form.get('password')
u = User({'mobile': mobile, 'username': username,
'password': password})
u.upsert()
i = 0
lnames = []
while True:
login_name = request.form.get('accounts[{}][login_name]'.format(i))
login_password = request.form.get(
'accounts[{}][login_password]'.format(i))
if login_name and login_password:
a = Account({'user_id': u._id,
'login_name': login_name,
'login_password': login_password})
a.upsert()
lnames.append(login_name)
i += 1
else:
break
Account.delete_many({'user_id': u._id,
'login_name': {'$nin': lnames}})
return jsonify(status=200)
async def api_register_user(*, email, name, passwd):
if not name or not name.strip():
raise APIValueError('name')
if not email or not _RE_EMAIL.match(email):
raise APIValueError('email')
if not passwd or not _RE_SHA1.match(passwd):
raise APIValueError('password')
users = await User.findAll('email=?', [email])
if len(users) > 0:
raise APIError('register failed', 'email', 'Email is already in use')
uid = next_id()
sha1_passwd = '%s:%s' % (uid, passwd)
passwd = hashlib.sha1(sha1_passwd.encode('utf-8')).hexdigest()
image = 'http://www.gravatar.com/avatar/%s?d=mm&s=120' % hashlib.md5(
email.encode('utf-8')).hexdigest()
user = User(uid=uid,
name=name.strip(),
email=email,
passwd=passwd,
image=image)
await user.save()
# make session in cookie
r = web.Response()
r.set_cookie(COOKIE_NAME,
user2cookie(user, 86400),
max_age=86400,
httponly=True)
user.passwd = '********'
r.content_type = 'application/json'
r.body = json.dumps(user, ensure_ascii=False).encode('utf-8')
return r
def __call__(self, form, field):
try:
User.get(User.email == field.data)
except Exception:
pass
else:
raise ValidationError('User with this email already exists')
def welcoming_task(message):
chat_id = message.chat.id
new_members_names = []
new_members_info = []
users = []
for member in message.new_chat_members:
new_members_names.append(member.first_name)
new_members_info.append(user_info(member))
if not member.is_bot:
user = {
'user_id' : member.id,
'chat_id' : chat_id,
'first_name': member.first_name,
'last_name' : member.last_name,
'is_member' : True
}
users.append(user)
if users: # Bot check
with db.atomic():
User.insert_many(users).on_conflict_replace().execute()
if str(message.chat.id) == config.mm_chat:
welcoming_msg = "{}, {}!\nЕсли здесь впервые, то ознакомься с правилами — /rules, " \
"и представься, если несложно.".format(random.choice(config.welcome_list),
', '.join(new_members_names))
else:
welcoming_msg = "{}, {}!\n".format(random.choice(config.welcome_list), ', '.join(new_members_names))
my_bot.reply_to(message, welcoming_msg)
action_log("User(s) {} joined the chat.".format(', '.join(new_members_info)))
def session_from_facebook():
"""
uses the facebook session cookie to create a site specific session.
it will also fetch profile information from facebook and add
the user to the datastore if it does not exist yet
"""
import facebook
# get facebook user id and token from facebook cookie
fb_user = facebook.get_user_from_cookie(request.cookies,
app.config['FACEBOOK_APPLICATION_ID'],
app.config['FACEBOOK_APPLICATION_SECRET'])
if fb_user:
# check whether the user is already in the datastoreg
user = User.all().filter('facebook_id =', str(fb_user['uid'])).get()
if user is None:
# if not we fetch his profile information via the facebook graph api
graph = facebook.GraphAPI(fb_user["access_token"])
profile = graph.get_object("me")
# now we can put the user in the datastore
user = User(key_name=generate_key(),
facebook_id=str(profile['id']),
facebook_token=request.values.get('access_token'),
email=profile['email'],
name=profile['name'])
user.save()
# last but not least we add the user's key to the session cookie
session['user_key'] = user.key().name()
return "ok"
def view_register(request):
#registerform = RegisterForm()
error = None
vista = "register"
if request.POST:
#registerform = RegisterForm(request.POST)
#if registerform.is_valid():
nombre = request.POST.get('nombre', -1)
apellidos = request.POST.get("apellidos", -1)
email = request.POST.get("email", -1)
profiles = Profile.objects.all()
passw = request.POST.get("password", -1)
repassw = request.POST.get("repassw", -1)
if repassw == passw and email != -1 and apellidos != -1 and nombre != -1:
u = User(username=nombre, first_name=nombre, last_name=apellidos, email=email)
u.set_password(repassw)
u.save()
Client.objects.create(user=u, profile=profiles[0])
request.session['registrado'] = True
return redirect(to="/register")
else:
if repassw == passw:
error = "los password no son iguales"
else:
error = "Falta insertar datos"
mostrar = 0
if request.session.get('registrado'):
mostrar = 1
del request.session['registrado']
print error
return render_to_response("desktop/inicio.html", {"error": error, 'mostrar': mostrar, 'vista': vista},
context_instance=RequestContext(request))
def after_login(resp):
if resp.identity_url is None or resp.identity_url == "":
flash(_('Invalid login. Please try again'))
return redirect(url_for('login'))
user = User.query.filter_by(identity_url = resp.identity_url).first()
if user is None:
nickname = resp.nickname
email = resp.email
if nickname is None or nickname == "":
if email is None or email == "":
nickname = resp.identity_url.strip("/").split("/")[-1]
else:
nickname = resp.email.split('@')[0]
nickname = User.make_unique_nickname(nickname)
user = User(identity_url = resp.identity_url, nickname = nickname, email = resp.email, role = ROLE_USER)
db.session.add(user)
db.session.commit()
# make the user follow him/herself
db.session.add(user.follow(user))
db.session.commit()
remember_me = False
if 'remember_me' in session:
remember_me = session['remember_me']
session.pop('remember_me', None)
login_user(user, remember = remember_me)
return redirect(request.args.get('next') or url_for('index'))
def api_register_user(*, email, name, passwd):
#检查注册信息合法性
if not name or not name.strip():
raise APIValueError('name')
if not email or not _RE_EMAIL.match(email):
raise APIValueError('email')
if not passwd or not _RE_SHA1.match(passwd):
raise APIValueError('passwd')
#根据email查找用户是否已存在
users = yield from User.findAll('email=?', [email])
if len(users) > 0:
raise APIError('register:failed', 'email', '该邮箱已被注册')
#若注册信息合法，生成唯一id
uid = next_id()
#对密码进行加密后，将用户信息存入数据库
sha1_passwd = '%s:%s' % (uid, passwd)
user = User(id=uid, name=name.strip(), email=email, passwd=hashlib.sha1(sha1_passwd.encode('utf-8')).hexdigest(), image='http://www.gravatar.com/avatar/%s?d=mm&s=120' % hashlib.md5(email.encode('utf-8')).hexdigest())
yield from user.save()
r = web.Response()
#设置cookie
r.set_cookie(COOKIE_NAME, user2cookie(user, 86400), max_age=86400, httponly=True)
user.passed = '******'
r.content_type = 'application/json'
#返回json数据，ensure_ascii=False，即非ASCII字符将保持原样，不进行转义
r.body = json.dumps(user, ensure_ascii=False).encode('utf-8')
return r
def pull_profile_from_node(node_id):
"""Pull the user profile from the given node id
Only update the user if data has changed."""
print "pull_profile_from_node %d" % node_id
save = False # Flag to save user
node = None
try:
node = Node.objects.get(pk=node_id)
except Node.DoesNotExist:
# TODO: ERROR LOG FILE
print "Node does not exist!!!"
return
user = None
try:
user = User.objects.get(node=node)
except User.DoesNotExist:
print "We don't have a user for the node..."
user = User() # We may not yet have a user for the node (rare)
save = True
# Perform communications
message = SylphMessage(node.uri)
message.set_post('dispatch', 'user_pull')
response = send(message)
if response.has_errors():
print "No communication return data!!" # TODO: Error log
node.just_failed(save=True)
return
try:
user_data = response.extract('User')
if not user_data or len(user_data) != 1:
raise Exception, "Error with data"
user_data = user_data[0]
except Exception:
print "No user data, or error. Ignoring."
node.just_failed(save=True)
return
node.just_pulled_from(save=True)
for k, v in user_data.iteritems():
chk = getattr(user, k)
if v == chk:
continue
if k == 'node':
if v == node.pk:
continue
# XXX: The following could be used to hijack other users
user.node = node # TODO: This isn't correct.
save = True
continue
save = True
setattr(user, k, v) # TODO: Might not work for 'uri' or 'node'
if save:
user.save()
def login():
if g.user is not None and g.user.is_authenticated():
return redirect(url_for('index'))
form_l = LoginForm()
form_s = SignUpForm()
if form_l.validate_on_submit() and (len(form_l.openid.data) < 100) and (len(form_l.password.data) < 100):
session['remember_me'] = form_l.remember_me.data
user = db.session.query(User).filter(User.email == form_l.openid.data).filter(User.password == md5(form_l.password.data).hexdigest()).first()
if user is not None:
login_user(user, remember = form_l.remember_me.data)
return redirect(url_for('index'))
else:
print("NOT FOUND")
if form_s.validate_on_submit() and (len(form_s.email.data) < 100) and (len(form_s.login.data) < 50) and (len(form_s.password.data) < 100):
k = False
user = db.session.query(User).filter(User.email == form_s.email.data or User.nickname == form_s.login.data).first()
if user is None:
u = User(nickname=form_s.login.data, email=form_s.email.data, password=md5(form_s.password.data).hexdigest())
db.session.add(u)
db.session.commit()
db.session.add(u.follow(u))
db.session.commit()
login_user(u)
return redirect(url_for('index'))
else:
print("EXISTS")
return render_template('login1.html',
form_l = form_l,
form_s = form_s)
def post(self):
active_subs = Subscription.get_active_subscriptions()
items = json.loads(self.request.get('items'))
logging.debug('before parsing, memory: %s' % runtime.memory_usage().current())
parser = RentParser()
parsed_items = []
for item in items:
try:
parsed = parser.parse(item)
ret = RentRecord.add_record(parsed)
except Exception as e:
logging.error(repr(e))
parsed_items.append(parsed)
logging.debug('after parsing, memory: %s' % runtime.memory_usage().current())
user2message = filter_items(parsed_items, active_subs)
for user, item in user2message.items():
logging.debug('user: %s has %d messages' % (user, len(item)))
User.update_user_items(user, item)
url = get_short_url(user)
if not url:
url = site_config.url + '?user=%s' % user
msg = [u'新找到%d条租房信息。' % len(item),
u'点击以下链接查看：',
url]
messenger.send_message(user, '\n'.join(msg))
def test_delete(self):
self.create_data(4, table=1)
assert User.at(1).delete().execute() == 1
assert User.where(
(User.name == 'name1') | (User.name == 'name2')
).delete().execute() == 1
assert User.count() == 2
def chat():
# Require login
if 'username' not in session:
return redirect('/login/')
# Get chat buddy
name_them = request.args.get('user', None)
user_them = None
if name_them:
try:
user_them = User.get(User.username == name_them)
except:
pass
# Bad user - add error
if not user_them:
if name_them:
errors = ["Could not find user %s." % name_them]
else:
errors = ["Please specify a user to chat with."]
return render_template('chat.html', data={'errors': errors});
# Chat avatars
user_you = User.get(User.username == session['username'])
return render_template('chat.html', data={'yourPic': user_you.imageUrl, 'theirPic': user_you.imageUrl, 'otherUsername': name_them, 'myLanguage': user_you.language })
def add_interests(user_id, interests):
logger.warning('add_interests user_id:%s interests:%s' % (user_id, str(interests)))
user = User.get_by_id(user_id)
for interest in interests:
if not interest:
continue
if interest not in user.get('interests', []):
User.push_user_field(user_id, 'interests', interest)
network = user.get('network')
interest = interest.strip('#').lower()
interest_data = Interest.get_by_name_network(interest, network)
int_col = get_interest_collection()
if not interest_data:
#Add a new one
interest_data = {
'name' : interest,
'num_followers' : 1,
'followers' : [user_id],
'network' : network,
'created' : datetime.datetime.now(),
'creator' : user_id
}
user_id = int_col.insert(interest_data)
else:
#Update existing
# push={}
# updates = {}
followers = interest_data.get('followers')
if user_id not in followers:
updates = {"$push" : {'followers' : user_id}, "$set" : { "num_followers" : len(followers) + 1 }}
int_col.update({"name" : interest}, updates)
def create_new_user_activation(user_id):
"""
Called when a new user is added to system, sets up activation and emails link to user
Not part of tasks.new_user as that's notification based and will probably be refactored into a separate file soon
"""
logger.warning('Starting user activation process for %s' % str(user_id))
user = User.objects.get(_id = user_id)
random_phrase = activation_phrases[randint(0, len(activation_phrases)-1)]
#Generate random user activation hash
activation_hash = User.create_activation_hash(user._id, randint(0,1000))
User.set_user_field(user_id, 'activation_hash', activation_hash)
if user.email in settings.SKIP_VALIDATION_ADDRESSES:
user.activated = True
User.set_user_field(user_id, 'activated', True)
return "Email validation skipped for %s" % user._id
url = 'http://keen.to/activate-%s-%s' % (random_phrase, activation_hash)
name = user.first_name
if not name:
name = user.name
logger.warning('Sending email to %s' % str(user_id))
send_activation(name, user.email, url)
logger.warning('Email sent to %s' % str(user_id))
return "Email sent to %s" % user._id
def sign_up():
_name = request.form['inputName']
_user_name = request.form['inputUserName']
_password = request.form['inputPassword']
username_list = g.sql_session.query(User.username).all()
if (_user_name,) not in username_list:
user = User()
user.name = _name
user.username = _user_name
user.password = generate_password_hash(_password)
user.type = 1
g.sql_session.add(user)
try:
g.sql_session.commit()
except Exception as e:
flash(str(e))
g.sql_session.rollback()
return redirect(url_for('.show_sign_up'))
session['user'] = _user_name
session['name'] = _name
session['type'] = user.type
return redirect(url_for('.user_home'))
else:
flash("The duplicated username")
return redirect(url_for('.show_sign_up'))
def after_login(resp):
if resp.email is None or resp.email == "":
flash('Invalid login. Please try again.')
return redirect(url_for('login'))
user = User.query.filter_by(email=resp.email).first()
if user is None:
nickname = resp.nickname
if nickname is None or nickname == "":
nickname = resp.email.split('@')[0]
nickname = User.make_unique_nickname(nickname)
user = User(nickname=nickname, email=resp.email, role=ROLE_USER)
db.session.add(user)
db.session.commit()
# make the user follow him/herself
db.session.add(user.follow(user))
db.session.commit()
remember_me = False
if 'remember_me' in session:
remember_me = session['remember_me']
session.pop('remember_me', None)
login_user(user, remember=remember_me)
return redirect(url_for('user', nickname=user.nickname))
def get(self, boker_id):
boker = Boker.get_by_id(int(boker_id))
if boker:
deferred.defer(update_num_view, str(boker.key()))
# Check post type, Video or Photo
if boker.video_id and boker.video_source:
self.template = 'video.html'
if self.current_user is not None:
user = User.get_by_key_name(self.current_user['id'])
can_like = not Like.already_like(user, boker)
else:
can_like = False
else:
active_contest = Contest.active_contest()
if active_contest:
is_nominee = Contest.is_nominee(boker)
if self.current_user is not None:
user = User.get_by_key_name(self.current_user['id'])
can_vote = not Vote.already_vote(user)
can_like = not Like.already_like(user, boker)
else:
can_vote = False
can_like = False
querystring = self.request.GET
return self.render_response(self.template, locals())
else:
self.abort(404)
def new_user():
u = User()
u.from_json(request.json)
print request.json
db.session.add(u)
db.session.commit()
return jsonify({})
def test_limit(self):
self.create_data(10)
query = User.limit(4).select()
results = query.execute()
assert results.count == 4
assert len(tuple(User.limit(9, offset=1).getall())) is 9
assert len(tuple(User.limit(100, offset=9).getall())) is 1
def test_invalid_username(self):
self.assertFalse(User.authenticate("badusername", "password"))
def add_user_controller(data=None, cls=True):
render_template(context={}, template="add_user.jinja2", cls=cls)
username = input()
user = User.add(username)
return 21, user # (next state, data)
def load_user(uid):
res = User.get_by_id(db, uid)
if res == None:
return None
newuser = User(res['uid'], res['first_name'], res['last_name'])
return newuser
# -*- coding: utf-8 -*-
from database import init_db, db_session
from models import User, Group, Location, Event
from werkzeug import generate_password_hash
import datetime
init_db()
session = db_session()
user = User(username='******',
first_name='Martin',
last_name='Czygan',
dob=datetime.datetime(1979, 4, 29),
email='*****@*****.**',
identifier_id='0000',
city='Leipzig',
country='DEU',
zipcode='04277',
street='Brandstr. 15',
password=generate_password_hash('dev'))
group = Group(name='admin')
user.groups.append(group)
session.add(user)
session.add(group)
session.commit()
location = Location()
def construct_objects(replay_file, pro = False):
try:
replay = sc2reader.load_replay(replay_file)
game = db.session.query(Game).filter_by(name = str(replay.date) + '_' + replay.players[0].play_race + ' v ' + replay.players[1].play_race + '_' + replay.players[0].name + ' v ' + replay.players[1].name).first()
if game != None:
#print('Game already exists: ', game)
return None
game = Game(name = str(replay.date) + '_' + replay.players[0].play_race + ' v ' + replay.players[1].play_race + '_' + replay.players[0].name + ' v ' + replay.players[1].name,
map = replay.map_name,
game_winner = replay.winner.players[0].name,
start_time = replay.start_time,
end_time = replay.end_time,
category = replay.category,
expansion = replay.expansion,
time_zone = replay.time_zone
)
userOne = db.session.query(User).filter_by(name = replay.players[0].name).first()
userTwo = db.session.query(User).filter_by(name = replay.players[1].name).first()
if userOne == None:
userOne = User(name = replay.players[0].name, region = replay.players[0].region, subregion = replay.players[0].subregion)
if userTwo == None:
userTwo = User(name = replay.players[1].name, region = replay.players[1].region, subregion = replay.players[1].subregion)
users = [userOne, userTwo]
if replay.players[0].is_human:
highest_league_playerOne = replay.players[0].highest_league
avg_apm_playerOne = replay.players[0].avg_apm
if pro:
highest_league_playerOne = 20
else:
highest_league_playerOne = -1
avg_apm_playerOne = -1
if replay.players[1].is_human:
highest_league_playerTwo = replay.players[1].highest_league
avg_apm_playerTwo = replay.players[1].avg_apm
if pro:
highest_league_playerTwo = 20
else:
highest_league_playerTwo = -1
avg_apm_playerTwo = -1
participantOne = Participant(user = [users[0]],
game = [game],
name = userOne.name,
league = highest_league_playerOne,
scaled_rating = replay.raw_data['replay.initData']['user_initial_data'][0]['scaled_rating'],
playrace = replay.players[0].play_race,
avg_apm = avg_apm_playerOne,
winner = userOne.name == replay.winner.players[0].name
)
participantTwo = Participant(user = [users[1]],
game = [game],
name = userTwo.name,
league = highest_league_playerTwo,
scaled_rating = replay.raw_data['replay.initData']['user_initial_data'][1]['scaled_rating'],
playrace = replay.players[0].play_race,
avg_apm = avg_apm_playerTwo,
winner = userTwo.name == replay.winner.players[0].name
)
participants = [participantOne, participantTwo]
events = replay.events
participantOne_events = []
participantTwo_events = []
for event in events:
try:
if event.name == 'PlayerStatsEvent':
if event.player.name == participants[0].name:
participantOne_events.append(PlayerStatsEvent(participant = participants[0],
name = event.name,
second = event.second,
minerals_current = event.minerals_current,
vespene_current = event.vespene_current,
minerals_collection_rate = event.minerals_collection_rate,
vespene_collection_rate = event.vespene_collection_rate,
workers_active_count = event.workers_active_count,
minerals_used_in_progress_army = event.minerals_used_in_progress_army,
minerals_used_in_progress_economy = event.minerals_used_in_progress_economy,
minerals_used_in_progress_technology = event.minerals_used_in_progress_technology,
minerals_used_in_progress = event.minerals_used_in_progress,
vespene_used_in_progress_army = event.vespene_used_in_progress_army,
vespene_used_in_progress_economy = event.vespene_used_in_progress_economy,
vespene_used_in_progress_technology = event.vespene_used_in_progress_technology,
vespene_used_in_progress = event.vespene_used_in_progress,
resources_used_in_progress = event.resources_used_in_progress,
minerals_used_current_army = event.minerals_used_current_army,
minerals_used_current_economy = event.minerals_used_current_economy,
minerals_used_current_technology = event.minerals_used_current_technology,
minerals_used_current = event.minerals_used_current,
vespene_used_current_army = event.vespene_used_current_army,
vespene_used_current_economy = event.vespene_used_current_economy,
vespene_used_current_technology = event.vespene_used_current_technology,
vespene_used_current = event.vespene_used_current,
resources_used_current = event.resources_used_current,
minerals_lost_army = event.minerals_lost_army,
minerals_lost_economy = event.minerals_lost_economy,
minerals_lost_technology = event.minerals_lost_technology,
minerals_lost = event.minerals_lost,
vespene_lost_army = event.vespene_lost_army,
vespene_lost_economy = event.vespene_lost_economy,
vespene_lost_technology = event.vespene_lost_technology,
vespene_lost = event.vespene_lost,
resources_lost = event.resources_lost,
minerals_killed_army = event.minerals_killed_army,
minerals_killed_economy = event.minerals_killed_economy,
minerals_killed_technology = event.minerals_killed_technology,
minerals_killed = event.minerals_killed,
vespene_killed_army = event.vespene_killed_army,
vespene_killed_economy = event.vespene_killed_economy,
vespene_killed_technology = event.vespene_killed_technology,
vespene_killed = event.vespene_killed,
resources_killed = event.resources_killed,
food_used = event.food_used,
food_made = event.food_made,
minerals_used_active_forces = event.minerals_used_active_forces,
vespene_used_active_forces = event.vespene_used_active_forces,
ff_minerals_lost_army = event.ff_minerals_lost_army,
ff_minerals_lost_economy = event.ff_minerals_lost_economy,
ff_minerals_lost_technology = event.ff_minerals_lost_technology,
ff_vespene_lost_army = event.ff_vespene_lost_army,
ff_vespene_lost_economy = event.ff_vespene_lost_economy,
ff_vespene_lost_technology = event.ff_vespene_lost_technology
))
else:
participantTwo_events.append(PlayerStatsEvent(participant = participants[1],
name = event.name,
second = event.second,
minerals_current = event.minerals_current,
vespene_current = event.vespene_current,
minerals_collection_rate = event.minerals_collection_rate,
vespene_collection_rate = event.vespene_collection_rate,
workers_active_count = event.workers_active_count,
minerals_used_in_progress_army = event.minerals_used_in_progress_army,
minerals_used_in_progress_economy = event.minerals_used_in_progress_economy,
minerals_used_in_progress_technology = event.minerals_used_in_progress_technology,
minerals_used_in_progress = event.minerals_used_in_progress,
vespene_used_in_progress_army = event.vespene_used_in_progress_army,
vespene_used_in_progress_economy = event.vespene_used_in_progress_economy,
vespene_used_in_progress_technology = event.vespene_used_in_progress_technology,
vespene_used_in_progress = event.vespene_used_in_progress,
resources_used_in_progress = event.resources_used_in_progress,
minerals_used_current_army = event.minerals_used_current_army,
minerals_used_current_economy = event.minerals_used_current_economy,
minerals_used_current_technology = event.minerals_used_current_technology,
minerals_used_current = event.minerals_used_current,
vespene_used_current_army = event.vespene_used_current_army,
vespene_used_current_economy = event.vespene_used_current_economy,
vespene_used_current_technology = event.vespene_used_current_technology,
vespene_used_current = event.vespene_used_current,
resources_used_current = event.resources_used_current,
minerals_lost_army = event.minerals_lost_army,
minerals_lost_economy = event.minerals_lost_economy,
minerals_lost_technology = event.minerals_lost_technology,
minerals_lost = event.minerals_lost,
vespene_lost_army = event.vespene_lost_army,
vespene_lost_economy = event.vespene_lost_economy,
vespene_lost_technology = event.vespene_lost_technology,
vespene_lost = event.vespene_lost,
resources_lost = event.resources_lost,
minerals_killed_army = event.minerals_killed_army,
minerals_killed_economy = event.minerals_killed_economy,
minerals_killed_technology = event.minerals_killed_technology,
minerals_killed = event.minerals_killed,
vespene_killed_army = event.vespene_killed_army,
vespene_killed_economy = event.vespene_killed_economy,
vespene_killed_technology = event.vespene_killed_technology,
vespene_killed = event.vespene_killed,
resources_killed = event.resources_killed,
food_used = event.food_used,
food_made = event.food_made,
minerals_used_active_forces = event.minerals_used_active_forces,
vespene_used_active_forces = event.vespene_used_active_forces,
ff_minerals_lost_army = event.ff_minerals_lost_army,
ff_minerals_lost_economy = event.ff_minerals_lost_economy,
ff_minerals_lost_technology = event.ff_minerals_lost_technology,
ff_vespene_lost_army = event.ff_vespene_lost_army,
ff_vespene_lost_economy = event.ff_vespene_lost_economy,
ff_vespene_lost_technology = event.ff_vespene_lost_technology
))
elif event.name == 'UnitBornEvent':
if event.unit_controller.name == participants[0].name:
participantOne_events.append(UnitBornEvent(participant = participants[0],
name = event.name,
second = event.second,
unit_type_name = event.unit_type_name,
loc_x = event.x,
loc_y = event.y
))
else:
participantTwo_events.append(UnitBornEvent(participant = participants[1],
name = event.name,
second = event.second,
unit_type_name = event.unit_type_name,
loc_x = event.x,
loc_y = event.y
))
elif event.name == 'UnitTypeChangeEvent':
if event.unit.owner.name == participants[0].name:
participantOne_events.append(UnitTypeChangeEvent(participant = participants[0],
name = event.name,
second = event.second,
unit = event.unit.name,
unit_type_name = event.unit_type_name
))
else:
participantTwo_events.append(UnitTypeChangeEvent(participant = participants[1],
name = event.name,
second = event.second,
unit = event.unit.name,
unit_type_name = event.unit_type_name
))
elif event.name == 'UpgradeCompleteEvent':
if event.player.name == participants[0].name:
participantOne_events.append(UpgradeCompleteEvent(participant = participants[0],
name = event.name,
second = event.second,
upgrade_type_name = event.upgrade_type_name
))
else:
participantTwo_events.append(UpgradeCompleteEvent(participant = participants[1],
name = event.name,
second = event.second,
upgrade_type_name = event.upgrade_type_name
))
elif event.name == 'UnitInitEvent':
if event.unit_controller.name == participants[0].name:
participantOne_events.append(UnitInitEvent(participant = participants[0],
name = event.name,
second = event.second,
unit_type_name = event.unit_type_name,
loc_x = event.x,
loc_y = event.y
))
else:
participantOne_events.append(UnitInitEvent(participant = participants[1],
name = event.name,
second = event.second,
unit_type_name = event.unit_type_name,
loc_x = event.x,
loc_y = event.y
))
elif event.name == 'UnitDoneEvent':
if event.unit.owner.name == participants[0].name:
participantOne_events.append(UnitDoneEvent(participant = participants[0],
name = event.name,
second = event.second,
unit = event.unit.name
))
else:
participantTwo_events.append(UnitDoneEvent(participant = participants[1],
name = event.name,
second = event.second,
unit = event.unit.name
))
elif event.name == 'BasicCommandEvent':
if event.player.name == participants[0].name:
participantOne_events.append(BasicCommandEvent(participant = participants[0],
name = event.name,
second = event.second,
ability_name = event.ability_name
))
else:
participantTwo_events.append(BasicCommandEvent(participant = participants[1],
name = event.name,
second = event.second,
ability_name = event.ability_name
))
elif event.name == 'TargetPointCommandEvent':
if event.player.name == participants[0].name:
participantOne_events.append(TargetPointEvent(participant = participants[0],
name = event.name,
second = event.second,
ability_name = event.ability_name,
loc_x = event.x,
loc_y = event.y
))
else:
participantTwo_events.append(TargetPointEvent(participant = participants[1],
name = event.name,
second = event.second,
ability_name = event.ability_name,
loc_x = event.x,
loc_y = event.y
))
elif event.name == 'UnitDiedEvent':
if event.killing_player.name == participants[0].name:
# if event.killer_pid != None:
# import pdb; pdb.set_trace()
if event.killing_unit.owner.name != event.unit.owner.name:
participantOne_events.append(UnitDiedEvent(participant = participants[0],
name = event.name,
second = event.second,
killing_unit = event.killing_unit.name,
unit = event.unit.name,
loc_x = event.x,
loc_y = event.y
))
#participantOne_events.append(UnitDiedEvent(participant = [participants[0]], killing_participant = [participants[1]], name = event.name, second = event.second, killing_unit = event.killing_unit.name, unit = event.unit.name, loc_x = event.x, loc_y = event.y))
#UnitDiedEvent(participant = participants[0], killing_participant = participants[1], game = game, name = event.name, second = event.second, killing_unit = event.killing_unit.name, unit = event.unit.name, loc_x = event.x, loc_y = event.y)
else:
# if event.killer_pid != None:
# import pdb; pdb.set_trace()
if event.killing_unit.owner.name != event.unit.owner.name:
participantTwo_events.append(UnitDiedEvent(participant = participants[1],
name = event.name,
second = event.second,
killing_unit = event.killing_unit.name,
unit = event.unit.name,
loc_x = event.x,
loc_y = event.y
))
except Exception as e:
pass
#print(e, event.name)
# if event.name == 'PlayerStatsEvent':
# print(event.name, event.player)
# elif event.name == 'UnitBornEvent':
# print(participants[0].name, participants[1].name, game, event.name, event.unit_controller, event.unit_type_name, event.second, event.x, event.y)
#import pdb; pdb.set_trace()
db.session.add_all(participantOne_events + participantTwo_events + participants + [game] + users)
db.session.commit()
return [participantOne, participantTwo, userOne, userTwo, game]
except Exception as e:
pass
def play_game(self, request):
"""Play move in a Game. A move of 'True' corresponds to defecting and
'False' corresponds to staying silent."""
scope = 'https://www.googleapis.com/auth/userinfo.email'
oauth_user = oauth.get_current_user(scope)
# Verify inputs and game state
game = get_by_urlsafe(request.game_key, Game)
if not game:
raise endpoints.ConflictException(
'Cannot find game with key {}'.format(request.game_key))
if not game.is_active:
raise endpoints.ConflictException('Game has already finished')
player = User.query(User.name == request.player_name).get()
if not player:
raise endpoints.ConflictException(
'No user named {} exists!'.format(request.player_name))
if not player.email == oauth_user.email():
raise endpoints.ConflictException(
'You are not authorized to play for {}!'.format(
request.player_name))
# Save single player's move
match = game.key.parent().get()
if match.player_1_name == request.player_name:
game.player_1_move = request.move
elif match.player_2_name == request.player_name:
game.player_2_move = request.move
else:
raise endpoints.ConflictException('Player {} is not playing in '
'game {}'.format(
request.player_name,
request.game_key))
game.put()
# Evaluate result and update Game and Match if game has finished
if game.player_1_move is not None \
and game.player_2_move is not None:
if game.player_1_move:
if game.player_2_move:
p1_penalty, p2_penalty = 2, 2
else:
p1_penalty, p2_penalty = 0, 3
else:
if game.player_2_move:
p1_penalty, p2_penalty = 3, 0
else:
p1_penalty, p2_penalty = 1, 1
game.result = 'Game result: {}:{} years, {}:{} years.'.format(
match.player_1_name, p1_penalty, match.player_2_name,
p2_penalty)
game.is_active = False
game.put()
match.player_1_penalty += p1_penalty
match.player_2_penalty += p2_penalty
match.games_remaining -= 1
match.put()
# Update Match and Users if match has finished
if match.games_remaining < 1:
match.is_active = False
match.put()
if match.player_1_penalty != match.player_2_penalty: # if not draw
if match.player_1_penalty < match.player_2_penalty:
winner_name = match.player_1_name
loser_name = match.player_2_name
else:
winner_name = match.player_2_name
loser_name = match.player_1_name
winner = User.query(User.name == winner_name).get()
loser = User.query(User.name == loser_name).get()
winner.score += 1
loser.score -= 1
winner.put()
loser.put()
match_result = 'Match finished. Winner:{}, Loser:{}.'.format(
winner_name, loser_name)
else:
match_result = 'Match still in progress.'
return StringMessage(
message='Registered player {}\'s play of {} in '
'game {}. {} {}'.format(request.player_name, request.move, request.
game_key, game.result, match_result))
def test_wrong_password(self):
self.assertFalse(User.authenticate(self.u1.username, "badpassword"))
def test_invalid_password_signup(self):
with self.assertRaises(ValueError) as context:
User.signup("testtest", "*****@*****.**", "", None)
with self.assertRaises(ValueError) as context:
User.signup("testtest", "*****@*****.**", None, None)
def test_invalid_username_signup(self):
invalid = User.signup(None, "*****@*****.**", "password", None)
uid = 123456789
invalid.id = uid
with self.assertRaises(exc.IntegrityError) as context:
db.session.commit()
def test_valid_authentication(self):
u = User.authenticate(self.u1.username, "password")
self.assertIsNotNone(u)
self.assertEqual(u.id, self.uid1)
def test_full_name(self):
user = User(first_name="Bob", last_name="Smith")
name = user.full_name()
self.assertEqual(name, "Bob Smith")
def test_invalid_email_signup(self):
invalid = User.signup("testtest", None, "password", None)
uid = 123789
invalid.id = uid
with self.assertRaises(exc.IntegrityError) as context:
db.session.commit()
from models import User, Ldap
import csv
with open('users.csv', 'rb') as f:
rows = list(csv.reader(f))
for r in rows:
user = User()
user.nome = r[0]
user.sobrenome = r[1]
user.email = r[2]
user.passwd = Ldap.pass_generate()
userldap = Ldap()
userldap.insert(user)
user.save()
def test_good_user(self):
""" Test case for good username """
user = User.authenticate(self.username, self.password)
self.assertIsNotNone(user)
self.assertEqual(user.username, self.username)
def initDB(self):
self.clearDB()
admin_character = Character(
id=1000,
user_id=1000,
name='Admin Alice',
corporation_id=self.ascee_corp_id,
)
db.session.add(admin_character)
self.admin = User.get(1000)
admin = Admin(
id=1000,
)
db.session.add(admin)
senior_recruiter_character = Character(
id=1001,
user_id=1001,
name='Senior Sam',
corporation_id=self.ascee_corp_id,
)
db.session.add(senior_recruiter_character)
self.senior_recruiter = User.get(1001)
senior_recruiter = Recruiter(
id=1001,
is_senior=True,
)
db.session.add(senior_recruiter)
recruiter_character = Character(
id=1002,
user_id=1002,
name='Recruiter Randy',
corporation_id=self.ascee_corp_id,
)
db.session.add(recruiter_character)
self.recruiter = User.get(1002)
recruiter = Recruiter(
id=1002,
)
db.session.add(recruiter)
other_recruiter_character = Character(
id=1003,
user_id=1003,
name='OtherRecruiter Oswald',
corporation_id=self.ascee_corp_id,
)
db.session.add(other_recruiter_character)
self.other_recruiter = User.get(1003)
db.session.add(self.other_recruiter)
other_recruiter = Recruiter(
id=1003,
)
db.session.add(other_recruiter)
db.session.commit()
test_applicant_id = 2114496483
self.applicant_character = Character.get(
test_applicant_id,
)
self.applicant_character.user_id = test_applicant_id
self.applicant_character.refresh_token = 'GCe-dZ58iNCRfX2sXf9DcGiP0T-ig8kyIHjr6vK9zHwfL3ij8R0emIuuy2m-gqHPGB_rn5CVUBTv8uhgmN9Tkvmnjp3uOPihHmOlfAqwooN-xbJTmR8w7wWOAhcvCRK62wm6mYMRaz2tI0--a65jeV4OKNxRYFUDiMvM-YMvF6D8AHTr8N9Gl5uCSsgXAz66ewrX7hega5DRGYlOlyFZZmpZRCX8l095aDBDk_GXwljRD4o4FoRfesc6DGsyQ3MUuxlbkwuJbeiyJxWjBkaCgLQEiJkLJf35NMclkU14EEy8nDwf4zjg1ZqXlUAxcjV7DosWh9nZU33_cmKTmKkD8apD3Ozsq5QSjji0TWzZA3Y'
self.applicant_character.user_id = test_applicant_id
db.session.add(self.applicant_character)
self.applicant = User.get(id=test_applicant_id)
db.session.add(self.applicant)
db.session.commit()
test_not_applicant_id = 2112166943
self.not_applicant_character = Character.get(
test_not_applicant_id,
)
db.session.add(self.not_applicant_character)
self.not_applicant = User.get(id=test_not_applicant_id)
db.session.add(self.not_applicant)
db.session.commit()
self.application = Application(
user_id=self.applicant.id,
recruiter_id=self.recruiter.id,
is_submitted=True,
)
db.session.add(self.application)
db.session.commit()
self.redlisted_character_1 = Character(
id=1234,
user_id=1234,
name='Redlisted Robert',
corporation_id=self.ascee_corp_id,
redlisted=True,
)
self.redlisted_character_2 = Character(
id=4321,
user_id=4321,
name='Redlisted Rebecca',
corporation_id=self.ascee_corp_id,
redlisted=True,
)
db.session.add(self.redlisted_character_1)
db.session.add(self.redlisted_character_2)
db.session.commit()
def index(self):
users = User.objects(alive=True)
return jsonify(ok=True, objects=[u.to_json() for u in users]), 200
def name_exists(form, field):
if User.select().where(User.username == field.data).exists():
raise ValidationError('User with that name already exists.')
from models import Base, Player, Club, User
# Adding all the players to the database
engine = create_engine('postgresql://catalog@localhost/catalog_db')
Base.metadata.create_all(engine)
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
# Reading from the JSON file
users = json.load(open('epldata_users.json'))
for user in users:
try:
user_profile = User(id=user['id'],
name=user['name'],
email=user['email'],
picture=user['picture'])
session.add(user_profile)
session.commit()
except:
# User already present
session.rollback()
exisiting_user = session.query(User).filter_by(id=user['id']).first()
exisiting_user.name = user['name']
exisiting_user.email = user['email']
exisiting_user.picture = user['picture']
session.add(exisiting_user)
session.commit()
print("All users updated!")
def test_users():
users = User.find_all()
return dict(users=users)
def email_exists(form, field):
if User.select().where(User.email == field.data).exists():
raise ValidationError('User with that email already exists.')
"""Seed file for blogly""" from models import User, Post, Tag, PostTag, db from app import app # Create all tables db.drop_all() db.create_all() blues = User(first_name="Blues", last_name="Henderson", img_url="/static/default-cat.png") db.session.add(blues) db.session.commit() post1 = Post(title="I'm starting a blog",content="It's about my cat, Robot", user_id = 1) db.session.add(post1) db.session.commit() tag1 = Tag(name="cats") db.session.add(tag1) db.session.commit() post_tag1 = PostTag(post_id=1, tag_id=1) db.session.add(post_tag1)
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from models import User
engine = create_engine('sqlite:///db.sqlite3', echo=True)
Session = sessionmaker(bind=engine)
session = Session()
ed_user = User(name='ed', fullname='Ed Jones', password='******')
session.add(ed_user)
session.add_all([
User(name='wendy', fullname='Wendy Williams', password='******'),
User(name='mary', fullname='Mary Contrary', password='******'),
User(name='fred', fullname='Fred Flinstone', password='******')
])
session.commit()
# Bind the engine to the metadata of the Base class so that the
# declaratives can be accessed through a DBSession instance
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
# A DBSession() instance establishes all conversations with the database
# and represents a "staging zone" for all the objects loaded into the
# database session object. Any change made against the objects in the
# session won't be persisted into the database until you call
# session.commit(). If you're not happy about the changes, you can
# revert all of them back to the last commit by calling
# session.rollback()
session = DBSession()
#Create dummy user
user1 = User(name="First User", email="*****@*****.**")
session.add(user1)
session.commit()
# Music Category
music_category = Category(user_id=1, name="Music")
session.add(music_category)
session.commit()
# A few Items
musicItem1 = Item(
user_id=1,
name="Hall and Oates Greatest Hits",
description="Greatest Hits album featuring some of their best songs",
price="$9.99",
category=music_category)
def message_flow(update: Update, ctx: CallbackContext):
"""A handler for all messages sent by a user"""
text = update.message.text
tg_id = update.message.chat.id
user = User.get(tg_id=tg_id)
if text == NEW_MESSAGE:
ctx.bot.send_message(
chat_id=tg_id,
text='Ok. Send me a message that you want to be published\n\n'
'For text formatting you can use html tags\n\n'
'↘️',
reply_markup=ReplyKeyboardRemove()
)
user.mode = modes['creating_message']
user.save()
return
if text == EDIT_MESSAGE:
ctx.bot.send_message(
chat_id=tg_id,
text='⚙️ <b>Text editing</b>\n'
'Send me the changed text.\n\n'
'You can use html for text fromatting\n\n'
'↘️'
)
user.mode = modes['editing_message']
user.save()
return
if user.mode == modes['creating_message'] or user.mode == modes['editing_message']:
global old_message, old_message_2
# if user.mode == modes['editing_message']:
# message_id_to_delete =
# publish_id =
out_msg = make_msg(text)
r = ctx.bot.send_message(chat_id=tg_id, text=out_msg, reply_markup=reactions, parse_mode='HTML', disable_web_page_preview=True)
reply_to_message_id = update.message.message_id
# text = 'There is no old Message'
if old_message is not None:
ctx.bot.delete_message(chat_id=tg_id, message_id=old_message.message_id)
if old_message_2 is not None:
ctx.bot.delete_message(chat_id=tg_id, message_id=old_message_2.message_id)
# delete all previous records in the message database
message_id = r.message_id
# records = Message.select().where(type(message_id) == int)
# Message.delete().where(records).execute()
interface_msg = '⬆️ <b>Will be looking like that.\n\nIf you want to change the message just send me another one</b>'
tg_message = ctx.bot.send_message(chat_id=tg_id, text=interface_msg, reply_markup=send_message_markup, parse_mode='HTML', reply_to_message_id=reply_to_message_id)
old_message = tg_message
old_message_2 = r
publish_id = tg_message.message_id
# db
message = Message.create(message_id=update.message.message_id, text=text, out_msg=out_msg)
user.message = message.text
user.message_id = message_id
user.publish_id = publish_id
user.mode = modes['editing_message'] # can cause an error
user.save()
return
def get(self):
""" List all blog users """
users = User.all()
t = jinja_env.get_template("index.html")
response = t.render(users=users)
self.response.write(response)
def getAllUser():
auth_header = request.headers.get('Authorization')
if auth_header:
try:
auth_token = auth_header.split(" ")[1]
except IndexError as identifier:
responseObject = {
'status': 'failed',
'message': 'Beared token malformed'
}
return make_response(jsonify(make_response)), 401
else:
auth_token = ''
responseObject = {'message': 'Token is missing'}
return make_response(jsonify(responseObject)), 404
if auth_token:
try:
resp = User.decode_auth_token(auth_token)
print('resp : ' + resp)
except Exception as identifier:
error = traceback.format_exc()
print(error)
return jsonify({error}), 500
user = db.session.query(User).filter_by(
public_id=resp,
status=5).filter(User.instituition_id == None).first()
if not user:
return jsonify({'message': resp, 'resp': resp}), 422
user_type, = db.session.query(
Usertype.public_id).filter_by(public_id=user.user_type).first()
first_name, = db.session.query(
User.first_name).filter_by(public_id=user.session_id).first()
last_name, = db.session.query(
User.last_name).filter_by(public_id=user.session_id).first()
registered_by = first_name + " " + last_name
#check if the usertype is assigned that feature
allowed = db.session.query(FeatureRole).filter_by(
role_public_id=user.user_type,
feature_public_id='7fc6f0e7').filter(
FeatureRole.deletion_marker == None).first()
if allowed:
users = db.session.query(User).filter(
User.deletion_marker == None).order_by(
User.created_at.desc()).all()
users_array = []
for user in users:
response = {}
user_role, = db.session.query(
Usertype.name).filter_by(public_id=user.user_type).first()
response['public_id'] = user.public_id
response['full_name'] = user.first_name.strip().title(
) + " " + user.last_name.strip().title()
response['phone_number'] = user.phone_number
response['email'] = user.email
response['user_type'] = user_role
response['registered_by'] = registered_by
response['user_type_id'] = user.user_type
response['user_role'] = user_role
response['registered_on'] = user.created_at
response['active_status'] = 'Suspended' if int(
user.status) == 15 else 'Active'
users_array.append(response)
responseObject = {'data': users_array}
return make_response(jsonify(responseObject)), 200
else:
responseObject = {
'message':
'invalid permissions to view this page {0}'.format(user_type)
}
return make_response(jsonify(responseObject)), 403
else:
responseObject = {'status': 'fail', 'message': resp}
return make_response(jsonify(responseObject)), 401
def createUser(login_session):
newUser = User(email=login_session['email'])
session.add(newUser)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
return user.id
def create_user(self, name, email, password):
new_user = User(name=name, email=email, password=password)
db.session.add(new_user)
db.session.commit()
def new_user(username, password):
user = User(username=username, password=password, role=USER_ROLES['user'])
db.session.add(user)
db.session.commit()
return user
# Bind the engine to the metadata of the Base class so that the
# declaratives can be accessed through a DBSession instance
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
# A DBSession() instance establishes all conversations with the database
# and represents a "staging zone" for all the objects loaded into the
# database session object. Any change made against the objects in the
# session won't be persisted into the database until you call
# session.commit(). If you're not happy about the changes, you can
# revert all of them back to the last commit by calling
# session.rollback()
session = DBSession()
# Create dummy user
User1 = User(username="******", email="*****@*****.**")
User2 = User(username="******", email="*****@*****.**")
User3 = User(username="******", email="*****@*****.**")
session.add(User1)
session.add(User2)
session.add(User3)
# Create dummy user's blogs
Blog1 = Blog(user_id=2,
blog_name="dream a little dream",
public_username="******",
short_intro="writing about my everyday thoughts",
location="LA, USA")
