Exemplo n.º 1
0
def create_user():
    body = request.get_json()

    exists = db.session.query(
        db.exists().where(User.email == body['email'])).scalar()

    if exists == True:
        user = User.query.filter_by(email=body["email"]).first()
        is_active = user.is_active
        if is_active == False:
            hashed_password = generate_password_hash(body['password'],
                                                     method='sha256')
            old_new_user = user
            old_new_user.reactivate_user(body['name'], body['last_name'],
                                         hashed_password, is_active)
            return jsonify(old_new_user.serialize()), 200
        else:
            return "Email alredy in use", 400
    else:
        try:
            hashed_password = generate_password_hash(body['password'],
                                                     method='sha256')
            new_user = User(email=body["email"],
                            password=hashed_password,
                            is_active=True,
                            name=body["name"],
                            last_name=body["last_name"])
            new_user.create_user()
            return jsonify(new_user.serialize()), 200
        except:
            return "Couldn't create the user", 401
Exemplo n.º 2
0
def subscribe(channel_id):
    if not db.session.query(db.exists().where(User.id == channel_id)).scalar():
        return redirect(request.referrer)
    new_subscribe = SubscriberAssociation(author_id=channel_id,
                                          subscriber_id=current_user.id)
    db.session.add(new_subscribe)
    db.session.commit()
    return redirect(request.referrer)
Exemplo n.º 3
0
def searchbox():
    """Search area for restroom"""

    search = request.args.get('q')

    client = GoogleSearchClass(api_key = API_KEY, address_or_postal_code=search)
    search_result=client.search()
    filtered_list = client.filter_results()
    detailed_list = client.detail()
    filtered=list(filtered_list)
    
    if search_result['status'] == "INVALID_REQUEST":
        raise ValueError('invalid zip code or address')

    for place in detailed_list:
        blacklist_exists = db.session.query(db.exists().where(Blacklist.restroom_id == place['place_id'])).scalar()

        if blacklist_exists is True:
          detailed_list.remove(place)
        else: 
            for restroom in filtered[0]:
                name = restroom['name']
                latitude = restroom['geometry']['location']['lat']
                longitude = restroom['geometry']['location']['lng']
                address = restroom['vicinity']
                place_id = restroom['place_id'] 
                user_id = g.user.id

                toilet = Restroom(name=name,
                            latitude=latitude,
                            longitude=longitude,
                            address=address,
                            place_id=place_id,
                            user_id = user_id
                          )
            
                restroom_exists = db.session.query(db.exists().where(Restroom.place_id == place_id)).scalar()

                if restroom_exists is True:
                    continue
                else:
                    db.session.add(toilet)
                    db.session.commit()
    
        
    return render_template('restrooms.html', detailed_list=detailed_list)
Exemplo n.º 4
0
def create_venue_submission():
    # TODO: insert form data as a new Venue record in the db, instead DONE
    # TODO: modify data to be the data object returned from db insertion
    # venue = request.form
    try:
        # venue = Venue(
        #   name=request.form['name'],
        #   genres=request.form.getlist('genres'),
        #   address=request.form['address'],
        #   city=request.form['city'],
        #   state=request.form['state'],
        #   phone=request.form['phone'],
        #   facebook_link=request.form['facebook_link'],
        #   website=request.form['website'],
        #   image_link=request.form['image_link'],
        #   seeking_talent=True if request.form['seeking_talent'] in ('y', True, 't', 'True') else False,
        #   seeking_description=request.form['seeking_description'],
        # )
        # print(venue.seeking_talent)
        exists = db.session.query(
            db.exists().where(Venue.name == request.form['name'])).scalar()

        if exists:
            flash('This venue is already exist')
            return render_template('pages/venues.html')

        venue = Venue()
        for field in request.form:
            if field == 'genres':
                setattr(venue, field, request.form.getlist(field))
            elif field == 'seeking_talent':
                setattr(
                    venue, field,
                    True if request.form.get(field) in ('y', True, 't',
                                                        'True') else False)
            else:
                setattr(venue, field, request.form.get(field))
        try:
            db.session.add(venue)
            db.session.commit()
            flash('Venue ' + request.form['name'] +
                  ' was successfully listed!')
        except:
            db.session.rollback()
            flash('An error occurred. Venue ' + venue.name +
                  ' could not be listed.')
            return render_template('errors/500.html'), 500
        finally:
            db.session.close()

    except:
        return render_template('errors/500.html'), 500

    # on successful db insert, flash success
    # TODO: on unsuccessful db insert, flash an error instead. DONE
    # e.g., flash('An error occurred. Venue ' + data.name + ' could not be listed.')
    # see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
    return render_template('pages/home.html')
