Beispiel #1
0
def index(response):
    form_id = response.get_field('form_id', 'front')
    if form_id == 'front':
        response.write(LOGIN_HTML)
    elif form_id == 'login':
        user = response.get_field('user')
        try:
            user = User.get(user=user)
            set_user(response, user)
            response.redirect('/profile')
        except DoesNotExistError:
            response.redirect('/')
    elif form_id == 'signup':
        user = response.get_field('user')
        passwd1 = response.get_field('passwd1')
        #passwd2 = response.get_field('passwd2')
        first = response.get_field('first')
        last = response.get_field('last')
        dob = response.get_field('dob')
        logger.info('adding user {} ({} {}) with passwd {}'.format(user, first, last, passwd1))
        if user and first and last and passwd1:
            try:
                user = User.add(user=user, passwd=passwd1, first=first, last=last, dob=dob)
                set_user(response, user)
                response.redirect('/profile')
            except IntegrityError:
                response.write(LOGIN_HTML)
        else:
            response.write(LOGIN_HTML)
Beispiel #2
0
def join():
	if request.method == 'GET':
		return render_template('join.html')
	username = request.form.get('username')
	password = request.form.get('password')
	email = request.form.get('email')
	if not username:
		flash('Please input username')
            	return redirect(url_for('join'))
	elif not password:
		flash('Please input password')
            	return redirect(url_for('join'))
	elif not email:
		flash('Please input email')
            	return redirect(url_for('join'))
        try:
         	# use the .get() method to quickly see if a user with that name exists
           	user = User.get(username=username)
            	flash('That username is already taken')
	except User.DoesNotExist:
           	# if not, create the user and store the form data on the new model
            	user = User.create(username=username,
			password=md5(password).hexdigest(),	
			email=email,join_date=datetime.datetime.now())
            		# mark the user as being 'authenticated' by setting the session vars
           	auth_user(user)
            	return redirect(url_for('homepage'))
Beispiel #3
0
 def add_user(self, user: User):
     if user.hash is None:
         raise ValueError("User doesn't have a hash.")
     if user.hash == owner_hash:
         for perm in all_perms.keys():
             user.add_permission(perm)
     self.session.add(user)
Beispiel #4
0
def r_success():
    nickname = request.form["nickname"]
    email = request.form["email"]
    passwd = request.form["passwd"]
    repasswd = request.form["repasswd"]
    if passwd != repasswd:
        return "비밀번호가 다릅니다."
    if len(passwd) < 8:
        return """
             <script>
             alert("비밀번호를 8자리 이상 적어주세요.");
            history.back();
             </script>
        """
    if not len(email) or not len(nickname):
        return """
             <script>
             alert("모두 채워 주세요.");
            history.back();
             </script>
            """
    if is_already_registered(email, nickname) == 2:
        return "메일"
    if is_already_registered(email, nickname) == 3:
        return "별명"
    new = User()
    new.nickname = nickname
    new.email = email
    new.pw = passwd
    db.session.add(new)
    db.session.commit()
    return render_template("index.html")
Beispiel #5
0
    def get(self, node):
        page = self.get_argument("page", 1)
        share_res = Share.find({'sharetype': node}).sort(
            '_id', DESCENDING).limit(10).skip((int(page) - 1) * 10)
        pagesum = (share_res.count() + 9) / 10

        shares = []
        for share in share_res:
            user = User.by_sid(share.user_id)
            share.name = user.user_name
            share.published = time.strftime(
                '%Y-%m-%d %H:%M:%S', time.localtime(share.published))
            share.domain = user.user_domain
            share.markdown = filter_tags(
                markdown2.markdown(share.markdown))[:100]
            share.gravatar = get_avatar(user.user_email, 16)
            shares.append(share)
        members = User.find().sort('_id', DESCENDING).limit(20)
        members_dict = []
        for member in members:
            member.gravatar = get_avatar(member.user_email, 25)
            members_dict.append(member)
        node_about = options.node_about[node]
        self.render(
            "node.html", shares=shares, members=members_dict,
            pagesum=pagesum, page=page, node=node, node_about=node_about)
Beispiel #6
0
 def create_user(self, name, team):
     newbie = User(name=name, team=team, loyalists=100, leader=True)
     self.sess.add(newbie)
     cap = Region.capital_for(team, self.sess)
     newbie.region = cap
     self.sess.commit()
     return newbie
Beispiel #7
0
 def get(self, name):
     user = User.find_one({"user_domain": name})
     user.user_say = markdown2.markdown(user.user_say)
     user.user_jointime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(user.user_jointime))
     likenum = User.find({"user_id": user._id}).count()
     user.gravatar = get_avatar(user.user_email, 100)
     self.render("userhome.html", user=user, likenum=likenum)
