def song_edit(id):
	song = session.query(models.Song).get(id)

	if not song:
		message = "Could not find song with id {}".format(id)
		data = json.dumps({"message": message})
		return Response(data, 404, mimetype="application/json")

	song_file = session.query(models.File).filter_by(id=song.file_id).first()
	data = request.json
	song_file.filename = data["filename"]
	session.commit()

	"""Print outs to veiw how data looks during execution above
	print("print outs from song_edit()")
	print("Orig son file data is {}".format(song.as_dictionary()))
	print("Orig file data is {}".format(song_file.as_dictionary()))
	print("data from test is showing as {}".format(data))
	"""
	data = json.dumps(song.as_dictionary())

	"""Print out to see how data above looks
	print("song_edit() final response data")
	"""
	headers = {"Location": url_for("song_get", id=id)}

	return Response(data, 201, headers=headers, mimetype="application/json")
Beispiel #2
0
def put_posts(id):
	""" Edit an existing post """

	data = request.json

	# Check JSON validity
	try:
		validate(data, post_schema)		
	except ValidationError as error:
		data = {"message": error.message}
		return Response(json.dumps(data), 422, mimetype="application/json")

	post = session.query(models.Post).filter_by(id=id).one()
	post.title = data["title"]
	post.body = data["body"]

	session.add(post)
	session.commit()

	#Return a 201 created, containing the post as JSON and with
	#the Location header set to the location of the post

	data = json.dumps(post.as_dictionary())
	headers = {"Location": url_for("post_get", id=post.id)}
	return Response(data, 201, headers=headers,
		mimetype="application/json")
def post():
    # schema = {'type': 'object',
    #           'properties':
    #               {'id': {'type': 'integer', 'minimum': 0}},
    #           'required': ['id']
    #           }

    # try:
    #     validate(request.json, schema)
    # except ValidationError as e:
    #     return jsonify({'msg': e.message}), 400

    # return str(type(request.json['id']))

    user = session.query(User).filter(
        User.id == request.json['id']).one_or_none()

    if user is None:
        return jsonify({'msg': 'User Not Found'}), 404

    pull = Pull(user_id=user.id)
    session.add(pull)
    session.commit()
    session.close()

    return jsonify({'id': request.json['id']}), 200
Beispiel #4
0
def delete_movie(movie_id):

    movie = session.query(Movie).filter(Movie.id == movie_id).first()

    if not movie:
        return make_response(
            jsonify({
                'response': 'Movie not found',
                'status': 404
            }))

    session.delete(movie)

    try:
        session.commit()
    except Exception as e:
        return make_response(
            jsonify({
                'Error': 'Movie was not deleted',
                'status': 500
            }), 500)

    return make_response(
        jsonify({
            'response': 'Movie has been deleted',
            'status': 200
        }), 200)
Beispiel #5
0
def insertdd():
    # walkをinsert
    # for i in range(1, 13):
        # hour = random.randint(8, 17)
        # miniute = random.randint(0, 59)
        # start_walk_datetime = datetime(2018, 5, i, hour, miniute, 0)
        # end_walk_datetime = start_walk_datetime + timedelta(minutes=40)
        # print(start_walk_datetime, end_walk_datetime)
        #
        # walk = Walk(user_id=1, started_at=start_walk_datetime, ended_at=end_walk_datetime)
        # session.add(walk)
        # session.commit()
        # session.close()

    for day in range(1, 13):
        for hour in range(8, 18):
            for miniute in range(0, 59):

                if random.randint(1, 3) % 2 == 0:
                    pull_datetime = datetime(2018, 5, day, hour, miniute, 0)

                    print(pull_datetime)
        #         if random.randint(1, 11) % 2:
        #             break
        #         pull_datetime = datetime(2018, 4, day, hour, miniute, 0)
        #
        #         print(pull_datetime)
        #
                    pull = Pull(user_id=1, created_at=pull_datetime)
                    session.add(pull)
                    session.commit()
                    session.close()
Beispiel #6
0
def editItem(item_id):
    """Render a page that displays an HTML form to edit an item

    Renders a page with an HTML form that allows the owner of the
    item to edit and update the item details.
    """
    formList = session.query(Medium).all()
    editedItem = session.query(ArtItem).filter_by(id=item_id).one()
    if request.method == 'POST':
        if request.form['name']:
            editedItem.name = request.form['name']
        if request.form['description']:
            editedItem.description = request.form['description']
        if request.form['material']:
            editedItem.material = request.form['material']
        if request.form['image_url']:
            editItem.image_url = request.form['image_url']
        if request.form['video_url']:
            editItem.video_url = request.form['video_url']
        if request.form['year']:
            editedItem.year = request.form['year']
        session.add(editedItem)
        session.commit()
        return redirect(url_for('showForms'))
    else:
        return render_template(
            'edit-item.html',
            item=editedItem,
            media=formList,
            userinfo=login_session
        )
Beispiel #7
0
def edit_post_post(id=1):
    post = session.query(Post)
    post = post.filter(Post.id == id).first()
    post.title=request.form["title"]
    post.content=mistune.markdown(request.form["content"])
    session.commit()
    return redirect(url_for("posts"))
def delete_document(url):
    try:
        Document.query.filter(Document.url == url).delete()
        session.commit()
        return 'true'
    except:
        return 'Delete Failed'
Beispiel #9
0
def editProfile(key):

    editProfile = session.query(Profile).filter_by(id = key).one()

    if request.method == 'POST':
        editProfile.name = request.form['name']
        editProfile.weight = request.form['weight']
        editProfile.gender = request.form['gender']
        editProfile.dateOfBirth = datetime.strptime(request.form['birthday'], "%Y-%m-%d")
        editProfile.description = request.form['description']
        editProfile.specialNeeds = request.form['needs']

        session.add(editProfile)
        session.commit()

        flash("Profile edited!")
        return redirect( url_for('viewProfile', key = key) )

    else:
        return render_template(
            'edit.html',
            viewType = 'profile',
            key = key,
            traits = editProfile.traits
        )