Exemplo n.º 5
0
 def test_promote_active_recruiter_to_senior(self):
     response = set_roles(self.recruiter.id,
                          is_senior_recruiter=True,
                          current_user=self.admin)
     self.assertEqual(response, {'status': 'ok'})
     self.assertTrue(self.recruiter.recruiter.is_senior)
     self.assertTrue(
         db.session.query(db.exists().where(
             db.and_(Application.user_id == self.applicant.id,
                     Application.is_concluded == False))).scalar())
Exemplo n.º 6
0
def add_comment():
    comment = request.form.get("comment")
    commenter_id = request.form.get("commenter_id")
    post_id = request.form.get("post_id")

    if not comment:
        return make_response(
            jsonify({
                "code": 403,
                "msg": "Cannot put comment. Comment is empty."
            }), 403)

    person_exists = db.session.query(
        db.exists().where(Person.id == commenter_id)).scalar()
    if not person_exists:
        return make_response(
            jsonify({
                "code": 403,
                "msg": "Cannot comment on post. User does not exist."
            }), 403)

    post_exists = db.session.query(
        db.exists().where(Post.post_id == post_id)).scalar()
    if not post_exists:
        return make_response(
            jsonify({
                "code": 403,
                "msg": "Cannot comment on post. Post does not exist."
            }), 403)
    c = Comment(post_id=post_id, commenter_id=commenter_id, comment=comment)
    db.session.add(c)
    try:
        db.session.commit()
    except sqlalchemy.exc.SQLAlchemyError as e:
        error = "Cannot put post. "
        print(app.config.get("DEBUG"))
        if app.config.get("DEBUG"):
            error += str(e)
        return make_response(jsonify({"code": 404, "msg": error}), 404)
    return jsonify({"code": 200, "msg": "success"})
Exemplo n.º 7
0
def get_user_characters(user_id, current_user=None):
    user = User.get(user_id)
    if not has_applicant_access(current_user, user, self_access=True):
        raise ForbiddenException(
            'User {} does not have access.'.format(current_user))
    if not db.session.query(db.exists().where(User.id == user_id)).scalar():
        raise BadRequestException(
            'User with id={} does not exist.'.format(user_id))
    character_dict = {}
    for character in db.session.query(Character).filter(
            Character.user_id == user_id):
        character_dict[character.id] = {
            'name': character.name,
            'corporation_id': character.corporation_id,
            'corporation_name': character.corporation.name,
        }
    return {'info': character_dict}
Exemplo n.º 8
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    # TODO: insert form data as a new Venue record in the db, instead
    # TODO: modify data to be the data object returned from db insertion
    try:
        exists = db.session.query(
            db.exists().where(Artist.name == request.form['name'])).scalar()

        if exists:
            flash('This artist is already exist')
            return render_template('pages/artists.html')
        artist = Artist()
        for field in request.form:
            if field == 'genres':
                setattr(artist, field, request.form.getlist(field))
            elif field == 'seeking_venue':
                setattr(
                    artist, field,
                    True if request.form.get(field) in ('y', True, 't',
                                                        'True') else False)
            else:
                setattr(artist, field, request.form.get(field))
        try:
            db.session.add(artist)
            db.session.commit()
            flash('Artist ' + request.form['name'] +
                  ' was successfully listed!')
        except:
            db.session.rollback()
            flash('An error occurred. Artist ' + artist.name +
                  ' could not be listed.')

            return render_template('errors/500.html'), 500
        finally:
            db.session.close()

    except:
        return render_template('errors/500.html'), 500

    # on successful db insert, flash success
    # flash('Artist ' + request.form['name'] + ' was successfully listed!')
    # TODO: on unsuccessful db insert, flash an error instead.
    # e.g., flash('An error occurred. Artist ' + data.name + ' could not be listed.')
    return render_template('pages/home.html')