Beispiel #8
0
    def recruit_from_comment(self, comment):
        session = self.session
        if not comment.author:  # Deleted comments don't have an author
            return
        name = comment.author.name.lower()
        if name == self.config.username.lower():
            return

        # Is this author already one of us?
        found = session.query(User).filter_by(
            name=name).first()
        if not found:
            # Getting the author ID triggers a lookup on the userpage.  In the
            # case of banned users, this will 404.  @failable would normally
            # catch that just fine, but I want to check it here so that in the
            # future, I can do things like e.g. add to an 'ignored' list and
            # save myself the lookup
            try:
                author_id = comment.author.id
            except NotFound:
                logging.warn("Ignored banned user %s" % name)
                return

            team = 0
            assignment = self.config['game']['assignment']
            if assignment == 'uid':
                base10_id = base36decode(author_id)
                team = base10_id % 2
            elif assignment == "random":
                team = random.randint(0, 1)
            is_leader = name in self.config["game"]["leaders"]
            newbie = User(name=name,
                          team=team,
                          loyalists=100,
                          leader=is_leader)
            session.add(newbie)

            cap = Region.capital_for(newbie.team, session)
            if not cap:
                logging.fatal("Could not find capital for %d" %
                              newbie.team)
            newbie.region = cap

            session.commit()
            logging.info("Created combatant %s", newbie)

            reply = ("Welcome to Chroma!  You are now a %s "
                     "in the %s army, commanding a force of loyalists "
                     "%d people strong. You are currently encamped at %s"
            ) % (newbie.rank,
                 num_to_team(newbie.team, self.config),
                 newbie.loyalists,
                 cap.markdown())
            comment.reply(reply)
        else:
            #logging.info("Already registered %s", comment.author.name)
            pass
Beispiel #9
0
def before_request():
    g.user = None
    try:
        if 'id' in session:
            g.user = User.get(User.id == session['id'])

    except User.DoesNotExist:
        g.user = None

    if "test" in request.headers:
        g.user = User.get(User.id == request.headers.get("test"))
Beispiel #10
0
 def test_user_change_info(self):
     self.create_test_data()
     query = User().update(authentication_level=2, email='*****@*****.**',
                                   phone_number='1231231234', name='new_name', title='new_title').where(User.pk == self._user.pk)
     query.execute()
     pk = self._user.pk
     self._user_2 = User().get(pk=pk)
     self.assertEqual(self._user_2.authentication_level, 2)
     self.assertEqual(self._user_2.phone_number, '1231231234')
     self.assertEqual(self._user_2.name, 'new_name')
     self.assertEqual(self._user_2.title, 'new_title')
Beispiel #11
0
 def post(self):
     oldpass = self.get_argument('oldpass', '')
     newpass = self.get_argument('newpass', '')
     newpass = hashlib.md5(newpass).hexdigest()
     user = User.by_sid(self.current_user['user_id'])
     if user.user_pass == hashlib.md5(oldpass).hexdigest():
         user = User.by_sid(self.current_user['user_id'])
         user['user_pass'] = newpass
         user.save()
         self.redirect('/setting')
     else:
         self.redirect('/setting')  # self.write('Wrong password')
Beispiel #12
0
 def post(self):
     oldpass = self.get_argument("oldpass", "")
     newpass = self.get_argument("newpass", "")
     newpass = hashlib.md5(newpass).hexdigest()
     user = User.by_sid(self.current_user["user_id"])
     if user.user_pass == hashlib.md5(oldpass).hexdigest():
         user = User.by_sid(self.current_user["user_id"])
         user["user_pass"] = newpass
         user.save()
         self.redirect("/setting")
     else:
         self.redirect("/setting")  # self.write('Wrong password')
Beispiel #13
0
 def create_test_data(self):
     self._company = Company().create(name='test_name', phone_number='1223456789', address='123 test road, testville test')
     self._user = User().create(name='test_name', email='*****@*****.**', title='the_boss',
                       secret_question='what is the answer?',
                         phone_number='1234567891', authentication_level=3, company=self._company.pk)
     self._user.set_password('test_password')
     self._user.set_secret_answer('42')
     self._admin = User().create(name='admin', email='*****@*****.**', title='the_boss',
                        secret_question='what is the answer?',
                            phone_number='1234567891', authentication_level=1, company=self._company.pk)
     self._admin.set_password('test_password')
     self._admin.set_secret_answer('42')
Beispiel #14
0
 def get(self, name):
     user = User.find_one({'user_domain': name})
     user.user_jointime = time.strftime(
         '%Y-%m-%d %H:%M:%S', time.localtime(user.user_jointime))
     likes = User.find({'user_id': user._id})
     likenum = likes.count()
     for like in likes:
         share = Share.by_id(like.share_id)
         like.title = share.title
         like.id = share.id
         like.type = share.sharetype
     user.gravatar = get_avatar(user.user_email, 100)
     self.render("userlike.html", user=user, likenum=likenum, likes=likes)