Beispiel #10
0
def newPuppy():

    if request.method == 'POST':
        newProfile = Profile(
            name = request.form['pupname'],
            weight = request.form['weight'],
            gender = request.form['gender'],
            picture = random.choice(puppy_images),
            dateOfBirth = datetime.strptime(request.form['birthday'], "%Y-%m-%d"),
            description = request.form['description'],
            specialNeeds = request.form['needs']
        )

        session.add(newProfile)

        new_puppy = Puppy(
            shelter_id = randint(1,5),
            profile = newProfile)

        session.add(new_puppy)
        session.commit()

        flash("New puppy created!")
        return redirect(url_for('viewPuppy', key = newPuppy.id))

    else:
        return render_template(
            'new.html',
            viewType = "puppy",
            traits = Puppy.defaultTraits()
        )
Beispiel #11
0
def editShelter(key):
    editShelter = session.query(Shelter).filter_by(id = key).one()

    if request.method == 'POST':

        editShelter.name = request.form['name']
        editShelter.address = request.form['address']
        editShelter.city = request.form['city']
        editShelter.state = request.form['state']
        editShelter.zipCode = request.form['zipcode']
        editShelter.website = request.form['website']
        editShelter.current_occupancy = request.form['occupancy']
        editShelter.maximum_capacity = request.form['capacity']
        print editShelter.serialize
        session.add(editShelter)
        session.commit()

        flash("Shelter edited!")
        return redirect(url_for('viewShelter', key = key))

    else:
        return render_template(
            'edit.html',
            viewType = 'shelter',
            key = key,
            traits = editShelter.traits
        )
Beispiel #12
0
def newShelter():
    if request.method == 'POST':
        newShelter = Shelter(
            name = request.form['name'],
            address = request.form['address'],
            city = request.form['city'],
            state = request.form['state'],
            zipCode = request.form['zipcode'],
            website = request.form['website'],
            current_occupancy = request.form['occupancy'],
            maximum_capacity = request.form['capacity']
        )

        session.add(newShelter)
        session.commit()

        flash("New Shelter created!")
        return redirect(url_for('viewShelter', key = newShelter.id))

    else:
        return render_template(
            'new.html',
            viewType = "shelter",
            traits = Shelter.defaultTraits()
        )
Beispiel #13
0
def song_delete():
    """ delete a song """
    headers = {"Location": url_for("song_delete")}
    # get the data from the form
    
    data = request.json
    
    post_song = models.Song(song_name=data["song_name"],id=data["song_id"])  ## ask sam if we really need to post seperately.
    post_file = models.File(song_id=data["song_id"],file_name=data["file_name"],id=data["file_id"])
  
    if session.query(models.Song).get(post_song.id):  #consider adding a check here for duplicate fileID too
        del_song=session.query(models.Song).get(post_song.id)
        session.delete(del_song)
        
        del_file = session.query(models.File).get(post_file.id)
        session.delete(del_file)
        
        session.commit()
    else:
        print "************* ELSE ***************"
        session.rollback()
        session.flush()
        return Response(json.dumps({"status":"failed - that song doesnt exists"}),500,mimetype="application/json")
    
    return Response(json.dumps({"status":"deleted"}), 200, headers=headers, mimetype="application/json")
Beispiel #14
0
 def delete(self, id):
     note = session.query(Note).filter(Note.id == id).first()
     if not note:
         abort(404, message="Note %s doesn't exist" % id)
     session.delete(note)
     session.commit()
     return note, 202
Beispiel #15
0
def createUser(login_session):
    """Add a User to the database using the current information stored in the
    login session.

    Args:
        login_session (dict): Dictionary containing information about the current
        login session, including the user's profile information from Google+

    Returns:
        int: The user_id from the newly created record in the User table in
            the database.

    """
    print "Creating User"
    newUser = User(
        name=login_session['username'],
        email=login_session['email'],
        picture=login_session['picture']
    )

    session.add(newUser)
    session.flush()
    session.commit()

    return newUser.id
Beispiel #16
0
def post_edit(id):
  """ Edit an existing post """
  data = request.json
  
  # Get the post from the database
  post = session.query(models.Post).get(id)
  
  # Check that the JSON supplied is valid
  # If not you return a 422 Unprocessable Entity
  try:
    validate(data, post_schema)
  except ValidationError as error:
    data = {"message": error.message}
    return Response(json.dumps(data), 422, mimetype="application/json")
  
  # Update the post
  post.title = data["title"]
  post.body = data["body"]
  session.commit()
  
  # Return a 200 Success, containing the edited post as a JSON and with the
  # Location header set to the location of the post
  data = json.dumps(post.as_dictionary())
  headers = {"Location": url_for("post_get", id=post.id)}
  return Response(data, 200, headers=headers, mimetype="application/json")
  
Beispiel #17
0
def newUser():
    """Present an Authorized Web User with a View for adding a new user.

    Returns:
        For a GET operation returns a Web View containing a form for entering
        data for the new user.

        A successful POST request directs presents a View of the new Record.

    """
    if isActiveSession() is False:
        return redirect(url_for("listUser"))

    # Process New User Form Submission
    if request.method == "POST":
        # Add the new user record to the database
        newUser = User(name=request.form["name"])

        session.add(newUser)
        session.commit()

        flash("New User created!")

        # Redirect to the User View
        return redirect(url_for("viewUser", key=newUser.id))

    # Present the New User Form
    else:
        return render_template(
            "generic.html", modelType="user", viewType=os.path.join("partials", "new.html"), traits=User.defaultTraits()
        )
