def create_post(): post_data = request.get_json(force=True, silent=True) if post_data == None: return "Bad request", 400 post = Post(post_data["title"], post_data["content"]) post.save() return json.dumps(post.to_dict()), 201
def __from_dynamo(item: dict) -> Post: return Post(name=item["name"]["S"], text=item["text"]["S"], post_id=item["post_id"]["S"], timestamp=item["timestamp"]["S"], img_url=item["img_url"]["S"], tags=item.get("tags", {}).get("SS"))
def create_post(): post_data = request.get_json(force=True, silent=True) if post_data == None: return "Bad request", 400 post = Post(get_id(), post_data["title"], post_data["content"]) POSTS[post.id] = post return json.dumps(post.to_dict()), 201
def new_post(self): title = input("Enter post title:") content = input("Enter post:") date = input("Enter date or leave for today(ddmmyyyy):") post = Post(self.author,title,content,self.id,datetime.datetime.strptime(date,"%d%m%Y")) post.save_to_mongo()
def create_post(): post = Post() try: data = request.get_data() data = json.loads(data) post.title = data['title'] post.content = data['content'] post.category_id = data['category_id'] tags = data['tags'] post.region = data['region'] post.image_header_id = data['image_header_id'] except Exception: raise ServiceException(ErrorCode.PARAM_ERROR, 'param error') tag_ids = [] if tags is not None and tags != '': tags = tags.split(",") for tag_name in tags: try: tag = GroupService.get_tag_by_name(tag_name) except ServiceException: tag = GroupService.insert_tag(tag_name) tag_ids.append(str(tag.id)) post.tag_ids = ",".join(tag_ids) post = PostService.insert_post(post) return jsonify(json_resp(data=model2dict(post)))
def create(self, request, *args, **kwargs): try: serializer = self.get_serializer(data=request.data) if serializer.is_valid(): # 대댓글을 달 post, comment 확인 post_id = kwargs["post_id"] comment_id = kwargs["comment_id"] comment = Comment.objects.filter(id=comment_id, post_id=post_id, depth=1).first() if comment: sequence_max = Comment.objects.filter( group=comment.group, post_id=post_id).aggregate(Max('sequence')) sequence = sequence_max["sequence__max"] + 1 post = Post(id=post_id) Comment.objects.create(post=post, sequence=sequence, depth=2, group=comment.group, **request.data) return Response(status=200, data=serializer.data) else: # 데이터 없음 return Response(status=400, data="데이터 없음") else: return Response(status=400) except Exception as e: print(e) return Response(status=500)
def init_db(): session = Session() file = open('example.json', 'r', encoding='utf-8') data = json.load(file) file.close() for user in data['Users']: item = User(username=user['username']) session.add(item) for section in data['Sections']: item = Section(title=section['title']) session.add(item) for post in data['Posts']: item = Post(title=post['title'], section_id=post['section_id'], user_id=post['user_id'], description=post['description']) session.add(item) for tag in data['Tags']: item = Tag(name=tag['name'], post_id=tag['post_id']) session.add(item) session.commit() session.close()
def get(self, id): query = ( "SELECT id, publish_date, length, user, topic, thread, hash " "FROM post WHERE id=%s") cursor = self.db.cursor(query, (id)) sql_result = cursor.fetchone() cursor.close() post = Post(sql_result[1], sql_result[2], sql_result[3], sql_result[4]) post.id = sql_result[0] post.hash = sql_result[5] return post
def post(self, id): subject = self.request.get('subject') content = self.request.get('content') if subject and content: post = Post(subject=subject, content=content) key = post.put() self.redirect('/blog/' + str(key.id())) else: self.render_form(content, subject, 'Both a subject and content must be present')
def deleteURL(): if not session["logged_in"]: return redirect(url_for("index")) if request.method == 'POST': id = request.form['id'] post = Post(session["username"]) post.delete(id) return "Success"
def blog(): form = PostForm() if current_user.can(Permission.WRITE_ARTICLES) and \ form.validate_on_submit(): post = Post(title=form.title.data, body=form.body.data, author=current_user._get_current_object()) db.session.add(post) db.session.commit() return redirect(url_for('blog.index')) return render_template('blog.html', form=form)
def setUp(self): self.testapp = webtest.TestApp(app) self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() self.testbed.init_memcache_stub() # Set up some initial users valid_user = User(id="Valid User", password="******") self.valid_user_key = valid_user.put() invalid_user = User(id="Invalid User", password="******") self.invalid_user_key = invalid_user.put() valid_liker = User(id="Valid Liker", password="******") self.valid_liker_key = valid_user.put() invalid_liker = User(id="Invalid Liker", password="******") self.invalid_liker_key = invalid_user.put() # Set up an initial post initial_post = Post(title="Test Post", content="Some content", submitter="Valid User") self.initial_post_key = initial_post.put() initial_post_to_like = Post(title="Test Post", content="Some content", submitter="Invalid Liker") self.initial_post_to_like_key = initial_post_to_like.put() # Set up some other posts Post(title="Test Post A", content="Some content", submitter="Invalid Liker").put() Post(title="Test Post B", content="Some content", submitter="Valid User").put() Post(title="Test Post C", content="Some content", submitter="Valid User").put()
def updateURL(): if not session["logged_in"]: return redirect(url_for("index")) if request.method == 'POST': id = request.form['id'] status = request.form['status'] post = Post(session["username"]) post.updateStatus(id, status) return "Success"
def post(self, user_id): """ Make a new post """ args = postParser.parse_args() content = args['content'] profile = Profile.objects(user=user_id).first() post = Post(user=user_id, user_profile=profile, content=content) post.save() return {'status': 'success'}
def add_new_post_service(title, body, tags=None): # cannot add two posts with the same title if Post.objects(title=title).first() is None: current_user = get_jwt_identity() new_post = Post(title=title, body=body, tags=tags, author=get_user_id(current_user)) new_post.save() return jsonify(new_post) else: return Response("Post with that title already exist!", status=409)
def post(self): titulo = self.request.get("edTitulo", "") autor = self.request.get("edAutor", "") contenido = self.request.get("edContenido", "") if (not titulo or not autor or not contenido): return self.redirect("/home") else: post = Post(titulo=titulo, contenido=contenido, autor=autor) post.put() time.sleep(1) return self.redirect("/home")
def get(self, **kwargs): template = jinja_env.get_template('new-post.html') post = Post().get_by_id(int(kwargs['post_id'])) self.write( template, { 'form': { 'title': post.title, 'content': post.content }, 'new': False, 'post_id': kwargs['post_id'] })
def create_post(): if request.method == 'GET': return render_template("new_post.html") elif request.method == 'POST': post_data = request.get_json(force=True, silent=True) if post_data == None: return "Bad request", 400 post = Post(post_data["title"], post_data["content"], post_data["price"], post_data["post_date"], post_data["available"], post_data["buyer"]) post.save() return redirect('/api/posts')
def addURL(): if not session["logged_in"]: return redirect(url_for("index")) if request.method == 'POST': url = request.form['url'] post = Post(session["username"]) count = len(post.get(user_id=session["user_id"]).all()) if count < post.limit: status = post.add(url) return status
def comment(self, request, *args, **kwargs): serializer = CommentSerializer(data=request.data) if serializer.is_valid(): # 댓글을 달 post 번호 post_id = kwargs["pk"] # 그룹 번호 갱신 group_max = Comment.objects.all().aggregate(Max('group')) group = group_max["group__max"] + 1 post = Post(id=post_id) Comment.objects.create(post=post, group=group, **request.data) return Response(status=200) else: return Response(status=400)
def new_post(self): title = input("Enter post title") content = input("Enter post content") date = input( "Enter post date, or leave blank for today(in format ddmmyyyy): ") if (date == ""): date = datetime.datetime.utcnow() else: date = datetime.datetime.strptime(date, "%d%m%Y") post = Post(blog_id=self.id, title=title, content=content, author=self.author, date=date) # strp allows to give a format string post.save_to_mongo()
def add_post(title, body, publish_date, img, requires_login, author_id): date = datetime.now() if publish_date is None: publish_date = date else: publish_date = __parse_date(publish_date) requires_login = __parse_bool(requires_login.lower()) __validate_params(title, body, publish_date, requires_login) img_path = storage.upload_image_file(img, "post") post = Post(title, body, date, publish_date, img_path, requires_login, author_id) insert(post)
def post(self, **kwargs): title = self.request.POST['title'] content = self.request.POST['content'] submitter = self.request.cookies.get('user').split("|")[0] # Check that title and content are non-empty and add the data to the # datastore; otherwise, re-render the form with errors if title != '' and content != '': new_post = Post(title=title, content=content, submitter=submitter) new_post_key = new_post.put() new_post_id = new_post_key.id() self.redirect('/posts/%d' % new_post_id) else: template = jinja_env.get_template('new-post.html') form_data = {'title': title, 'content': content, 'error': True} self.write(template, {'form': form_data, 'new': True})
def new_post(self): title = input("Enter post title : ") content = input("Enter Post content : ") date = input( "Enter the post date or leave blank for today (in format DDMMYYYY)" ) if date == "": date = datetime.datetime.utcnow() else: date = datetime.datetime.strptime(date, "%d%m%Y") post = Post(blog_id=self.id, title=title, content=content, author=self.author, date=date) post.save_to_mongo()
def select_posts(self) -> List[Post]: """ Iterate the posts and select only posts that can be published. It selects posts that represent goal video and that are not already posted in the last hour. Returns: List[Post]: A list of posts that can be published. """ # Regex for goal posts pattern = re.compile( "^.* ([0-9]+|\[[0-9]+\])( )*-( )*([0-9]+|\[[0-9]+\]) .* ([0-9]+'|[0-9]+'\+[1-9]+')$" ) posts = [] # Put all goal post in a list. # It's a list of tuple. for post in self.posts_iterator: # Check if is a goal post if (pattern.match(post.title) is not None and post.link_flair_text == "Media"): text = "⚽ " + post.title + "\n\nVideo: " + post.url p = Post( post.id, datetime.datetime.fromtimestamp(post.created_utc, tz=datetime.timezone.utc), text, ) posts.append(p) one_hour_ago_ts = datetime.datetime.now( datetime.timezone.utc) - datetime.timedelta(hours=1) # Filter messages. Only messages not published in the last hour to_post = [ p for p in posts if p not in self.posted_last_hour and p.timestamp > one_hour_ago_ts ] # Remove post older than one hour self.posted_last_hour = [ p for p in self.posted_last_hour if p.timestamp > one_hour_ago_ts ] self.posted_last_hour = self.posted_last_hour + to_post # Save data posted if self.save_mng is not None: self.save_mng.save(self.posted_last_hour) return to_post
def redirect_if_not_author(*args, **kwargs): self = args[0] user_id = kwargs['user_id'] post_id = kwargs['post_id'] post = Post().get_by_id(int(post_id)) is_author = (post.submitter == user_id) # Perform is_author XOR invert to determine whether or not to # call the decorated function decorate = (is_author and not invert) or (not is_author and invert) if decorate: # Call the decorated function fn(*args, **kwargs) else: self.redirect('/posts/' + kwargs['post_id'])
def add_entry(): if not session.get('logged_in'): abort(401) html_content = markdown(request.form['content']) title = 'No title' if request.form['title'] is not "": title = request.form['title'] post = Post(title=title, content=html_content, date=time()) g.session.add(post) g.session.commit() flash("Added entry!") return redirect(url_for('show_entries'))
def populate_db(filename): engine = create_engine("sqlite:///{}".format(filename), echo=True) Session = sessionmaker() Session.configure(bind=engine) session = Session() default_post = Post(post_id=0, date=int(time()), title="Hello World", content="Welcome :)") session.add(default_post) user = User(user_id=0, username='******', real_name='Root Fairy', password_hash=sha1('password').hexdigest()) session.add(user) session.commit()
def get_posts(self, tags): """Gets all unique posts that have at least one of supplied tags Parameters ---------- tags : list(str) list of tags Returns ------- List(dictionaries) List of posts that have at least one of the supplied tags """ query_tags = copy.copy(tags) final_results = list() #caching functionality for tag in tags: cached_data = self.cache.get(tag) if cached_data != None: query_tags.remove(tag) final_results.append(cached_data) if len(query_tags) != 0: asyncio.set_event_loop(asyncio.new_event_loop()) loop = asyncio.get_event_loop() future = asyncio.ensure_future(self.get_tags(query_tags)) results = loop.run_until_complete(future) #add our new results into the cache for index in range(len(results)): self.cache.set(query_tags[index], results[index], ex=self.time_to_expire) final_results += results posts = list(map(lambda x: json.loads(x), final_results)) all_posts = [] for post in posts: object_form = list(map(lambda data: Post(data), post['posts'])) all_posts += object_form all_posts = list(set(all_posts)) return all_posts
def post(self): title = self.request.get('title') content = self.request.get('content') board = self.request.get('board') if title == '': self.error(400) else: author = getSecureUser(self.request) if (author is not None): # TODO: check if user is authorized to post in board newPost = Post(title=title, content=content, author=author, board=board) newPost.put() # TODO: redirect to post URL else: self.error(401)