Beispiel #15
0
def create():
    new = User()
    new.userId = request.form['id']
    new.userPw = request.form['pw']
    new.nickname = request.form['nickname']
    if new.userId and new.userPw and new.nickname :
        db.session.add(new)
        try:
            db.session.commit()
        except IntegrityError:
            return "이미 있습니다."
        return "%s (%s %s)" % (new.nickname, new.userId, new.userPw)
    else:
        return "내용을 전부 채워야합니다"
 def on_post(self, req, resp):
     doc = req.context['doc']
     users=Session.query(User).all()
     unique=True
     for user in users:
         if doc['email'] == user.email:
             unique=False
     if unique:
         user = User(name=doc['name'], email=doc['email'].lower(), signedin=False,registerTime=datetime.datetime.today())
         print(datetime.datetime.today())
         user.salt = bcrypt.gensalt()
         user.pw_hash = bcrypt.hashpw(doc['password'].encode('utf-8'), user.salt)
         s=smtplib.SMTP_SSL('smtp.gmail.com',465)
         s.ehlo()
         s.login('*****@*****.**','helloworld@ppclub')
         code=randint(1000000,10000000)
         user.code=code
         msg=MIMEText('Hi '+user.name+', your verification URL is: '+'http://192.168.1.127:8000/confirmation/'+str(code))
         msg['From']='*****@*****.**'
         msg['To']=user.email
         msg['Subject']='PhoenixNow Account Confirmation'
         s.send_message(msg)
         s.close()
         Session.add(user)
         Session.flush()
         Session.commit()
         req.context['user'] = user.id
         req.context['result'] = {"result": "success", "action": "register"}
     else:
         user=get_user(req,resp)
         td=datetime.timedelta(minutes=30)
         if datetime.datetime.today()-td<user.registerTime or user.emailVerified==True:
             description = "User was already made"
             title = "User creation conflict"
             raise falcon.HTTPConflict(title=title, description=description)
         else:
             Session.delete(user)
             Session.flush()
             user = User(name=doc['name'], email=doc['email'], signedin=False,registerTime=datetime.datetime.today())
             print(datetime.datetime.today())
             user.salt = bcrypt.gensalt()
             user.pw_hash = bcrypt.hashpw(doc['password'].encode('utf-8'), user.salt)
             s=smtplib.SMTP_SSL('smtp.gmail.com',465)
             s.ehlo()
             s.login('*****@*****.**','helloworld@ppclub')
             code=randint(1000000,10000000)
             user.code=code
             msg=MIMEText('Hi '+user.name+', your verification URL is: '+'http://192.168.1.127:8000/confirmation/'+str(code))
             msg['From']='*****@*****.**'
             msg['To']=user.email
             msg['Subject']='PhoenixNow Account Confirmation'
             s.send_message(msg)
             s.close()
             Session.add(user)
             Session.flush()
             Session.commit()
             req.context['user'] = user.id
             req.context['result'] = {"result": "success", "action": "register"}
Beispiel #17
0
 def _get_and_validate_user(self, username, password):
     user = User.get_by_user_id(username)
     if user == None or not user.validate_password(password):
         raise AuthenticationError(
                 'Username or password does not match.'
             )
     return user
Beispiel #18
0
    def post(self):
        id = self.get_argument("id", None)
        tags = self.get_argument("tags", '')
        user_id = self.current_user["user_id"]
        res = {
            'title': self.get_argument("title"),
            'markdown': self.get_argument("markdown"),
            'sharetype': self.get_argument("type"),
            'slug': self.get_argument("slug", ''),
            'tags': tags,
            'updated': time.time(),
        }

        if id:
            share = Share.by_sid(id)
            if not share:
                self.redirect("/404")
            share.update(res)
            share.save()
        else:
            share = Share
            res['user_id'] = user_id
            share = share.new(res)
            user = User.by_sid(user_id)
            user.user_leaf += 10
            user.save()
        for i in tags.split(' '):
            Tag.new(i, share.id)
        self.redirect("/share/" + str(share.id))
Beispiel #19
0
def get_user_rating():
    name = request.args.get('name')
    if name is None:
        abort(400)
    fmt = request.args.get('format', 'json')
    try:
        user = User.get(User.user == name)
    except User.DoesNotExist:
        abort(404)
    if fmt == 'xml':
        def quoteattr(s):
            return '"{0}"'.format(str(s)
                                  .replace('&', '&amp;')
                                  .replace('<', '&lt;')
                                  .replace('>', '&gt;')
                                  .replace('"', '&quot;'))
        xml = '<?xml version="1.0" encoding="UTF-8"?>\n<mmwatch>\n'
        for field in (
            ('name', user.user.encode('utf-8')),
            ('rank', user.rank),
            ('edits', user.edits),
            ('joined', user.joined.isoformat())
        ):
            xml = xml + '  <{0} value={1} />\n'.format(field[0], quoteattr(field[1]))
        xml = xml + '</mmwatch>'
        return Response(xml, mimetype='application/xml')
    return jsonify(name=user.user, rank=user.rank, edits=user.edits, joined=user.joined.isoformat())
Beispiel #20
0
 def post(self):
     user = User.by_sid(self.current_user['user_id'])
     user['user_name'] = self.get_argument('name', None)
     user['user_city'] = self.get_argument('city', None)
     user['user_say'] = self.get_argument('say', None)
     user.save()
     self.redirect('/setting')