Beispiel #18
0
def songs_post():
    """ Post a new song to database """

    data = request.json

    # Check for valid JSON. If not available, return 422, Unprocessable Entity
    try:
        validate(data, post_schema)
    except ValidationError as error:
        data = json.dumps({"message": error.message})
        return Response(data, 422, mimetype="application/json")

    file_id = data["file"]["id"]
    song_file = session.query(models.File).get(file_id)

    if not song_file:  # File with id = file_id is not in database
        message = "Could not find song file with file id {}".format(file_id)
        data = json.dumps({"message": message})
        return Response(data, 404, mimetype="application/json")

    song = models.Song(file_id=file_id)
    session.add(song)
    session.commit()
    data = json.dumps(song.as_dictionary())
    return Response(data, 201, mimetype="application/json")
Beispiel #19
0
def newCategory():
    """Allow an Authorized User to add a new Category or Process the form for
    adding a new Category.

    Returns:
        For a GET operation returns a Web View containing a form for entering
        data for the new user.

        A successful POST request directs presents a View of the new Category.

    """
    # Only an Authenticated User can add New Categories
    if isActiveSession() is False:
        return redirect(url_for("listCategory"))

    # Process the New Category Form and add it to the Database
    if request.method == "POST":
        newCategory = Category(user_id=getSessionUserInfo()["id"], name=request.form["name"])

        session.add(newCategory)
        session.commit()

        flash("New Category created!")
        # Display the Information for the new Category
        return redirect(url_for("viewCategory", key=newCategory.id))

    else:
        return render_template(
            "generic.html",
            modelType="category",
            viewType=os.path.join("partials", "new.html"),
            traits=Category.defaultTraits(),
        )
Beispiel #20
0
def edit_activity(activity_id=None):

    activity = session.query(Activity).get(activity_id)
    form = NewActivity(obj=activity)

    if request.method == 'POST':
        try:
            #start_time = datetime.strptime(str(form.start_time.data), '%b %d %Y %I:%M%p')
            #end_time = datetime.strptime(str(form.end_time.data), '%b %d %Y %I:%M%p')
            #duration = str(activity.end_time - activity.start_time)

            activity.title = form.title.data
            activity.activity = form.activity.data
            activity.start_time = form.start_time.data
            activity.end_time = form.end_time.data
            activity.duration = timedelta()
            activity.start_location = form.start_location.data
            activity.end_location = form.end_location.data
            activity.notes = form.notes.data
            activity.calories = form.calories.data

            if form.waypoints.data:
                activity.waypoints = form.waypoints.data

            session.commit()
        except ValueError as e:
            print e
            flash('Please enter date in correct format')
            return render_template('edit_activity.html', form=form)

        flash('Acvitity Edited!')

        return redirect(url_for('entries'))
    return render_template('edit_activity.html', form=form)
Beispiel #21
0
def update_post(id):
    """ Update a single post """
    # check if the post exists, if not return a 404 with a helpful message
    post = session.query(models.Post).get(id)
    if not post:
        message = "Could not find post with id {}".format(id)
        data = json.dumps({"message": message})
        return Response(data, 404, mimetype="application/json")

    data = request.json

    # check that the JSON supplied is valid
    # if not you return a 422 Unprocessable Entity
    try:
        validate(data, post_schema)
    except ValidationError as error:
        data = {"message": error.message}
        return Response(json.dumps(data), 422, mimetype="application/json")

    post.title = data["title"]
    post.body = data["body"]
    session.commit()

    # return an OK 200, containing the post as JSON and with the
    # location header set to the location of the post
    data = json.dumps(post.as_dictionary())
    headers = {"Location": url_for("post_get", id=post.id)}
    return Response(data, 200, headers=headers, mimetype="application/json")
Beispiel #22
0
def admin_edit_cities_state(message, user, is_entry=False):
    current_cities = session.query(City.name).all()
    current_cities = [i for obj in current_cities for i in obj]
    if is_entry:
        bot.send_message(
            message.chat.id,
            'Щоб змінити список міст, скопіюйте наступне повідомлення, та відредагуйте його.\nПоточний список міст:',
            reply_markup=get_back_keyboard(language=user.language))
        bot.send_message(message.chat.id, '\n'.join(current_cities))
    else:
        if message.text == DICTIONARY[user.language]['back_btn']:
            return True, 'admin_settings_state'
        else:
            new_cities = []
            for city in message.text.split('\n'):
                if city not in current_cities:
                    new_cities.append({
                        'name': city,
                        'is_regional_center': False
                    })

            session.execute(
                insert(City).values(new_cities).on_conflict_do_nothing())
            session.commit()
            bot.send_message(message.chat.id, 'Список міст оновлено')
            return True, 'admin_settings_state'

    return False, ''
Beispiel #23
0
def delete_document(url):
    try:
        Document.query.filter(Document.url == url).delete()
        session.commit()
        return 'true'
    except:
        return 'Delete Failed'
Beispiel #24
0
def create_movie():
    data = request.get_json()

    if data is None:
        return make_response(
            jsonify({
                'message': 'error creating movie, body is required',
                'status': 500
            }), 500)

    movie = Movie(title=data['title'],
                  description=data['description'],
                  genre_id=data['genre_id'])

    session.add(movie)

    try:
        session.commit()
    except Exception as e:
        return make_response(
            jsonify({
                'message': 'error creating movie, {}'.format(str(e)),
                'status': 500
            }), 500)

    return make_response(jsonify({
        'message': 'movie created',
        'status': 201
    }), 201)
