def register_post(): form = RegistrationForm(request.form) if form.validate(): user = session.query(User).filter_by(username=form.username.data).first() if user: flash('That username is already in use', 'danger') return redirect(url_for('register_get')) user = session.query(User).filter_by(email=form.email.data).first() if user: flash('That email is already in use', 'danger') return redirect(url_for('register_get')) newuser = User(username=form.username.data, email=form.email.data, password=generate_password_hash(form.password.data) ) if form.fname.data and form.lname.data: newuser.realname = form.fname.data + form.lname.data elif form.fname.data: newuser.realname = form.fname.data elif form.lname.data: newuser.realname = form.lname.data session.add(newuser) session.commit() flash('Thanks for registering!', 'success') return redirect(url_for('login_get')) else: flash_errors(form) return render_template('register.html', form=form)
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")
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)
def authenticate_to_game(game_id): data = request.get_json(force=True) try: auth = authentication.Authentication() user_data = auth.user_from_identifier(data["authenticate"]["identifier"]) users = models.User.query.filter_by(username=user_data["username"]) if users.length > 0: # User is already registered user_id = users.first().id else: # User is not registered, register them register_user(user_data=user_data) user_id = models.User.query.filter_by(username=user_data["username"]).first().id game = models.Game.query.filter_by(id=game_id).first() score = models.Score(user_id=user_id, game_id=game.id) db.add(score) db.commit() response = return_success() except Exception as e: response = return_error(e) return jsonify(response)
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 )
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
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")
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() )
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")
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 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")
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")
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")
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(), )
def edit_post_post(id): post = session.query(Post).filter(Post.id == id).one() post.title = request.form["title"] post.content = mistune.markdown(request.form["content"]) session.add(post) session.commit() return redirect(url_for('posts'))
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() )
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 )
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() )
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")
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 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")
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")
def add_post_post(): post = Post( title=request.form["title"], content=mistune.markdown(request.form["content"]) ) session.add(post) session.commit() return redirect(url_for("posts"))
def register(): form = RegisterForm() if form.validate_on_submit(): user = User(email=form.email.data, password=form.password.data) session.add(user) session.commit() login_user(user, remember=True) return redirect("/") return render_template("register.html", form=form)
def edit_post_post(blogid=1): post = session.query(Post).filter(Post.id==blogid).first() post.title = request.form["title"] post.content = mistune.markdown(request.form["content"]) print 'post.title',post.title print 'post.content',post.content session.add(post) session.commit() return redirect(url_for("posts"))
def add_post_post(): post = Post( title=request.form["title"], content=request.form["content"], author=current_user, ) session.add(post) session.commit() return redirect(url_for("posts"))
def generatePreKeys(self): keyIdOffset = self.getNextPreKeyId() for i in range(0, self.BATCH_SIZE): keyId = (keyIdOffset + i) % self.MAX_PRE_KEY privkey, pubkey = genKey() session.add(PreKey(keyId=keyId, publicKey=pubkey, privateKey=privkey)) self.setNextPreKeyId((keyIdOffset + self.BATCH_SIZE) % self.MAX_PRE_KEY)
def edit_post_post(postId=None): post = session.query(Post).filter(Post.id==postId).all()[0] if (post.author.id != current_user.id): return redirect(url_for("posts")) post.title = request.form["title"] post.content = mistune.markdown(request.form["content"]) session.add(post) session.commit() return redirect(url_for("get_post", postId=post.id))
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'))
def add_post_post(): #create a new Post object post = Post( title=request.form["title"], content=mistune.markdown(request.form["content"]), ) #add post to our session and commit to database session.add(post) session.commit() return redirect(url_for("posts"))
def add_item(): if request.method == 'POST': user = getUserInfo(login_session['user_id']) category_name = request.form['genre'] category = session.query(Category).filter_by( name=str(category_name)).one() newItem = Item(title=request.form['title'], description=request.form['description'], category=category, user_id=login_session['user_id'], user=user) session.add(newItem) session.commit() flash("New item created!") return redirect(url_for('users.display_all')) else: return render_template('add_item.html')
def mutate(cls, instance, args, info): session.begin() new_comment = CommentModel( text = args.get('text'), user_id = args.get('user_id'), product_id = args.get('product_id'), ) session.add(new_comment) session.commit() return CreateComment( comment=Comment(new_comment), ok=True, )
def register_clock_in(user_id): """ Register clock in for a teacher. :param user_id: :return: True or False """ success = True try: spell = Spell(start=datetime.now()) spell.user_id = user_id session.add(spell) session.commit() except Exception as exc: success = False logger.exception(exc) return success
def signup(): form = RegisterForm() if form.validate_on_submit(): # check if user with same id exists hashed_password = generate_password_hash(form.password.data, method='sha256') new_user = User(email=form.email.data, username=form.username.data, password=hashed_password) session.add(new_user) session.commit() return redirect(url_for('.login')) # return '<h1>' + form.username.data + ' ' + form.email.data + ' ' + form.password.data + '</h1>' return render_template('signup.html', form=form)
def editAdopter(key): print "editAdopter: id = %s" % key edAdopter = session.query(Adopter).filter_by(id=key).one() if request.method == 'POST': edAdopter.name = request.form['name'] session.add(edAdopter) session.commit() return redirect(url_for('viewAdopter', key=edAdopter.id)) else: return render_template('edit.html', viewType="adopter", key=key, traits=edAdopter.traits)
def create_cluster(name_cluster, name_key, zone): """ :name_cluster: Name new cluster :name_key: Name connection strint to aws in table connection :awsAccessKeyId: Access key id for access to aws :awsSecretKeyId: Secret key id for access to aws """ logging.info("Creating cluster") try: session.add(ClusterTable(name_cluster, name_key, zone)) session.commit() except: logging.error("Error add cluster to table") session.rollback() raise return Cluster(name_cluster)
def deposit(): animal_type = session.query(AnimalType).filter(AnimalType.name == request.form['type']).first() if not animal_type: flash('Sorry, we do not accept animals of this type', 'danger') return redirect(url_for('animals_list')) animal = Animal(animal_type_id=animal_type.id, name=request.form['name'], weight=request.form['weight'], age=request.form['age']) try: session.add(animal) session.commit() except: flash('Error occured', 'danger') return redirect(url_for('animals_list'))
def post(self): """Create a new bucketlist.""" parser.add_argument('list_name', help='List name cannot be blank') arg = parser.parse_args() if arg['list_name']: list_name = arg['list_name'] else: return {'message': 'Invalid value passed.'} created_by = current_user.user_id bucketlistexist = session.query(BucketList).filter_by( list_name=list_name, creator=created_by).first() if bucketlistexist: return {'message': 'Bucketlist already exists'}, 400 else: bucketlist = BucketList(list_name=list_name, creator=created_by) session.add(bucketlist) session.commit() return marshal(bucketlist, bucketlists), 201
def on_message(self, room: Room, user: User, message: Message) -> None: """ Triggers upon every chat message to parse commands, validate users, and save chat logs. :param Room room: Chatango room. :param User user: User responsible for triggering command. :param Message message: Raw chat message submitted by a user. :returns: None """ chat_message = message.body.lower() user_name = user.name.title().lower() room_name = room.room_name.lower() self._check_blacklisted_users(room, user_name, message) self._get_user_data(room_name, user, message) self._process_command(chat_message, room, user_name, message) session.add( Chat(username=user_name, room=room_name, message=chat_message))
def generate_token(bot, update, args): if len(args) == 1: token_value = str(uuid.uuid4().hex) valid_until = datetime.datetime.now() + datetime.timedelta( days=int(args[0])) valid_until_f = valid_until.strftime('%m.%d.%Y') token = Token(value=token_value, valid_until=valid_until.date()) session.add(token) session.commit() update.message.reply_text("Here is the new token: \n\n" "```{}```\n\n" "Valid until: `{}`".format( token_value, valid_until_f), parse_mode=ParseMode.MARKDOWN) else: update.message.reply_text("Please, send me the number of days " "the token will be valid.")\
def put(self, list_id): """Modify existing bucketlist.""" try: bucketlist = _get_bucketlist(list_id) parser.add_argument('list_name') arg = parser.parse_args() if arg['list_name']: bucketlist.list_name = arg['list_name'] else: return {'message': 'Invalid value passed.'} session.add(bucketlist) session.commit() return { 'message': 'Bucketlist {} has been modified'.format(list_id) }, 202 except NoResultFound: return { 'message': 'Bucketlist {} has not been found'.format(list_id) }, 404
def submit_handler_3(user: User, update: Update, context: CallbackContext): todays_mwe = mwe_helper.get_todays_mwe(user.language) submit_category_1_submissions = [ get_language_token(user.language, Tokens.FORM_SPECIAL_MEANING_TOGETHER) % get_mwe_words(todays_mwe), get_language_token(user.language, Tokens.DOESNT_FORM_SPECIAL_MEANING_TOGETHER) % get_mwe_words(todays_mwe), ] if update.message.text in submit_category_1_submissions: if update.message.text == submit_category_1_submissions[0]: update.message.reply_text( get_language_token(user.language, Tokens.ARE_WORDS_SEPARATED) % get_mwe_words(todays_mwe), parse_mode=telegram.ParseMode.MARKDOWN, reply_markup=get_submit_category_2_keyboard_markup( user.language, todays_mwe)) context.user_data["state"] = "submit_example_type_2" else: submission = context.user_data["submission"] submission.category = "non-mwe" submission.users_who_reviewed = '' submission.user = user submission.language = user.language submission.mwe = todays_mwe session.add(submission) session.commit() del context.user_data["state"] del context.user_data["submission"] update.message.reply_text( get_language_token(user.language, Tokens.THANKS_FOR_SUBMISSION) % (get_random_congrats_message(user.language), 30), parse_mode=telegram.ParseMode.MARKDOWN, reply_markup=get_main_keyboard_markup(user.language)) else: update.message.reply_text( get_language_token(user.language, Tokens.ENTER_VALID_MWE_CATEGORY_1), parse_mode=telegram.ParseMode.MARKDOWN, reply_markup=get_submit_category_1_keyboard_markup( user.language, todays_mwe))
def create_quiz(quiz: schemas.CreateQuizRequest): """Create a new quiz """ new_quiz = models.Quiz(quiz.title, quiz.author) session.add(new_quiz) session.commit() for question in quiz.questions: new_question = models.Question(new_quiz.id, question.question_text, question.correct_answer, question.answer_one, question.answer_two, question.answer_three, question.answer_four) session.add(new_question) session.commit() session.refresh(new_quiz) return new_quiz
def edit_item(item_name): item = session.query(Item).filter_by(title=item_name).one() if item.user_id == login_session['user_id']: if request.method == 'POST': if request.form['title']: item.title = request.form['title'] if request.form['description']: item.description = request.form['description'] category_name = request.form['genre'] category = session.query(Category).filter_by( name=str(category_name)).one() item.category = category session.add(item) session.commit() flash("Item has been edited.") return redirect(url_for('users.display_all')) else: return render_template('edit_item.html', item_name=item.title) else: redirect(url_for('users.display_all'))
def support_menu_state(message, user, is_entry=False): if is_entry: bot.send_message( message.chat.id, DICTIONARY[user.language]['support_menu_msg'], reply_markup=get_back_keyboard(language=user.language)) else: if message.text == DICTIONARY[user.language]['back_btn']: return True, 'main_menu_state' else: support_request = SupportRequest(user_id=user.id, message=message.text[:300]) session.add(support_request) session.commit() bot.send_message( message.chat.id, DICTIONARY[user.language]['sent_support_request_msg']) return True, 'main_menu_state' return False, ''
def add_best_bets(): browser.get('https://sportsinsights.actionnetwork.com/best-bets/') time.sleep(7) a_s3 = browser.find_element_by_id('myTab1').find_elements_by_tag_name('a')[2] browser.execute_script('arguments[0].click()', a_s3) time.sleep(1) main_tab = browser.find_element_by_id('s3').find_elements_by_id('borderLayout_eRootPanel')[1] div_list = main_tab.find_element_by_class_name('ag-body-container').find_elements_by_css_selector( '.ag-row.ag-row-no-focus') for div in div_list: cell_list = div.find_elements_by_tag_name('div') new_best_bets = SportsInsightsBESTBETS(cell_list[0].get_attribute('innerHTML'), cell_list[1].get_attribute('innerHTML'), cell_list[2].get_attribute('innerHTML'), cell_list[3].get_attribute('innerHTML'), cell_list[4].get_attribute('innerHTML').replace( '<b>', '').replace('</b>', ''), cell_list[5].get_attribute('innerHTML')) session.add(new_best_bets) print(new_best_bets)
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())
def create_user(): form = NewUserForm(request.form) sys.stderr.write("FORM IS validated? %s \n" % form.validate()) if form.validate() and request.method == 'POST': flash("Successfully created user {}".format(form.username.data)) users = session.query(User).filter( User.username == form.username.data).all() if users: flash( "Username {} already exists; please choose a different username" .format(form.username.data)) else: new_user = User(username=form.username.data, password=form.password.data, is_admin=form.is_admin.data) session.add(new_user) session.commit() return redirect('index') elif request.method == 'POST': flash("Limit entries to 3-8 characters") return render_template('create_user.html', form=form, is_admin=is_admin)
def solve_n_queens(self): q = session.query(Queen).filter_by(n=self.N) number_of_solutions = -1 for x in q: number_of_solutions = x.number_of_solutions if number_of_solutions != -1: print("Number of solutions: ", number_of_solutions) return number_of_solutions else: k = 0 board = [0] * self.N queen = Queen(n=self.N, number_of_solutions=0) session.add(queen) session.commit() if self.find_solution(board, k) == False: print("There is not solution for this N") return False print("Number of solutions: ", self.solutions) queen.number_of_solutions = self.solutions session.commit() return self.solutions
def post(): # user_id # promise_id -1ならNone # created_at 2012-12-29 13:49:37の形式 user = session.query(User).filter( User.id == request.json['user_id']).one_or_none() promise = session.query(Promise).filter( Promise.id == request.json['promise_id']).one_or_none() motion = Motion() motion.user_id = user.id motion.promise_id = None if promise is None else promise.id motion.created_at = DT.strptime(request.json['created_at'], '%Y-%m-%d %H:%M:%S') session.add(motion) session.commit() session.close() return jsonify({'results': 'OK'}), 200
def post(self): data = Menu.parser.parse_args() #경로를 위한 변수 설정 server_path = '' data = request.form if 'category_pk' not in data.keys(): return Response(status = 404) if 'image' in request.files: #local_path 저장할 경로, server_path 이미지 접근 가능 url 저장 image = request.files['image'] local_path = os.path.join(saveImgDir, 'main/', secure_filename(image.filename)) image.save(local_path) server_path = os.path.join(serverImgDir, 'main/', secure_filename(image.filename)) main_menu = models.Menu() #request에 이미지 파일이 존재하면 객체 menu_image필드에 server_path 저장 if server_path != '': main_menu.menu_image = server_path for i in data.keys(): if i == 'category_pk': main_menu.category_pk = data['category_pk'] elif i == 'menu_name': main_menu.menu_name = data['menu_name'] elif i == 'menu_price': main_menu.menu_price = data['menu_price'] elif i == 'menu_soldout': main_menu.menu_soldout = data['menu_soldout'] elif i == 'menu_description': main_menu.menu_description = data['menu_description'] session.add(main_menu) session.flush() session.commit() session.close() return Response(status = 201)
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).filer_by(text=hashtag).one() except NoResutlFound: user = create_ 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()
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()
def test_get_all(): item1 = TodoItem(completed=False, text="Test item text") session.add(item1) item2 = TodoItem(completed=False, text="Test item two text") session.add(item2) item3 = TodoItem(completed=True, text="Test item three text") session.add(item3) session.flush() response = client.get("/todo/") actual = response.json() expected = { "status": "success", "data": [ { "id": item1.id, "completed": False, "text": "Test item text" }, { "id": item2.id, "completed": False, "text": "Test item two text" }, { "id": item3.id, "completed": True, "text": "Test item three text" }, ], } assert actual == expected
def file_post(): # Attempt to obtain the file uploaded file from Flask's request.files dict file = request.files.get("file") # If the file is not found, return an error if not file: data = {"message": "Could not find file data"} return Response(json.dumps(data), 422, mimetype="application/json") # Werkzeug secure_filename function provides safe version of file name # For instance ../../../etc/passwd is replaced by etc_passwd filename = secure_filename(file.filename) # Create file object with safe filename db_file = models.File(name=filename) # Add the file object to the session and commit session.add(db_file) session.commit() # Save the file to the upload path using the safe file name file.save(upload_path(filename)) # Create a dict object of file data = db_file.as_dictionary() # Return a response with 201 CREATED return Response(json.dumps(data), 201, mimetype="application/json")
def post(self): data = request.form server_path = '' print(3) if 'category_pk' not in data.keys(): return Response(status=404) if 'image' in request.files: image = request.files['image'] print(image.filename) local_path = os.path.join(saveImgDir, 'main/', secure_filename(image.filename)) image.save(local_path) print(local_path) server_path = os.path.join(serverImgDir, 'main/', secure_filename(image.filename)) main_menu = models.Menu() if server_path != '': main_menu.menu_image = server_path for i in data.keys(): if i == 'category_pk': main_menu.category_pk = data['category_pk'] elif i == 'menu_name': main_menu.menu_name = data['menu_name'] elif i == 'menu_price': main_menu.menu_price = data['menu_price'] elif i == 'menu_soldout': main_menu.menu_soldout = data['menu_soldout'] elif i == 'menu_description': main_menu.menu_description = data['menu_description'] session.add(main_menu) session.flush() session.commit() return Response(status=201)
def send_welcome(message): try: logger.debug(f"/start | user_id: {message.from_user.id}") user = session.query(User).filter_by(user_id=message.from_user.id).first() if user is None: user = User( user_id=message.from_user.id, username=message.from_user.username, first_name=message.from_user.first_name, last_name=message.from_user.last_name, state='login_state' ) session.add(user) session.commit() else: user.state = 'main_menu_state' session.commit() get_state_and_process(message, user, True) except Exception as e: logger.error(e, exc_info=True)
def cli(n, l): """ backup with 7zip and python Frederico Sales <*****@*****.**>. Use: bck -n backupname -l path/folder/.../folder """ _date = datetime.now _now = _date().strftime("_%d-%m-%Y_%H:%m.7z") config = ConfigParser() config.read(_Loc() + '/bck.cfg') if n != None and l != None: _bck = n + _now cmd = "7z a " + _bck + " " + l os.system(cmd) # md5sum md5sum = "md5sum " + _bck os.system(md5sum) # move backup to url _bck_path = config.get("BACKUP", "BACKUP_PATH") _mv = "mv " + os.getcwd() + "/" + _bck + " " + _bck_path os.system(_mv) # md5sum to db _file = _bck_path + "/" + _bck md = open(_file, 'rb').read() check = hashlib.md5(md).hexdigest() _bck_ = Backup(name=_bck, path=l, md5=check) session.add(_bck_) session.commit() session.close() click.echo('backup ends successfully.') else: click.echo('catastrophic failure.')
def post(self, list_id): """Add a new item to a bucketlist.""" try: bucketlist = _get_bucketlist(list_id) parser.add_argument('item_name') arg = parser.parse_args() if arg['item_name']: item = arg['item_name'] else: return {'message': 'Invalid value passed.'} bucketlistitem = BucketListItems(item_name=item, bucket_id=bucketlist.list_id) session.add(bucketlistitem) session.commit() return { 'message': '{0} has been added to Bucketlist {1}'.format(item, list_id) }, 201 except NoResultFound: return { 'message': 'Bucketlist does not exist'.format(list_id) }, 404
def posts_post(): """ 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") # add the post to the database post = models.Post(title=data["title"], 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")