Beispiel #21
0
    def validate(self):
        rv = Form.validate(self)
        if not rv:
            return False

        print self.admin
        user = User(self.admin.data)
        if user is None:
            self.admin.errors.append('Unknown admin')
            return False

        if not user.check_password(self.password.data):
           self.password.errors.append('Invalid password')
           return False

        return True
Beispiel #22
0
 def get(self):
     email = self.get_argument('e', '')
     emailverify = self.get_argument('k', '')
     if User.by_email_verify(email, emailverify):
         self.render('setpass.html')
     else:
         self.render('forgotpass.html')
Beispiel #23
0
 def bind(self, verifier):
   s = Session.get_by_key_name(self._jid)
   if s:
     token = oauth.OAuthToken.from_string(s.data)
     consumer = oauth.OAuthConsumer(config.OAUTH_CONSUMER_KEY, config.OAUTH_CONSUMER_SECRET)
     oauth_request = oauth.OAuthRequest.from_consumer_and_token(consumer, token=token, verifier=verifier,
                                                                http_url=config.ACCESS_TOKEN_URL)
     signature_method_hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1()
     oauth_request.sign_request(signature_method_hmac_sha1, consumer, token)
     try:
       result = urlfetch.fetch(oauth_request.to_url(), method=oauth_request.http_method)
     except urlfetch.Error:
       return 'Network Error!'
     try:
       token = oauth.OAuthToken.from_string(result.content)
     except BaseException:
       return 'Wrong verifier!'
     u = User.get_by_key_name(self._jid)
     if u:
       u.access_key = token.key
       u.access_secret = token.secret
       u.put()
     else:
       User(key_name=self._jid, access_key=token.key, access_secret=token.secret).put()
     s.data = None
     s.put()
     return 'Successfully bind your account.'
Beispiel #24
0
 def get(self):
     email = self.get_argument("e", "")
     emailverify = self.get_argument("k", "")
     if User.by_email_verify(email, emailverify):
         self.render("setpass.html")
     else:
         self.render("forgotpass.html")
Beispiel #25
0
 def post(self):
     name = self.get_argument("name", '')
     password = self.get_argument("password", '')
     password = hashlib.md5(password).hexdigest()
     email = self.get_argument("email", '')
     domain = self.get_argument("domain", '')
     if domain == '':
         domain = name
     if User.find({'user_email': email}).count() > 0:
         self.write('用户已经存在,请直接登录')
         self.redirect("/login")
     else:
         res = User
         res['id'] = res.find().count() + 1
         res['user_name'] = name
         res['user_pass'] = password
         res['user_email'] = email
         res['user_domain'] = domain
         res.new(res)
         user = {'user_id': res.id,
                 'user_name': res.user_name,
                 'user_email': res.user_email,
                 'user_domain': res.user_domain}
         self.set_secure_cookie("user", tornado.escape.json_encode(user))
         self.redirect(self.get_argument("next", "/"))
Beispiel #26
0
def get_userinfo(email):
    try:
        userinfo = User.get(User.email == email)
    except Exception:
        return False
    else:
        return userinfo
Beispiel #27
0
 def post(self):
     name = self.get_argument('name', '')
     password = self.get_argument('password', '')
     email = self.get_argument('email', '')
     domain = self.get_argument('domain', '')
     password = utils.make_password(password)
     if domain == '':
         domain = name
     if User.by_email(email):
         self.redirect('/login')  # self.write('用户已经存在,请直接登录')
     else:
         res = User
         res['id'] = res.find().count() + 1
         print(name, type)
         res['user_name'] = name
         res['user_pass'] = password
         res['user_email'] = email
         res['user_domain'] = domain
         res.new(res)
         send_joinus_email(email, name)
         user_info = {
             'user_id': res.id,
             'user_name': res.user_name,
             'user_email': res.user_email,
             'user_domain': res.user_domain}
         self.set_secure_cookie(
             'user', tornado.escape.json_encode(user_info))
         self.redirect(self.get_argument('next', '/'))
Beispiel #28
0
 def get(self, node='home'):
     page = self.get_argument("page", 1)
     # share_res = Share.find({'status': 0}).sort(
     #     'score', DESCENDING).limit(11).skip((int(page) - 1) * 11)
     share_res = Share.find({'status': {'$gte': 1}}).sort(
         '_id', DESCENDING).limit(11).skip((int(page) - 1) * 11)
     pagesum = (share_res.count() + 10) / 11
     shares = []
     for share in share_res:
         if share.id in (48, 47):
             continue
         user = User.by_sid(share.user_id)
         share.name = user.user_name
         share.published = time.strftime(
             '%Y-%m-%d %H:%M:%S', time.localtime(share.published))
         share.domain = user.user_domain
         share.markdown = cutter(
             markdown2.markdown(share.markdown))
         share.title = share.title.split('_')[0]
         shares.append(share)
     self.render(
         "node.html",
         shares=shares,
         pagesum=pagesum, page=page, node=node,
     )