def songs_post():
    # Add a new song to the database 
    db_song = models.Song(file_id=file.id)
    session.add(db_song)
    session.commit()
    data = db_song.as_dictionary()
    return Response(json.dumps(data), 201, mimetype="application/json")
Beispiel #26
0
def add_flavor():
    """ Add a flavor to the DB """
    # Get creator user name passed with request as argument
    creator = request.args.get("creator")
    # Get flavor name passed as argument
    flavor_name = request.args.get("flavor")

    # Try to get the flavor being added from the DB
    data = session.query(Flavor).filter(Flavor.name == flavor_name).all()
    # If you got the item back from the DB, issue a warning
    if data:
        message = {"message": "Entry matching request already exists in database."}
        return Response(json.dumps(message), 422, mimetype="application/json")
    # Otherwise create the flavor
    flavor = Flavor()
    flavor.name = flavor_name
    flavor.creator = creator
    # Add it to the DB
    session.add(flavor)
    session.commit()
    # Obtain the dict info for the created object
    data = flavor.as_dictionary()
    # And create the header for the new ingredient
    headers = {"Location": "/api/flavor/id/{}".format(flavor.id)}
    # Return that with 201 created
    return Response(json.dumps(data), 201,
                    headers=headers,
                    mimetype="application/json")
Beispiel #27
0
def put():
    # 受け取る値
    # user_id       userID -1ならNoneにして、達成を解除する。それ以外(正しいユーザID)なら普通にupdate
    # promise_id    promiseID

    promise = session.query(Promise).filter(Promise.id == request.json['promise_id']).one_or_none()

    if request.json['user_id'] == -1:
        promise.one_side_done_user_id = None

        session.commit()
        session.close()

        return jsonify({'results': '約束の承認を解除'}), 200


    if not (promise.master_user_id == request.json['user_id'] or promise.slave_user_id == request.json['user_id']):
        session.close()
        return jsonify({'results': '権限なし'}), 403


    if promise.one_side_done_user_id is None:
        promise.one_side_done_user_id = request.json['user_id']
        msg = '片方が承認しました'
    elif promise.one_side_done_user_id == request.json['user_id']:
        msg = '何もしないよ'
    else:
        promise.one_side_done_user_id = None
        promise.is_done = True
        msg = '約束の承認をお互いにしました'

    session.commit()
    session.close()

    return jsonify({'results': msg}), 200
Beispiel #28
0
def add_post_post():
    post = Post(title=request.form["title"],
                content=mistune.markdown(request.form["content"]),
                author=current_user)
    session.add(post)
    session.commit()
    return redirect(url_for("posts"))
Beispiel #29
0
def songs_post():
    """ Add a new song - after file is uploaded """
    # Get JSON from the request
    data = request.json

    # Check that the JSON supplied is valid
    # If not you return a 422 Unprocessable Entity
    try:
        validate(data, file_schema)
    except ValidationError as error:
        data = {"message": error.message}
        return Response(json.dumps(data), 422, mimetype="application/json")

    # Extract the file data from the request
    file = data["file"]
    # Verify that this file exists in the database
    db_file = session.query(models.File).get(file["id"])

    # Create the song object, linking the file_id
    song = models.Song(file_id=file["id"])
    # Add the song to the session and commit it
    session.add(song)
    session.commit()

    # Return a 201 Created, containing the post as JSON and with the
    # Location header set to the location of the post
    data = json.dumps(song.as_dictionary())
    headers = {"Location": url_for("songs_get")}
    return Response(data, 201, headers=headers, mimetype="application/json")
Beispiel #30
0
def post():
    schema = {
        'type': 'object',
        'properties': {
            'user_id': {
                'type': 'integer',
                'minimum': 0
            }
        },
        'required': ['user_id']
    }

    try:
        validate(request.json, schema)
    except ValidationError as e:
        return jsonify({'msg': e.message}), 400

    user = session.query(User).filter(
        User.id == request.json['user_id']).one_or_none()

    if user is None:
        return jsonify({'msg': 'User Not Found'}), 404

    walk = Walk(user_id=user.id)
    session.add(walk)
    session.commit()
    session.close()

    return jsonify({'walk_id': walk.id}), 200
Beispiel #31
0
async def main():
    file_list = cj.ADD_FEE_LIST.keys()
    futures = [
        asyncio.ensure_future(
            parse_zipcode(
                '{path}/{f_name}.txt'.format(path=path.DATA_PATH,
                                             f_name=f_name),
                cj.ADD_FEE_LIST[f_name])) for f_name in file_list
    ]

    futures.extend([
        asyncio.ensure_future(
            parse_jeonnam_zipcode(
                '{path}/전라남도.txt'.format(path=path.DATA_PATH),
                cj.ADD_FEE_JEONAM)),
        asyncio.ensure_future(
            parse_incheon_zipcode(
                '{path}/인천광역시.txt'.format(path=path.DATA_PATH),
                cj.ADD_FEE_INCHEON)),
        asyncio.ensure_future(
            parse_jeju_zipcode(
                '{path}/제주특별자치도.txt'.format(path=path.DATA_PATH)))
    ])

    results = await asyncio.gather(*futures)
    for result in results:
        session.bulk_save_objects([Address(**item) for item in result])
        session.commit()
Beispiel #32
0
def insert_data(request):
    """Parse request json data and insert into db"""
    raw_data = request.get_data(as_text=True, cache=False)
    raw_data = json.loads(raw_data)

    # remove any whitespace and parse to dictionary
    sensor_data = raw_data['data'].replace(" ", "")
    sensor_data = (dict(x.split(':') for x in sensor_data.split(',')))

    # convert to floats and remove chars after '_'
    sensor_data = {
        k: float(v[:v.index('_')])
        for k, v in sensor_data.items() if k != "minSinceStart"
    }

    print(sensor_data)

    # this timestamp is the time at which the sensor
    # pushed the data
    timestamp = raw_data['published_at']

    particle_id = raw_data['coreid']

    # get the sensor id from the users table if it exists
    sensor_owner = session.query(Users).filter_by(
        particle_str=particle_id).first()

    data_insert = Airdata(device_time=timestamp,
                          temperature_C=sensor_data["Temp"],
                          pressure_hPa=sensor_data["Press"],
                          humidity_perc=sensor_data["Hum"],
                          user=sensor_owner)

    session.add(data_insert)
    session.commit()
