def search_action(self): entry = SearchRecord() form = SearchCreateForm(self.request.POST) if self.request.method == 'POST' and form.validate(): uuid = self.searchid keywords = form.data['keywords'] entry.id = uuid entry.keywords = keywords entry.pfams = form.data['pfams'] self.request.dbsession.add(entry) return HTTPFound(location=self.request.route_url( 'results', slug=urlify(keywords), searchid=uuid)) return dict()
def view_results(self): def convert_results_to_display(results): data = [] if len(results) == 0: return None for res in results: print('#####') print(res.patent_title) data.append((res.patent_title, 'US' + str(res.patent_number), res.patent_abstract)) return data # gets search parameters from webform keywords, pfams = retrieve_search(self.request) # submits search to patentview response = search_patentview(keywords, verbose=True) # populates the search table with results r = pop_temp_search_table(self.request, response, self.searchid) # filter results against domain information results = query_and_filter_database(self.request, pfams=pfams) results = results.all() data = convert_results_to_display(results) if data: page = {'name': 'Results', 'creator': 'Jake', 'data': data} else: # TODO change this so it redirects to a standard "no results" page data = [( '', '', 'There are no results for these search terms. Please try again.' )] page = {'name': 'Results', 'creator': 'Jake', 'data': data} return HTTPFound(location=self.request.route_url( 'no-results', searchid=self.searchid, slug=urlify(keywords))) return dict(page=page)
def search_action(self): """ This function creates a search id, record, and redirects to the results page. """ # create search record entry = SearchRecord() form = SearchCreateForm(self.request.POST) if self.request.method == 'POST' and form.validate(): # create unique search id uuid = self.searchid # extract keyword arguments from the web form keywords = form.data['keywords'] entry.id = uuid entry.keywords = keywords # extract the pfams from the web form if form.data['pfams']: entry.pfams = form.data['pfams'] else: entry.pfams = 'PF07686' # default pfam is the v-set self.request.dbsession.add(entry) # populate the database entry return HTTPFound(location=self.request.route_url( 'results', slug=urlify(keywords), searchid=uuid)) return dict()
def slug(self): return urlify(self.username)
def register_through_xhr(request): req_body = request.params first_name = req_body.get('firstName') last_name = req_body.get('lastName') username = req_body.get('username') password = request.params.get('password') email = req_body.get('email') phone = req_body.get('phone') sex = req_body.get('sex') birth_date = req_body.get('birthDate') birth_month = req_body.get('birthMonth') birth_year = req_body.get('birthYear') country = req_body.get('country') sub_unit = req_body.get('subUnit') profile_pic = req_body.get('profilePic', None) categories = req_body.get('categories', None) categories_list = categories.split(',') category_subs = [] try: new_user = User() new_user.first_name = first_name new_user.last_name = last_name new_user.email = email new_user.set_password(password) new_user.username = username new_user.phone_number = str(phone) new_user.sex = sex new_user.birth_date = int(birth_date) new_user.birth_month = birth_month new_user.birth_year = int(birth_year) new_user.country = int(country) new_user.sub_unit = int(sub_unit) if profile_pic != None: try: if profile_pic.file != None: pic_file = profile_pic.file pic_name = "{}".format(uuid.uuid4()) uploaded_pic = upload_profile_picture(pic_file, pic_name) new_user.profile_picture = uploaded_pic['secure_url'] except: print('we') request.dbsession.add(new_user) request.dbsession.flush() new_user.slug = urlify(new_user.full_name) for category in categories_list: new_sub = CategorySubscriber() new_sub.category_id = int(category) new_sub.user_id = new_user.id new_user.subscriptions.append(new_sub) #redis redis_category_subscription = CategorySubscription(int(category)) redis_category_subscription.add_subscriber(new_user.id) transaction.commit() except Exception as e: request.response.status = '400' return {'status': e} else: request.response.status = '200' return {'success': 'success'}
def generate_blog_post_slug(mapper, connect, target): if not target.slug: target.slug = urlify(target.title)
def url(self): return '/blog/{0}'.format(self.slug or urlify(self.title))
def create_poll(request): body = request.params question = body.get('question', None) poser = request.user.id info = body.get('info', None) options = body.get('options', None) option_images = body.getall('optionImage') option_image_titles = body.getall('option') duration = body.get('timeDue', None) categories = body.get('categories', None) context_image = body.get('context-image', None) options_list = [] poll_categories_list = [] if categories: categories = categories.split(',') if options: options = options.split(',') new_poll = Poll() new_poll.poser = poser if not question: request.response.status = '500' return 00 new_poll.question = question new_poll.info = info slug = urlify(question) #new_poll.slug = slug try: if context_image != None: image_file = context_image.file image_name = "{}".format(uuid.uuid4()) uploaded_image = add_image_description(image_file, image_name) new_poll.info_image_link = uploaded_image['secure_url'] except: print("noting") if duration: now = datetime.datetime.utcnow() year = now.year day = now.day + int(duration) month = now.month hour = now.hour minute = now.minute second = now.second microsecond = now.microsecond try: new_poll.end_time = datetime.datetime(year, month, day, hour, minute, second, microsecond) except: day = 1 month += 1 finally: new_poll.end_time = datetime.datetime(year, month, day, hour, minute, second, microsecond) if option_images != None or len(option_images) > 0: for i, option_image in enumerate(option_images): try: try: image_file = option_image.file except: request.response.status = '400' return {'eorror': option_image} image_name = '{}'.format(uuid.uuid4()) uploaded_image = add_image_description(image_file, image_name) uploaded_image_link = uploaded_image['secure_url'] new_option = Option() new_option.title = option_image_titles[i] new_option.image_link = uploaded_image_link options_list.append(new_option) except Exception as e: request.response.status = '400' return {'status': e} if option_image_titles == []: for option in options: if option != '': new_option = Option() new_option.title = option options_list.append(new_option) new_poll.options = options_list request.dbsession.add(new_poll) request.dbsession.flush() for category in categories: new_poll_category = PollCategory() new_poll_category.poll_id = new_poll.id new_poll_category.category_id = int(category) category = request.dbsession.query(Category).filter( Category.id == int(category)).first() category.polls.append(new_poll_category) poll_categories_list.append(new_poll_category) #add to redis category new_poll.categories = poll_categories_list request.dbsession.add(*poll_categories_list) new_activity = ActivityService(request, 'poll', request.user, new_poll) new_activity.create_new_activity() new_activity = new_activity.get_activity() RedisCategoryTimelineStorage.add_to_many(categories, new_activity.id) transaction.commit() return {}
def slug(self): """ This function makes a readable URL. """ return urlify(self.title)
def slug(self): return urlify(self.title)
def slug(self): return urlify(self.question)
def slug(self): return urlify(self.subject)
def slug(self): """ Create a human readable slug that makes it easy to read the URL. """ return urlify(self.title)
def slug(self): """ Create a slug for the URL that the user should be able to read. """ return urlify(self.subject)
def add_success(self, values): doc = Document(**values) name = urlify(doc.title) self.context[name] = doc return HTTPFound(self.request.resource_url(doc))
def add_success(self, values): image = PersistentImage(values['title'], values['data']['fp'].read()) name = urlify(image.title) self.context[name] = image return HTTPFound(self.request.resource_url(image))
def slug(self): """ There should be a nice readable URL slug when the user visits. """ return urlify(self.username)
def slug(self): """ Create a human readable URL for when a user visits. """ return urlify(self.title)