Beispiel #29
0
 def post(self):
     user = User.by_sid(self.current_user["user_id"])
     user["user_name"] = self.get_argument("name", None)
     user["user_city"] = self.get_argument("city", None)
     user["user_say"] = self.get_argument("say", None)
     user.save()
     self.redirect("/setting")
Beispiel #30
0
 def post(self):
     name = self.get_argument("name", "")
     password = self.get_argument("password", "")
     email = self.get_argument("email", "")
     domain = self.get_argument("domain", "")
     password = utils.make_password(password)
     if domain == "":
         domain = name
     if User.by_email(email):
         self.redirect("/login")  # self.write('用户已经存在,请直接登录')
     else:
         res = User
         res["id"] = res.find().count() + 1
         res["user_name"] = name
         res["user_pass"] = password
         res["user_email"] = email
         res["user_domain"] = domain
         res.new(res)
         send_joinus_email(email, name)
         user_info = {
             "user_id": res.id,
             "user_name": res.user_name,
             "user_email": res.user_email,
             "user_domain": res.user_domain,
         }
         self.set_secure_cookie("user", tornado.escape.json_encode(user_info))
         self.redirect(self.get_argument("next", "/"))
Beispiel #31
0
def register(bot, update, args):
    args_msg = """Error, please register using the command:
```
/register [ssc_email] [ssc_password]
```

*WARNING: Your account information will be stored in plain text, use this bot at your own risk*"""

    exists_msg = """Error, account already exists.

To update your account information please use the command:
```
/update [ssc_email] [ssc_password]
```

*WARNING: Your account information will be stored in plain text, use this bot at your own risk*"""

    success_msg = "Registered successfully!"

    if len(args) != 2:
        bot.send_message(chat_id=update.message.chat_id,
                         text=args_msg,
                         parse_mode="Markdown")
        return

    telegram_id = update['message']['chat']['id']
    username = update['message']['chat']['username']

    ssc_username = args[0]
    ssc_password = args[1]

    session = Session()
    user = session.query(User).filter_by(telegram_id=telegram_id).first()

    if user:
        bot.send_message(chat_id=update.message.chat_id,
                         text=exists_msg,
                         parse_mode="Markdown")
        session.close()
        return

    user = User(telegram_id, username, ssc_username, ssc_password)
    status = Status(telegram_id)
    session.add(user)
    session.add(status)
    session.commit()
    session.close()

    bot.send_message(chat_id=update.message.chat_id,
                     text=success_msg,
                     parse_mode="Markdown")
    return
 def user_status_update(self, user_id: int, status: str) -> Any:
     """ Disable User"""
     try:
         db_user = User.objects(id=user_id).first()
         if status == "enable":
             db_user.is_active = True
         elif status == "disable":
             db_user.is_active = False
         db_user.save()
         return db_user
     except Exception as e:
         fastapi_logger.exception("user_status_update")
         return None
Beispiel #33
0
def oauth():
    resp = openstreetmap.authorized_response()
    if resp is None:
        return 'Denied. <a href="' + url_for('login') + '">Try again</a>.'
    session['osm_token'] = (
            resp['oauth_token'],
            resp['oauth_token_secret']
    )
    user_details = openstreetmap.get('user/details').data
    uid = int(user_details[0].get('id'))
    session['osm_uid'] = uid
    try:
        User.get(User.uid == uid)
    except User.DoesNotExist:
        User.create(uid=uid)

    if session.get('next'):
        redir = session['next']
        del session['next']
    else:
        redir = url_for('front')
    return redirect(redir)
Beispiel #34
0
 def decode_password_token(self,
                           token: str,
                           verify_exp: bool = False) -> Dict[str, Any]:
     assert token, 'Token required'
     assert jwt.get_unverified_header(token).get(
         'tok') == 'pas', 'Password reset token required'
     user = jwt.decode(token, verify=False).get('own')
     with session_scope() as session:
         password = User.get_by_id(session, user).password
     return jwt.decode(token,
                       key=password,
                       algorithms=[self.alg],
                       options={'verify_exp': verify_exp})
Beispiel #35
0
def add_users():
    for u in get_users():
        user = User(id_in_services=u["id"],
                    name=u["username"],
                    email=u["email"],
                    city=u["address"]["city"],
                    company=u["company"]["name"],
                    website=u["website"])
        s.add(user)
        s.commit()
        logger.success("Пользователь {}({}) успешно добавлен!", u["username"],
                       u["email"])
    s.close()
Beispiel #36
0
def create_user(name, username, email, password):
    user = get_user_by_email(email)
    if user is not None:
        return False, user

    new_user = User(name=name,
                    username=username,
                    email=email,
                    password=password)

    db.session.add(new_user)
    db.session.commit()
    return True, new_user