Beispiel #33
0
def posts_edit_post(id):
    """ Add a new post """
    data = request.json
    # Check that the JSON supplied is valid
    # If not you return a 422 Unprocessable Entity
    try:
        validate(data, post_schema)
    except ValidationError as error:
        data = {"message": error.message}
        return Response(json.dumps(data), 422, mimetype="application/json")

    
    # Call up and edit the post
    post = session.query(models.Post).get(id)
    
    if data["title"]:
        post.title=data["title"]
    else:
        post.title=post.title
    if data["body"]:
        post.body=data["body"]
    else 
    
    session.commit()

    # Return a 200 Created, containing the post as JSON and with the
    # Location header set to the location of the post
    data = json.dumps(post.as_dictionary())
    return Response(data, 200, mimetype="application/json")
def posts_put(id):

    data = request.json                                      
    # Check that the JSON supplied is valid
    # If not we return a 422 Unprocessable Entity
    try:
        validate(data, post_schema)
    except ValidationError as error:
        data = {"message": error.message}
        return Response(json.dumps(data), 422, mimetype="application/json")                               
          
    post = session.query(models.Post).get(id)
    # Check whether the post exists
    # If not return a 404 with a helpful message
    if not post:
        message = "Could not find post with id {}".format(id)
        data = json.dumps({"message": message})
        return Response(data, 404, mimetype="application/json")
                                          
    post.title = data["title"]
    post.body = data["body"]
    session.add(post)
    session.commit()
                                          
    # Return a 201 Created, containing the post as JSON and with the
    # Location header set to the location of the post
    data = json.dumps(post.as_dictionary())
    headers = {"Location": url_for("post_get", id=post.id)}
    return Response(data, 201, headers=headers,
                    mimetype="application/json")
Beispiel #35
0
def song_post():
    """ post a song """
    headers = {
        "Location": url_for("song_post"),
        "Content-Type": "application/json"
    }

    ######### get the data from the form
    data = request.json

    post_song = models.Song(
        song_name=data["song_name"],
        id=data["song_id"])  ## ask sam if we really need to post seperately.
    post_file = models.File(song_id=data["song_id"],
                            file_name=data["file_name"],
                            id=data["file_id"])

    if not session.query(models.Song).get(
            post_song.id
    ):  #consider adding a check here for duplicate fileID too
        session.add_all([post_song, post_file])
        session.commit()
    else:
        print "************* ELSE ***************"
        session.rollback()
        session.flush()
        return Response(json.dumps(
            {"status": "failed - that song already exists"}),
                        500,
                        mimetype="application/json")

    return Response(stripUnicode(data),
                    200,
                    headers=headers,
                    mimetype="application/json")
Beispiel #36
0
def edit_post_post(post_id):
    post = session.query(Post).filter(Post.id == post_id).first()
    post.title = request.form["title"]
    post.content = mistune.markdown(request.form["content"])
    #session.add(post)
    session.commit()
    return redirect(url_for("posts"))
Beispiel #37
0
def update_token():
    schema = {
        'type': 'object',
        'properties': {
            'token': {
                'type': 'string',
                'pattern': '^[0-9a-f]{64}$'
            }
        },
        'required': ['token']
    }

    try:
        validate(request.json, schema)
    except ValidationError as e:
        session.close()
        frame = inspect.currentframe()
        abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})

    user = session.query(User).filter(
        User.code == api_basic_auth.username()).one()
    user.token = request.json['token']

    session.commit()
    session.close()

    return jsonify({'msg': 'OK'}), 200
Beispiel #38
0
def delete_post_post(post):
    posts= session.query(Post)
    posts= posts[post]

    session.delete(posts)
    session.commit()
    return redirect(url_for("posts"))
Beispiel #39
0
def save_to_database(data):
    try:
        user = session.query(User).filter_by(id=str(data['user']['id'])).one()
    except NoResultFound:
        user = create_user_helper(data['user'])
        session.add(user)

    hashtag_results = []
    hashtags = data['entities']['hashtags']
    for hashtag in hashtags:
        hashtag = hashtag['text'].lower()
        try:
            hashtag_obj = session.query(Hashtag).filter_by(text=hashtag).one()
        except NoResultFound:
            hashtag_obj = Hashtag(text=hashtag)
            session.add(hashtag_obj)

        hashtag_results.append(hashtag_obj)

    tweet = create_tweet_helper(data, user)

    for hashtag in hashtag_results:
        tweet.hashtags.append(hashtag)

    session.add(tweet)
    session.commit()
Beispiel #40
0
def post_put(id):
    """ Updating or editing a single post endpoint """
    # Get the post from the database
    post = session.query(models.Post).get(id)

    # Check whether the post exists
    # If not return a 404 with a helpful message
    if not post:
        message = "Could not find post with id {}".format(id)
        data = json.dumps({"message": message})
        return Response(data, 404, mimetype="application/json")

    data = request.json

    # Check that the JSON supplied is valid
    # If not we return a 422 Unprocessable Entity
    try:
        validate(data, post_schema)
    except ValidationError as error:
        data = {"message": error.message}
        return Response(json.dumps(data), 422, mimetype="application/json")

    # Add the post to the database
    post = models.Post(title=data["title"], body=data["body"])
    session.add(post)
    session.commit()

    # Return the post as JSON
    data = json.dumps(post.as_dictionary())
    headers = {"Location": url_for("post_get", id=post.id)}
    return Response(data, 201, headers=headers,
                    mimetype="application/json")