Exemplo n.º 9
0
def delete_post_by_id(post_id):
    post_exists = db.session.query(
        db.exists().where(Post.post_id == post_id)).scalar()
    if not post_exists:
        return make_response(
            jsonify({
                "code": 403,
                "msg": "Post does not exist."
            }), 403)
    post = Post.query.filter_by(post_id=post_id).first()
    if post:
        Post.query.filter_by(post_id=post_id).delete()
        Comment.query.filter_by(post_id=post_id).delete()
        db.session.commit()
        return jsonify({"code": 200, "msg": "success"})
    else:
        return make_response(
            jsonify({
                "code": 404,
                "msg": "Post does not exist."
            }), 404)
Exemplo n.º 10
0
    def get(self):
        if current_identity.has_role('admin') or current_identity.has_role('researcher'):
            survey = database.survey.get(current_identity.survey_id)
            survey_users = []

            users_with_coordinates = (survey.mobile_users.filter(
                db.exists().where(MobileUser.id == MobileCoordinate.mobile_id)))

            for user in users_with_coordinates:
                survey_users.append({
                    'uuid': user.uuid,
                    'created_at': user.created_at.isoformat()
                })
        else:
            survey_users = [{
                'uuid': current_identity.participant_uuid,
                'created_at': current_identity.created_at.isoformat()
            }]
        return Success(status_code=200,
                       headers=self.headers,
                       resource_type=self.resource_type,
                       body=survey_users)            
Exemplo n.º 11
0
def fetch_data():
    date = datetime.today().date() - timedelta(days=1)
    date_to_url = str(date).replace('-', '')
    URL = f'https://www.espn.com/nba/scoreboard/_/date/{date_to_url}'
    driver = webdriver.Chrome(ChromeDriverManager().install())
    driver.get(URL)
    soup = BeautifulSoup(driver.page_source, 'html.parser')
    teams = soup.find_all("tbody", {"id": "teams"})
    if not soup and not teams:
        return
    if db.session.query(db.exists().where(DateResults.date == date)).scalar():
        return
    date_results_model = DateResults(date=date)
    date_results_model.save()
    for i in teams:
        away = i.find("tr", {"class": "away"})
        home = i.find("tr", {"class": "home"})
        data = {
            'away_name': away.find('span', {
                'class': 'sb-team-short'
            }).text,
            'away_score': int(away.find('td', {
                'class': 'total'
            }).text),
            'home_name': home.find('span', {
                'class': 'sb-team-short'
            }).text,
            'home_score': int(home.find('td', {
                'class': 'total'
            }).text),
            'date_results_id': date_results_model.id
        }
        teams_scores_model = TeamsScores(**data)
        teams_scores_model.save()

    driver.close()
    return
Exemplo n.º 12
0
def get_answers(user_id, current_user=None):
    if not db.session.query(db.exists().where(User.id == user_id)).scalar():
        raise BadRequestException(
            'User with id={} does not exist.'.format(user_id))
    user = User.get(user_id)
    current_user = current_user or user
    if not has_applicant_access(current_user, user, self_access=True):
        raise ForbiddenException(
            'User {} does not have access to user {}'.format(
                current_user, user_id))

    application = Application.get_for_user(user_id)
    if not application:
        raise BadRequestException(
            'User with id={} has no application.'.format(user_id))
    questions = get_questions()
    response = {'questions': {}, 'has_application': False}
    if application:
        response['has_application'] = True
        # get a dict keyed by question id of questions & answers
        answers = {a.question_id: a.text for a in application.answers}
        for question_id in questions:
            answer = answers[question_id] if question_id in answers else ""
            response['questions'][question_id] = {
                'question': questions[question_id],
                'user_id': user_id,
                'answer': answer,
            }
    else:
        # no application yet, create empty answers
        for question_id in questions:
            response['questions'][question_id] = {
                'question': questions[question_id],
                'user_id': user_id,
                'answer': '',
            }
    return response
Exemplo n.º 13
0
import models
from models import db, Picar
from flask_socketio import SocketIO, emit

webcam_w = 320
webcam_h = 240
fps = 10

app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)

# create db if it doesn't exists
with app.app_context():
    db.create_all()
    exists = db.session.query(db.exists().where(Picar.id == 1)).scalar()

    #exists = Picar.query.filter_by(id=0).first().scalar()
    if (exists == 0):
        print("creating defaults for picar in db")
        picarDb = Picar(name="picarv1")
        db.session.add(picarDb)
        db.session.commit()

    # query to make sure it's in there
    #ppp = db.session.query(db.exists().where(Picar.id == 0))
    ppp = Picar.query.filter_by(id=1).first()
    #ppp = Picar.query.get(0)
    print("got picar from db name:" + ppp.name)