Beispiel #37
0
    def create_user(self, email, password, fname=None, lname=None):
        author = User(seq('users'), email, password, fname, lname)

        if not self.check_password(password):
            raise UserPasswordNotStrongEnough

        try:
            self.session.add(author)
            self.session.commit()
        except sqlalchemy.exc.IntegrityError:
            self.session.rollback()

            raise UsernameAlreadyExistsException
Beispiel #38
0
 def post(self):
     """Add user"""
     json_data = request.get_json(force=True)
     name = json_data['name']
     email = json_data['email']
     try:
         repository.add_user(User(id=email, name=name))
         return {'status': "done"}
     except RepositoryException as err:
         return ReturnDocument(err.__doc__, "error").asdict()
     except KeyError as err:
         return ReturnDocument(f"{err.__str__()}-{err.__doc__}",
                               "error").asdict()
Beispiel #39
0
def update_user_profile(id: int,
                        food: List[int] = None,
                        pantry: bool = None,
                        eager: int = None):
    with session_scope() as session:
        user = User.get_by_id(session, id)
        if food:
            UserFoodPreference.update(session, id, food)
        if pantry:
            user.pitt_pantry = pantry
        if eager:
            user.eagerness = eager
        session.merge(user)
Beispiel #40
0
    async def associate(self, context, kol_id=None):
        """ Member is asking to associate their Discord and KoL accounts """
        if kol_id is None:
            await context.send("Please specify your KoL id")
            return

        kol = self.bot.kol
        member = context.author
        token = str(uuid4())[:8]
        User.replace(kol_id=kol_id, discord_id=member.id,
                     token=token).execute()
        try:
            await kol.kmail.send(recipient=kol_id,
                                 message="$verify {}".format(token))
            await context.send(
                "Verification token sent to your account via kmail. Paste the command from there into this DM."
            )
        except UserNotFoundError:
            await context.send("User id is invalid")
        except Error as e:
            print(e)
            await context.send("There was an error sending you a kmail")
Beispiel #41
0
    def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
               domain: Dict[Text, Any]) -> List[Dict]:

        cpf = tracker.get_slot("cpf")
        email = tracker.get_slot("email")

        user = User.where(User.document == cpf).first()

        user.email = email

        session.commit()

        return []
 def allUsers(self):
     users = []
     sql = "select * from user;"
     cursor.execute(sql)
     data = cursor.fetchone()
     while data != None:
         user = User.User()
         user.setId(data[0])
         user.setUsername(data[1])
         user.setPassword(data[2])
         users.append(user)
         data = cursor.fetchone()
     return users
Beispiel #43
0
def add_new_user():
    if request.method == 'POST':
        first_name = request.form.get('first_name')
        last_name = request.form.get('last_name')
        address = request.form.get('address')
        city = request.form.get('city')
        new_address = Address(address=address, city=city)
        new_user = User(first_name=first_name,
                        last_name=last_name,
                        address=new_address)
        DBUser(new_user).add_entity()
        return redirect(url_for('/db.manage_data'))
    return render_template('add_user.html')
Beispiel #44
0
    def get(self):
        def handle_result(rpc):
            try:
                result = rpc.get_result()
            except urlfetch.Error:
                return
            else:
                jid = self.jids[id(rpc)]
                emails_map = parse(result.content)
                emails = list()
                for email in emails_map:
                    if not Mail.get_by_key_name(email['id']):
                        if Mail(key_name=email['id']).put():
                            str = 'From: %(author)s\nTitle: %(title)s\nSummary: %(summary)s\nTime: %(time)s\n%(url)s' % email
                            emails.insert(0, str)
                if emails:
                    while CapabilitySet('xmpp').is_enabled():
                        try:
                            xmpp.send_message(jid, '\n\n'.join(emails))
                        except xmpp.Error:
                            pass
                        else:
                            break

        def create_callback(rpc):
            return lambda: handle_result(rpc)

        if not db.WRITE_CAPABILITY:
            return
        rpcs = []
        self.jids = {}
        for u in Session.all().filter('data =', None):
            jid = u.key().name()
            u = User.get_by_key_name(jid)
            token = oauth.OAuthToken(u.access_key, u.access_secret)
            consumer = oauth.OAuthConsumer(config.OAUTH_CONSUMER_KEY,
                                           config.OAUTH_CONSUMER_SECRET)
            oauth_request = oauth.OAuthRequest.from_consumer_and_token(
                consumer, token=token, http_url=config.RESOURCE_URL)
            signature_method_hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1()
            oauth_request.sign_request(signature_method_hmac_sha1, consumer,
                                       token)
            rpc = urlfetch.create_rpc()
            rpc.callback = create_callback(rpc)
            urlfetch.make_fetch_call(rpc,
                                     oauth_request.http_url,
                                     headers=oauth_request.to_header())
            rpcs.append(rpc)
            self.jids[id(rpc)] = jid
        for rpc in rpcs:
            rpc.wait()