Beispiel #41
0
def add_account(bot, update, args, user_data):
    if len(args) == 1:
        phone_number = args[0]
        user = session.query(User).filter(
            User.tg_id == update.message.chat_id).first()
        tg_sessions = session.query(TelegramSession).filter(
            TelegramSession.user == user).all()
        phone_numbers = [s.phone_number for s in tg_sessions]
        if phone_number in phone_numbers:
            update.message.reply_text(
                "Sorry, this phone number already exists.")
            return ConversationHandler.END
        client = TelegramClient(
            os.path.join(config.TELETHON_SESSIONS_DIR, phone_number),
            user.api_id if user.api_id else config.TELEGRAM_API_ID,
            user.api_hash if user.api_hash else config.TELEGRAM_API_HASH)
        client.connect()

        result = client.send_code_request(phone_number, force_sms=True)
        client.disconnect()
        tg_session = TelegramSession(phone_number=phone_number,
                                     phone_code_hash=result.phone_code_hash,
                                     user=user)
        session.add(tg_session)
        session.commit()
        user_data['session_id'] = tg_session.id
        update.message.reply_text("Please, send the login code to continue")

        return LOGIN_CODE
    else:
        update.message.reply_text("Please, include the phone number to this "
                                  "command.")
        return ConversationHandler.END
Beispiel #42
0
def newItem():
    """Render a page that displays an HTML form to create a new item

    Renders a page with an HTML form. When the form is submitted a
    new item is created in the database with the form values submitted.
    """
    formList = session.query(Medium).all()
    if request.method == 'POST':
        newItem = ArtItem(
            name=request.form['name'],
            description=request.form['description'],
            material=request.form['material'],
            image_url=request.form['image_url'],
            video_url=request.form['video_url'],
            year=request.form['year'],
            medium_id=request.form['medium'],
            user_id=login_session['user_id']
        )
        session.add(newItem)
        session.commit()
        return redirect(url_for('showForms'))
    else:
        return render_template(
            'new-item.html',
            media=formList,
            userinfo=login_session
        )
Beispiel #43
0
def confirm_tg_account(bot, update, user_data):
    code = update.message.text
    tg_session = session.query(TelegramSession).filter(
        TelegramSession.id == int(user_data['session_id'])).first()
    user = session.query(User).filter(
        User.tg_id == update.message.chat_id).first()
    client = TelegramClient(
        os.path.join(config.TELETHON_SESSIONS_DIR, tg_session.phone_number),
        user.api_id if user.api_id else config.TELEGRAM_API_ID,
        user.api_hash if user.api_hash else config.TELEGRAM_API_HASH)
    client.connect()

    try:
        client.sign_in(tg_session.phone_number,
                       code,
                       phone_code_hash=tg_session.phone_code_hash)
        tg_session.active = True
        update.message.reply_text('Account added successfully.')
    except Exception as e:
        update.message.reply_text('Error: {}.'.format(e))
        path = os.path.join(config.TELETHON_SESSIONS_DIR,
                            '{}.session'.format(tg_session.phone_number))
        if os.path.exists(path):
            os.remove(path)
        session.delete(tg_session)

    session.commit()

    client.disconnect()

    return ConversationHandler.END
Beispiel #44
0
def update_song(id):
    """ Updating a single song """

    # check if the song exists, if not return a 404 with a helpful message
    song = session.query(models.Song).get(id)
    if not song:
        message = "Could not find song with id {}".format(id)
        data = json.dumps({"message": message})
        return Response(data, 404, mimetype="application/json")

    data = request.json

    # check that the JSON supplied is valid
    # if not, return a 422 Unprocessable Entity
    try:
        validate(data, song_schema)
    except ValidationError as error:
        data = {"message": error.message}
        return Response(json.dumps(data), 422, mimetype="application/json")

    song.song_file = data["song_file"]
    session.commit()

    # return an OK 200, containing the song as JSON with the
    # location header set to the location of the post
    data = json.dumps(song.as_dictionary())
    headers = {"Location": url_for("post_get", id=song.id)}
    return Response(
        data, 200, headers=headers,
        mimetype="application/json"
    )
Beispiel #45
0
def send_email(**kwargs):
    from_address = FROM_ADDR
    to_address = kwargs.get('email')

    user_id = session.query(User.id).filter(User.email == to_address).first()
    if not user_id:
        raise ValueError("Enter Valid Email")

    msg = MIMEMultipart('alternative')
    msg['Subject'] = SUBJECT
    msg['From'] = from_address
    msg['To'] = to_address

    text = "Your Account for "+ to_address + " is successfully created \n \n Thanks \n Flask Blog"
    p1 = MIMEText(text, 'plain')

    msg.attach(p1)

    s = smtplib.SMTP('smtp.gmail.com', 587)
    s.starttls()
    s.login("*****@*****.**", "Pankaj154!")
    s.sendmail(from_address, to_address, msg.as_string())
    s.quit()

    email_obj = SystemEmailLog(
        user_id=user_id,
        from_address=from_address,
        to_address=to_address,
        cc=CC,
        subject=SUBJECT,
        message_body=kwargs,
        status=1
    )
    session.add(email_obj)
    session.commit()
Beispiel #46
0
def set_city_state(message, user, is_entry=False):
    if is_entry:
        bot.send_message(
            message.chat.id,
            DICTIONARY[user.language]['set_city_msg'],
            reply_markup=get_skip_keyboard(language=user.language))
    else:
        if message.text == DICTIONARY[user.language]['skip_btn']:
            bot.send_message(message.chat.id,
                             DICTIONARY[user.language]['signed_up_msg'])
            return True, 'main_menu_state'
        else:
            # check if given city exists in database
            current_cities = session.query(City.name).all()
            current_cities = [i for obj in current_cities for i in obj]
            if message.text in current_cities:
                user.city = message.text
                session.commit()
                bot.send_message(message.chat.id,
                                 DICTIONARY[user.language]['signed_up_msg'])
                return True, 'main_menu_state'
            else:
                bot.send_message(message.chat.id,
                                 DICTIONARY[user.language]['no_city_msg'])
                return True, 'main_menu_state'

    return False, ''
Beispiel #47
0
def session_clear(exception):
    if exception and session.is_active:
        session.rollback()
    else:
        session.commit()

    session.close()
Beispiel #48
0
def language_update_handler(user: User, update: Update,
                            context: CallbackContext):
    if update.message.text == get_language_token(user.language,
                                                 Tokens.LANGUAGE_ENGLISH):
        user.language = "en"
        session.commit()
        del context.user_data["state"]
        update.message.reply_text(
            get_language_token(user.language,
                               Tokens.LANGUAGE_CHANGE_SUCCESSFUL),
            parse_mode=telegram.ParseMode.MARKDOWN,
            reply_markup=get_main_keyboard_markup(user.language))
    elif update.message.text == get_language_token(user.language,
                                                   Tokens.LANGUAGE_TURKISH):
        user.language = "tr"
        session.commit()
        del context.user_data["state"]
        update.message.reply_text(
            get_language_token(user.language,
                               Tokens.LANGUAGE_CHANGE_SUCCESSFUL),
            parse_mode=telegram.ParseMode.MARKDOWN,
            reply_markup=get_main_keyboard_markup(user.language))
    else:
        update.message.reply_text(
            get_language_token(user.language,
                               Tokens.PLEASE_SELECT_VALID_LANGUAGE),
            parse_mode=telegram.ParseMode.MARKDOWN,
            reply_markup=get_language_selection_keyboard_markup(user.language))
Beispiel #49
0
def _update_sets(api, session, tweet_set, start_num):
    """
    Broke out a helper method so we didn't have to repeat the code for our
    last set.

    This helper method does the heavy lifting for us
    """
    # Grab out just the tweet ids using a list comprehension
    tweet_ids = [tweet.tid for tweet in tweet_set]
    # Using the tweepy api, grab the updated tweets
    # `trim_user` drops user data
    updated_set = api.statuses_lookup(tweet_ids, trim_user=True)

    # iterate through update set
    for updated_tweet in updated_set:
        # the values we want to update
        fav_count = updated_tweet.favorite_count
        retweet_count = updated_tweet.retweet_count

        # Get the old tweet using it's twitter id (tid for short)
        tid = updated_tweet.id
        database_tweet = session.query(Tweet).filter_by(tid=tid).one()

        # update the tweet information in our database
        database_tweet.favorite_count = fav_count
        database_tweet.retweet_count = retweet_count

        # User feedback
        print('index: {}'.format(database_tweet.id))
        print('favs: {} \t retweets: {}'.format(fav_count, retweet_count))

    # save our changes to the database
    session.commit()
Beispiel #50
0
def populate_movies():
    movies = request.json

    if movies is None:
        return make_response(
            jsonify({
                'message': 'error populating movies, body is required',
                'status': 500
            }), 500)

    for movie in movies:
        new_movie = Movie(title=movie['title'],
                          description=movie['description'],
                          genre_id=movie['genre_id'])
        session.add(new_movie)

    try:
        session.commit()
    except Exception as e:
        return make_response(
            jsonify({
                'message': 'error populating movies, {}'.format(str(e)),
                'status': 500
            }), 500)

    return make_response(
        jsonify({
            'message': 'movies populated',
            'status': 201
        }), 201)
Beispiel #51
0
def song_post():
  """ add a new song """
  data = request.json
  
  # Check that the JSON supplied is valid
  # If not you return a 422 Unprocessable Entity
  try:
    validate(data, song_schema)
  except ValidationError as error:
    data = {"message": error.message}
    return Response(json.dumps(data), 422, mimetype="application/json")
  
  # Get the file from the database
  file = session.query(models.File).get(data["file"]["id"])
  
  # If the file does not exist, respond with a 404
  if not file:
    message = "Could not find file with id {}".format(data["file"]["id"])
    data = json.dumps({"message": message})
    return Response(data, 404, mimetype="application/json")    
  
  # Add the new song to the database
  song = models.Song(file=file)
  session.add(song)
  session.commit()
  
  # Return a 201 Created, containing the song as json
  data = json.dumps(song.as_dictionary())
  headers = {"Location": url_for("song_get", id=song.id)}
  return Response(data, 201, headers=headers, mimetype="application/json")
Beispiel #52
0
def songs_post():
    """ Post a new song to database """

    data = request.json

    # Check for valid JSON. If not available, return 422, Unprocessable Entity
    try:
        validate(data, post_schema)
    except ValidationError as error:
        data = json.dumps({"message": error.message})
        return Response(data, 422, mimetype="application/json")

    file_id = data["file"]["id"]
    song_file = session.query(models.File).get(file_id)

    if not song_file: # File with id = file_id is not in database
        message = "Could not find song file with file id {}".format(file_id)
        data = json.dumps({"message": message})
        return Response(data, 404, mimetype="application/json")
        
    song = models.Song(file_id=file_id)
    session.add(song)
    session.commit()
    data = json.dumps(song.as_dictionary())
    return Response(data, 201, mimetype="application/json")