Beispiel #45
0
def thanks(update, context):
    _log_msg(update.message.text, 'user', update, state='registration_final')
    try:
        awc_code = int(update.message.text)
    except:
        return _awc_code_error(update)

    if len(str(awc_code)) != 11:
        return _awc_code_error(update)

    context.user_data['awc_code'] = update.message.text

    # HACK: to calculate the cohort
    d1 = datetime(2019, 6, 26)
    d2 = datetime.utcnow()
    monday1 = (d1 - timedelta(days=d1.weekday()))
    monday2 = (d2 - timedelta(days=d2.weekday()))
    cohort = (monday2 - monday1).days // 7

    # SAVE THE USER
    new_user = User(
        chat_id=update.effective_chat.id,
        first_name=context.user_data['preferred_name'],
        last_name=update.message.from_user.last_name,
        track=context.user_data['track'],
        phone_number=context.user_data['phone_number'],
        child_name=context.user_data['child_name'],
        child_gender=context.user_data['child_gender'],
        child_birthday=datetime.strptime(
            context.user_data['child_birthday'], '%Y-%m-%d'),
        current_state='echo',
        current_state_name='echo',
        aww=context.user_data['aww'],
        aww_number=context.user_data['aww_number'],
        awc_code=context.user_data['awc_code'],
        registration_date=datetime.utcnow(),
        cohort=cohort,
        test_user=False
    )
    Database().insert(new_user)
    if settings.HINDI:
        send_text_reply(
            "धन्यवाद! अब आप पंजीकृत हैं।", update, state='registration_final')
        send_text_reply(
            "यदि आप मेरे द्वारा पहला संदेश भेजने से पहले थोड़ा अभ्यास करना चाहते हैं, तो कृपया 1 से 10 के बीच कोई भी संख्या दर्ज करें और मैं आपको बताउंगी कि मैंने क्या समझा।", update, state='registration_final')
        send_text_reply(
            "कृपया अपने पहले संदेश की प्रतीक्षा करें, जो अगले 7 दिनों के भीतर मेरे द्वारा आना चाहिए। आप मेरे द्वारा भेजे गए किसी भी सन्देश को फिर से पा सकते हैं, बस किसी भी समय हेल्लो टाइप करके!", update, state='registration_final')
    else:
        send_text_reply(
            "Thank you! You're registered. Please wait for your first message, that should come within the next 7 days. If you want to practice before I sent you the first message, please enter a number between 1 to 10 and I will tell you what I understood. You can access all content I have sent you after that just by typing hello at any time!", update, state='registration_final')
    return ConversationHandler.END
Beispiel #46
0
    def post(self):
        body = request.get_json()

        if not User.objects(email=body["email"]):
            if len(body["password"]) >= 6:
                user = User(email=body["email"], password=body["password"])
                user.hash_password()
                user.save()
                return {'id': str(user.id)}, 200
            return {"error": "Short password"}, 401

        return {"error": "Email was already used!"}, 401
Beispiel #47
0
def get_comments(share, like_commentids, dislike_commentids):
    comments = []
    comment_res = Comment.find({'share_id': share.id})
    for comment in comment_res:
        user = User.by_sid(comment.user_id)
        comment.name = user.user_name
        comment.domain = user.user_domain
        comment.gravatar = get_avatar(user.user_email, 50)
        print(like_commentids, comment.id)
        print(dislike_commentids, comment.id)
        comment.is_liking = comment.id in like_commentids
        comment.is_disliking = comment.id in dislike_commentids
        comments.append(comment)
    return comments
Beispiel #48
0
def registration_post():
    email = request.form.get('email').strip()
    password = request.form.get('password').strip()

    if email != "" and password != "" and database.create_user(
            email, email, password):
        remember = request.form.get('remember') is not None
        user_id = database.check_user(email, email, password)
        login_user(User(user_id, database), remember=remember)
        return redirect("/")

    flask.flash('Не удалось создать учётную запись. '
                'Возможно, Вы уже зарегистрированы?')
    return redirect("/login")
def create_user(first_name, last_name, username, phone_number, email,
                password):
    user = get_user_by_email(email)
    if user is not None:
        return False, user
    new_user = User(first_name=first_name,
                    last_name=last_name,
                    username=username,
                    phone_number=phone_number,
                    mail=email,
                    password=password)
    db.session.add(new_user)
    db.session.commit()
    return True, new_user
Beispiel #50
0
    def create_new_user(self, email, password, **params):
        if not email or not password:
            raise SignUpError("invalid input")

        user = self.session.query(User).filter_by(login=email).first()

        if user is not None:
            raise SignUpError("email is already used")

        new_user = User(login=email,
                        username=params.get("username", email),
                        pwd_hash=password_hash(password))

        self.activate_session_token(new_user)
Beispiel #51
0
def ufwlist():
    json_list = request.get_json(silent=True)
    if json_list is None:
        abort(400, 'bad request - expected json payload')
    elif not isinstance(json_list, list):
        abort(400, 'bad request - expected a list')
    ret = []
    for user in User.select().where(User.wallet_address.in_(json_list)):
        ret.append({
            'discord_id': user.user_id,
            'user_name': user.user_name,
            'created_ts': format_js_iso(user.created),
        })
    return jsonify(ret)
	def get(self):
		try:
			user=(request.form['User'])
		except:
			user = None
		if user != None:
			print(user)
			if not User.objects(username=user):
				return {"error": 'User not found'}, 404
			else:
				return CustomerHistory.objects(userID = user).to_json(),200
		else:
			print()
			return CustomerHistory.objects().to_json(),200