Beispiel #53
0
def get_request_error_results(**kwargs):
    q_list = []
    if kwargs['product_category'] == 'HOTELS':
        q_list = queries.hotel_queries
    elif kwargs['product_category'] == 'FLIGHTS':
        q_list = queries.flight_queries
    else:
        q_list = queries.car_queries

    for q in q_list:
        try:
            q['query'] = q['query'].format(**kwargs)
            data = get_data(q['query'])
        except vp.errors.QueryError as e:
            data = [{'error': e.error_response.error_message()},{'error': e.sql}]
        for row in data:
            for key in row:
                row[key] = str(row[key])
        result = RequestErrorResult(result=json.dumps({'name': q['name'], 'description': q['description'], 'query': q['query'], 'data': data}), 
                                    request_id=kwargs['request_id'])
        session.add(result)
        session.commit()
    final = RequestErrorResult(result=json.dumps({'data':[{"end": "end"}]}), 
                               request_id=kwargs['request_id'])
    session.add(final)
    session.commit()
def file_post():
	#try to access uploaded file from Flask's request.files dictionary
	file = request.files.get("file")
	if not file:
		data = {"message": "Could not find file data"}
		return Response(json.dumps(data), 422, mimetype="application/json")

	#secure_filename() --> function(from Werkzeug) which creates a safe version of the filename supplied by client
	filename = secure_filename(file.filename)
	#use the secure filename to create a File object and add it to the database and commit
	db_file = models.File(filename=filename)
	session.add(db_file)
	session.commit()
	#save file to an upload folder using our upload_path() function
	file.save(upload_path(filename))

	#return file information
	data = db_file.as_dictionary()

	"""View how data above looks
	print ("file data from file_post() is {}".format(data))
	print ("")
	print("Response data is {}".format(json.dumps(data)))
	"""
	return Response(json.dumps(data), 201, mimetype="application/json")
Beispiel #55
0
def update_song(id):
  """ Single song update endpoint """
  
  # get the song from the database
  song = session.query(models.Song).get(id)
  
  # cehck if the song exisits
  # if not return a 404 with a helpful message
  if not song:
    message = "Could not find the song with id {}".format(id)
    data = json.dumps({"message": message})
    return Response(data, 404, mimetype="application/json")
    
  data = request.json
  
  # check that the JSON supplied is valid
  # if not return a 422 Unprocessable Entry
  try:
    validate(data, song_schema)
  except ValidationError as error:
    data = {"message": error.message}
    return Response(json.dumps(data), 422, mimetype="application/json")
    
  song.song_file_id = data["file"]["id"]
  session.commit()
  
  # return an OK 200
  # containing the song as JSON and with the
  # location header set to the location of the song
  data = json.dumps(song.as_dictionary())
  headers = {"Location": url_for("song_get", id=song.id)}
  return Response(data, 200, headers=headers, mimetype="application/json")
Beispiel #56
0
def update_post(id):
    """ Single post update endpoint """

    # Get the post from the database
    post = session.query(models.Post).get(id)

    # Check if the post exists
    # If not return a 404 with a helpful message
    if not post:
        message = "Could not find the post with id {}".format(id)
        data = json.dumps({"message": message})
        return Response(data, 404, mimetype="application/json")

    data = request.json

    # Check that the JSON supplied is valid
    # If not you return a 422 Unprocessable Entity
    try:
        validate(data, post_schema)
    except ValidationError as error:
        data = {"message": error.message}
        return Response(json.dumps(data), 422, mimetype="application/json")

    post.title = data["title"]
    post.body = data["body"]
    session.commit()

    # return an OK 200, containing the post as JSON and with the
    # location header set to the location of the post
    data = json.dumps(post.as_dictionary())
    headers = {"Location": url_for("post_get", id=post.id)}
    return Response(data, 200, headers=headers, mimetype="application/json")
Beispiel #57
0
async def update_tasks(tasks: List[Task]):
    for new_task in tasks:
        task = session.query(TaskTable).filter(
            TaskTable.id == new_task.id).first()
        task.title = new_task.title
        session.commit()
        session.close()
Beispiel #58
0
def posts_put():
    """  Endpoint to post blog posts """

    # Construct the request data object
    data = request.json
    
    # First validate data object is valid JSON
    # If not valid return 422 error
    try:
        validate(data, post_schema)
    except ValidationError as error:
        data = {"message": error.message}
        return Response(json.dumps(data), 422, mimetype="application/json")        

    
    # Create data object from the request 
    data = request.json

    # Post data object to database
    post = models.Post(title=data["title"], body=data["body"])
    session.add(post)
    session.commit()

    # Response to client of successful post
    data = json.dumps(post.as_dictionary())
    headers = {"Location": url_for("post_get", id=post.id)}
    return Response(data, 201, headers=headers,
                    mimetype="application/json")
Beispiel #59
0
def add_poi_post():
    form = POIForm(request.form)
    if form.validate():
        location = session.query(POI).filter_by(address=form.address.data).first()
        if location:
            flash('That location is already in the database!', 'warning')
            return redirect(url_for('add_poi_get'))
        lat, lng = geocode(form.address.data)
        if lat and lng:
            poi = POI(name=form.name.data,
                category=form.category.data,
                address=form.address.data,
                latitude=lat,
                longitude=lng,
                desc=form.desc.data)
            session.add(poi)
            session.commit()
            user = session.query(User).get(int(current_user.get_id()))
            user.poi_assocs.append(UserPOI(poi=poi, upvote=1))
            session.commit()
            flash('You added a new place!', 'success')
            return redirect(url_for('index'))
        else:
            flash('Google Maps could not find that address. Try again!',
                'warning')
            return render_template('add_poi.html', form=form)

    else:
        flash_errors(form)
        return render_template('add_poi.html', form=form)