Beispiel #53
0
    def get(self):
        share_res = Share.find()
        shares = []
        for share in share_res:
            user = User.by_sid(share.user_id)
            share.name = user.user_name
            share.published = datetime.datetime.fromtimestamp(share.published)
            share.updated = datetime.datetime.fromtimestamp(share.updated)
            share.domain = user.user_domain
            share.content = markdown2.markdown(share.markdown)
            shares.append(share)

        self.set_header("Content-Type", "application/atom+xml")
        self.render("feed.xml", shares=shares)
Beispiel #54
0
def new_roadblock(bot: Bot, message: Message) -> None:
    if banned(message.from_user) or message.chat_id == roads_chat \
            or spam(message):
        return

    user_id = message.from_user.id
    with db_session:
        U.get(user_id=user_id).roadblocks_count += 1
    user = bot.get_chat_member(mods_chat, user_id)
    if user['status'] in ('creator', 'administrator', 'member'):
        bypass_moderators(bot, message)
        return

    message.reply_text(BOT_MSG_ACCEPT.format(message.from_user.name))
    msg = BOT_REQUEST_CHECK.format(message.from_user.name)
    mods_message = bot.send_message(mods_chat, msg, reply_markup=mods_keyboard)
    message.forward(mods_chat)

    with db_session:
        Roadblock(author=message.from_user.id,
                  chat_id=message.chat_id,
                  chat_message_id=message.message_id,
                  mods_message_id=mods_message.message_id)
Beispiel #55
0
def oauth():
    resp = openstreetmap.authorized_response()
    if resp is None:
        return 'Denied. <a href="' + url_for('login') + '">Try again</a>.'
    session['osm_token'] = (resp['oauth_token'], resp['oauth_token_secret'])
    user_details = openstreetmap.get('user/details').data
    session['osm_uid'] = int(user_details[0].get('id'))
    name = user_details[0].get('display_name')
    user, created = User.get_or_create(uid=session['osm_uid'],
                                       defaults={'name': name})
    if user.name != name or created:
        user.name = name
        user.save()
    return redirect(url_for('front'))
Beispiel #56
0
def create_user(email, password, first_name, last_name):
    optional_user = get_user_by_email(email)
    if optional_user:
        return False, optional_user

    user = User(email=email,
                password=password,
                firstName=first_name,
                lastName=last_name)

    db.session.add(user)
    db.session.commit()

    return True, user
Beispiel #57
0
async def process_group(msg: types.Message, state: FSMContext):
    async with state.proxy() as data:
        direction = data["direction"]
        if msg.text not in get_group_names_by_short_direction_name(direction):
            return await msg.answer("Выберите группу с клавиатуры!")
        data["group"] = msg.text
        user_data = msg.from_user
        user = User(user_data.id, user_data.first_name, user_data.last_name,
                    user_data.username, user_data.language_code,
                    user_data.is_bot, get_group_id_by_name(msg.text))
        insert_user(user)
        await state.finish()
        await msg.answer("Ура! Теперь вам доступно расписание!",
                         reply_markup=menu_kb)
Beispiel #58
0
def signup(email: str,
           password: str,
           name: str = None) -> Tuple[Optional['UserData'], Optional[str]]:
    """
    Sign user up with
    :param email:
    :param password:
    :param name:
    :return:
    """
    with session_scope() as session:
        user = User.create(session, User(email=email, password=password))
        if user is not None:
            code = None
            threshold = int(get_property('user.threshold'))
            if threshold > 0:
                logging.info("passed threshold")
                code = UserVerification.add(session, user.id).code
                set_property('user.threshold', str(threshold - 1))
            else:
                logging.info("failed threshold")
            return UserData(user), code
    return None, None
Beispiel #59
0
def login():
    form = LoginForm()
    if request.method == 'POST' and form.validate_on_submit():
        name = form.username.data
        pwd = form.password.data
        remember = form.remember.data
        user = User.objects(name=name, pwd=pwd).first()
        if user:
            flash('login success !', category='login success')
            login_user(user, remember=form.remember.data)
            return redirect('/admin')
        else:
            return render_template('login.html', form=form, status=1)
    return render_template('login.html', form=form)
Beispiel #60
0
def login():
    form = LoginForm()
    if current_user.is_authenticated:
        return redirect('/user/me')
    elif request.method == 'POST' and form.validate_on_submit():
        username = form.username.data
        remember = form.remember.data
        password = form.password.data
        user = User.objects(username=username).first()
        if user.check_password(password):
            login_user(user, remember=remember)
            return redirect('/user/me')
        return render_template('login.html', form=form, status=0)
    return render_template('login.html', form=form, status=1)