def list_mp(list_id): list_ = List.get_by_id(list_id) list_ = List.get_by_id(list_.subscribed_by_id) mp = InlineKeyboardMarkup(row_width=1) for item in list_.items: if item.tag: s = "🔘 %s" % item.name else: s = "⚪ %s" % item.name mp.add( InlineKeyboardButton(s, callback_data="upd_list" + str(list_id) + "." + str(item.id))) if len(list_.items) > 0: mp.row( InlineKeyboardButton(_("➕ Add item"), callback_data="add_item_%i" % list_id), InlineKeyboardButton(_("🔗 Share"), switch_inline_query=list_.name), InlineKeyboardButton(_("❌ Delete item"), callback_data="delete_items_%i" % list_id), ) else: mp.row( InlineKeyboardButton(_("➕ Add item"), callback_data="add_item_%i" % list_id), InlineKeyboardButton(_("🔗 Share"), switch_inline_query=list_.name), ) return mp
def deleting_list(msg): user = User.get_by_id(msg.chat.id) if msg.text.startswith("🔙 "): bot.send_message(msg.chat.id, _("Canceled"), reply_markup=mps.main_mp(user.id)) return try: list_name = msg.text[4:] list_ = List.get((List.name == list_name) & (List.owner == user)) except (IndexError, DoesNotExist): bot.send_message( msg.chat.id, _("This list doesn't exist, choose from keyboard below"), reply_markup=mps.delete_list_mp(user.id)) bot.register_next_step_handler_by_chat_id(user.id, deleting_list) return if list_ == list_.subscribed_by: for sub in List.select().where(List.subscribed_by == list_): bot.delete_message(sub.owner.id, sub.last_message_id) sub.delete_instance() bot.send_message(sub.owner.id, _("List _%s_ was deleted") % sub.name, reply_markup=mps.main_mp(sub.owner.id), parse_mode='markdown', disable_notification=True) else: bot.delete_message(msg.chat.id, list_.last_message_id) list_.delete_instance() bot.send_message( msg.chat.id, _("You were successfully unsubscribed from list _%s_ ") % list_name, reply_markup=mps.main_mp(msg.chat.id), parse_mode='markdown')
def delete_items_mp(spotted: list, list_id): list_ = List.get_by_id(list_id) orig_list = List.get_by_id(list_.subscribed_by) mp = InlineKeyboardMarkup(row_width=1) for item in orig_list.items: spt = spotted.copy() if item.id in spotted: s = "💔 %s" % item.name spt.remove(item.id) else: s = "❤ %s" % item.name spt.append(item.id) cdata = "spt" + str(list_id) + '.' + ltos(spt) mp.add(InlineKeyboardButton(s, callback_data=cdata)) if len(spotted) == 0: mp.add( InlineKeyboardButton(_("🔙 Back"), callback_data="upd_list" + str(list_id) + '.')) else: mp.add( InlineKeyboardButton(_("❌ Delete"), callback_data="cmt" + str(list_id) + '.' + ltos(spotted))) return mp
def post(self, version): if not self.valid_version(version): self.error(404, "API Version %s not supported" % version) return name = self.request.get('name', default_value=None) description = self.request.get('description', default_value=None) if not name or not description: self.error(400, "Bad Data: Name: %s, Description: %s" \ % (name, description)) return slug = slugify.slugify(name) existing_s = List.get_by_slug(slug) if existing_s: self.error(404, "A list with this name already exists") return l = List(name=name, slug=slug, description=description) l.put() invalidate_cache() self.response.set_status(201) self.json(l.rest(self.base_url(version)))
def setUpClass(cls): db.drop_all() db.create_all() cls.client = app.test_client() cls.testuser = User.signup(username="******", email="*****@*****.**", password="******", avatar_url=None) cls.testuser_id = 1000 cls.testuser.id = cls.testuser_id cls.u1 = User.signup("my_user1", "*****@*****.**", "password", None) cls.u1_id = 2000 cls.u1.id = cls.u1_id cls.u2 = User.signup("my_user2", "*****@*****.**", "password", None) cls.u2_id = 3000 cls.u2.id = cls.u2_id db.session.commit() lst1 = List(name='list 1',description='coolest list ever',user_id=1000) lst2 = List(name='list 2',user_id=1000) lst3 = List(name='list 3',user_id=3000) lst1.id = 100 db.session.add(lst1) db.session.add(lst2) db.session.add(lst3) db.session.commit()
def delete_todo(list_id, user_id): check_user = do_user_check(user_id) if check_user: todo_item = List.query.get_or_404(list_id) List.delete(todo_item) return redirect(f"/users/{user_id}/shopping-list") else: return redirect('/')
def create_tables(): Number.create_table(True) SMS.create_table(True) Seller.create_table(True) Market.create_table(True) List.create_table(True) ListRelationship.create_table(True) Outbox.create_table(True)
def add_todo(user_id): check_user = do_user_check(user_id) if check_user: new_todo = List(user_id=user_id, item=request.json['ingredient']) List.save(new_todo) flash("You successfully added to shopping list", "success") return redirect('/') else: return redirect('/')
def mutate(cls, *args, **kwargs): user = get_current_user() name = kwargs["name"] if not name: raise GraphQLError("Invalid name") slug = List.generate_slug(user, name) description = kwargs.get("description") or "" list_ = List.create(user=user, name=name, slug=slug, description=description) return cls(list=list_)
def mark_todo(user_id, list_id): check_user = do_user_check(user_id) if check_user: todo = List.query.get_or_404(list_id) todo.checked = not todo.checked List.save(todo) return redirect(f'/users/{user_id}/shopping-list') else: return redirect('/')
def user_create(name, email, password): user = User(name=name, email=email, password=password) db.session.add(user) db.session.commit() #Init Getting Started List getting_started_list = List(title="Getting Started", current = True, parent_user=user.id, all_count=6, current_count=6) db.session.add(getting_started_list) db.session.commit() task = Task(title="Try marking this task as completed!", parent_list=getting_started_list.id, sort_value=1) db.session.add(task) task = Task(title="Try adding a new task!", parent_list=getting_started_list.id, sort_value=2) db.session.add(task) task = Task(title="Try Creating a New List.", parent_list=getting_started_list.id, sort_value=3) db.session.add(task) task = Task(title="Try adding a new task to the list", parent_list=getting_started_list.id, sort_value=4) db.session.add(task) task = Task(title="Try deleting a task from a list", parent_list=getting_started_list.id, sort_value=5) db.session.add(task) task = Task(title="Try restoring a task from the deleted filter", parent_list=getting_started_list.id, sort_value=6) db.session.add(task) db.session.commit() #Init Books to read List good_books_list = List(title="Good Books", current = False, parent_user=user.id, all_count=5, current_count=5) db.session.add(good_books_list) db.session.commit() task = Task(title="1984 By George Orwell", parent_list=good_books_list.id, sort_value=1) db.session.add(task) task = Task(title="Anna Karenina By Leo Tolstoi", parent_list=good_books_list.id, sort_value=2) db.session.add(task) task = Task(title="The Great Gatsby By F. Scott Fitzgerald", parent_list=good_books_list.id, sort_value=3) db.session.add(task) task = Task(title="Alice in Wonderland By Lewis Carroll", parent_list=good_books_list.id, sort_value=4) db.session.add(task) task = Task(title="A Clockwork Orange By Anthony Burgess", parent_list=good_books_list.id, sort_value=5) db.session.add(task) db.session.commit() #Init Shopping List shopping_list = List(title="Shopping List (Empty)", current = False, parent_user=user.id) db.session.add(shopping_list) #Init Bucket List bucket_list = List(title="Bucket List (Empty)", current = False, parent_user=user.id) db.session.add(bucket_list) db.session.commit() print('User *'+user.name+'* created!') return True
def test_deletion_of_orphans(self): task_list = List(title="tasks") work_list = List(title="work") task_list.todos = [Todo(title="exercise"), Todo(title="office"), Todo(title="breakfast")] work_list.todos = [Todo(title="health insurance"), Todo(title="support")] db.session.add_all([task_list, work_list]) db.session.commit() db.session.delete(task_list) db.session.commit() self.assertEqual(len(Todo.query.all()), len(work_list.todos))
def commit_deleting(c): dot = c.data.find('.') list_id = int(c.data[3:dot]) list_ = List.get_by_id(list_id) spt_s = c.data[dot + 1:] spotted = [int(i) for i in spt_s.split(',')] Item.delete().where(Item.id.in_(spotted)).execute() for sub in List.select().where(List.subscribed_by == list_.subscribed_by): bot.edit_message_reply_markup(sub.owner.id, sub.last_message_id, reply_markup=mps.list_mp(sub.id))
def comments_list(movieid): movie_id = int(movieid) from models import List query = List.select(List.comment).where(List.movie_id == movie_id) for list in query: print(list.comment) return redirect(url_for('movie', movieid=movieid, query=query))
def data(self): services = [] default_status = Status.get_default() lists = [] for list in self.lists: l = List.get_by_slug(list) if l is not None: lists.append(l) for service in Service.all().filter("list IN", lists).order("name").fetch(100): event = service.current_event() if event is not None: status = event.status else: status = default_status if len(self.statuses) and not status.slug in self.statuses: continue today = date.today() + timedelta(days=1) current, = service.history(1, default_status, start=today) has_issues = current["information"] and status.key() == default_status.key() service_dict = { "slug": service.slug, "name": service.name, "url": service.url(), "status": status, "has_issues": has_issues, "history": service.history(5, default_status), } services.append(service_dict) return {"days": get_past_days(5), "statuses": Status.all().fetch(100), "services": services}
def save_list_type(): if request.method == 'POST': type = None title = '' u_name = session['username'] u = db.session.query(User.id).filter(User.username == u_name).scalar() list_type_select = request.form['list-type'] if list_type_select == 'publiczna': type = 0 title = 'publiczna' flash('Twoja lista jest publiczna') elif list_type_select == 'prywatna': type = 1 title = 'prywatna' flash('Twoja lista jest prywatna') elif list_type_select == 'dla znajomych': type = 2 title = 'dla znajomych' flash('Twoja lista jest widoczna tylko dla znajomych') #sprawdzanie czy typ listy jest już określony check_list_type = db.session.query(List).filter( List.user_id == u).scalar() check_list_title = db.session.query(List).filter( List.user_id == u).scalar() if check_list_type and check_list_title: check_list_type.type = type check_list_title.title = title db.session.commit() else: tplist = List(title=title, type=type, user_id=u) db.session.add(tplist) db.session.commit() return redirect('/records')
def test_move_container(client, list_, access_token, container_id, new_container_id): nb_containers = len(list_.item_containers) url = url_for("graphql") list_id = to_global_id("TypeList", list_.id) res = client.post( url, headers={"Authorization": f"Bearer {access_token}"}, json={ "query": move_container_query, "variables": { "id": list_id, "containerId": container_id, "newContainerId": new_container_id }, }, ) assert res.status_code == HTTPStatus.OK, res.json res = res.json assert res["data"]["moveContainer"]["list"]["countItems"] == nb_containers list_ = List.filter(id=list_.id).first() assert len(list_.item_containers) == nb_containers for i, container in enumerate(list_.item_containers): if i < min(container_id, new_container_id): assert len(container.items) == i + 1 elif i == new_container_id: assert len(container.items) == container_id + 1
def test_update_list(client, list_, access_token, variables): url = url_for("graphql") list_id = to_global_id("TypeList", list_.id) res = client.post( url, headers={"Authorization": f"Bearer {access_token}"}, json={ "query": update_list_query, "variables": { "id": list_id, **variables } }, ) assert res.status_code == HTTPStatus.OK res = res.json assert res["data"]["updateList"]["list"] updated_list = List.get(id=list_.id) if variables.get("name"): assert updated_list.name == variables["name"] assert updated_list.slug == slugify(variables["name"]) else: assert updated_list.name == list_.name assert updated_list.slug == list_.slug if "description" in variables: assert updated_list.description == variables["description"] else: assert updated_list.description == list_.description
def test_create_list(client, user, access_token, name, description): url = url_for("graphql") res = client.post( url, headers={"Authorization": f"Bearer {access_token}"}, json={ "query": create_list_query, "variables": { "name": name, "description": description } }, ) assert res.status_code == HTTPStatus.OK queryset = List.filter(user=user) assert queryset.count() == 1 list_ = queryset.first() assert list_.user == user assert list_.name == name assert list_.slug == slugify(name) assert list_.description == description res = res.json assert res["data"]["createList"]["list"] assert res["data"]["createList"]["list"]["name"] == name
def save_list_type(): if request.method == 'POST': u_name = session['username'] u = db.session.query(User.id).filter(User.username == u_name).scalar() title = request.form['list-name'] type = request.form['list-type'] if type == '0': flash('Twoja lista jest publiczna', category='success') elif type == '1': flash('Twoja lista jest prywatna', category='success') elif type == '2': flash('Twoja lista jest widoczna tylko dla znajomych', category='success') else: flash('Nie wybrałeś typu listy', category='danger') #sprawdzanie czy nazwa listy już istnieje check_list_exist = db.session.query(List).filter( List.user_id == u, List.title == title, List.type == type).first() if check_list_exist: flash('Lista o tej nazwie i typie już istnieje!', category='danger') else: tplist = List(title=title, type=type, user_id=u) db.session.add(tplist) db.session.commit() return redirect(url_for('user', username=u_name))
def list_create(): if request.method == 'POST': title = request.form['new_list'] if check_list_exists(title): flash('A list with this name already exists') return redirect(url_for('dashboard')) lists = db.session.query(List).filter_by( parent_user=session["user_id"]).all() old_current_list = find_current_list(lists) new_current_list = List(title=request.form['new_list'], parent_user=session['user_id']) #This needs to be here before the change/choose function calls #because they query for this list and then update current db.session.add(new_current_list) db.session.commit() #when you create a new list, switch to immediately if old_current_list: change_current_list(old_current_list.id, new_current_list.id) else: choose_current_list(new_current_list.id) print('List *' + new_current_list.title + '* for user with id: *' + str(session['user_id']) + '* created!') flash('List *' + new_current_list.title + '* for user with id: *' + str(session['user_id']) + '* created!') return redirect(request.referrer)
def test_show_edit_list_unauthorized(self): """Testing access to edit list on another users page""" with app.test_client() as client: with client.session_transaction() as change_session: change_session["USERNAME"] = "******" user2 = User.signup(username="******", first_name="Test2", last_name="User2", email="*****@*****.**", password="******") user = User.query.filter_by(username="******").first() user2_list = List(name="testplanets2", description="my testplanets2", user_id=user.id) db.session.add(user2_list) db.session.commit() get_list = List.query.filter_by(name="testplanets2").first() resp = client.get(f"/users/testuser2/lists/{get_list.id}/edit", follow_redirects=True) html = resp.get_data(as_text=True) self.assertEqual(resp.status_code, 200) self.assertIn("Test's page", html) self.assertIn("Unauthorized access.", html) del change_session["USERNAME"]
def create_new_list(user, detail): new_list = List(user=user, createdate=datetime.datetime.now(), duedate=datetime.datetime.now(), status=get_first_status(), detail=detail) new_list.save()
def add_list(): """Add list to the group""" if 'user_id' not in session: return redirect(url_for('login')) u = User.query.filter_by(user_id=session['user_id']).first() print('Checking status!') if u.enter is None: flash('You are not in the current group anymore!') return json.dumps({'url': url}), 301 if not Group.query.filter_by(group_id=u.enter).first(): flash('The group is deleted, Please enter another group!') return json.dumps({'url': url}), 301 print('Adding list!') gp = Group.query.filter_by(group_id=u.enter).first() if request.form['title']: # Prevent adding lists of the same name l = get_list_id(request.form['title']) if l is None: db.session.add( List(u.enter, request.form['title'], int(time.time()))) db.session.commit() else: flash('The list name is in use!') return redirect(url_for('in_group', group_name=gp.group_name))
def create_list(): """Perform creation of a list by a user.""" if request.method == "GET": return redirect("/") movies = request.json.get("list") title = request.json.get("title") description = request.json.get("description") top_movie = db.session.query(Movie).filter( Movie.movie_id == movies[0]["movie_id"]).first() image = top_movie.backdrop_image newlist = List(user_id=session[CURR_USER_KEY], title=title, description=description, total_movies=len(movies), image=image) db.session.add(newlist) db.session.commit() for movie in movies: list_movie = ListMovie(list_id=newlist.id, movie_id=movie["movie_id"], position=movie["movie_position"]) db.session.add(list_movie) db.session.commit() return ("created")
def add_item(msg): user = User.get_by_id(msg.chat.id) list_id = list_to_edition[user.id] list_ = List.get_by_id(list_id) orig_list = list_.subscribed_by items = [ Item(name=item_name, list_id=orig_list.id) for string in msg.text.split('\n') for item_name in string.split(',') if len(item_name) <= 255 ] if len(items) == 0: bot.send_message(msg.chat.id, _("Too long item name. Cancelled.")) else: bot.send_message(msg.chat.id, ngettext("Item created", "Items created", len(items)), parse_mode="markdown", reply_markup=mps.main_mp(msg.chat.id), disable_notification=True) Item.bulk_create(items) sent = bot.send_message(msg.chat.id, "📝 *%s*" % list_.name, reply_markup=mps.list_mp(list_id), parse_mode='markdown') list_.last_message_id = sent.message_id list_.save() for sub in orig_list.subs: if sub == list_: continue bot.edit_message_reply_markup(chat_id=sub.owner.id, message_id=sub.last_message_id, reply_markup=mps.list_mp(sub.id))
def get_list_from_id(list_id): user = get_current_user() _, list_id = from_global_id(list_id) list_ = List.filter(user=user, id=list_id).first() if not list_: raise GraphQLError("No list with this id") return list_
def lists_delete(list_id): list = List.get_by_id(list_id=list_id) if list: list.delete() return ('', 204) else: return ('List not found', 404)
def remove_todo(): if request.method=='GET': return redirect(url_for('home')) else: try: req = request.form _id = req.get('rm-list') List.remove_todo(_id) flash('Data Removed Successfully','warning') return redirect(url_for('home')) except Exception as error: print(error) flash('List is already empty','danger') data = list(List.find_todo()) return redirect(url_for('home'))
def post(self, version, list_slug): if not self.valid_version(version): self.error(404, "API Version %s not supported" % version) return list = List.get_by_slug(list_slug) if not list: self.error(404, "Service %s does not exist" % list_slug) return name = self.request.get('name', default_value=None) description = self.request.get('description', default_value=None) if description: list.description = description if name: list.name = name if name or description: invalidate_cache() list.put() self.json(list.rest(self.base_url(version)))
def setUp(self): """Create test client, add sample data.""" User.query.delete() List.query.delete() Favorite.query.delete() self.client = app.test_client() user = User(username="******", first_name="Test", last_name="User", email="*****@*****.**", password="******") db.session.add(user) self.user = User.query.filter_by(username="******").first() user_list = List(name="testplanets", description="my testplanets", user_id=self.user.id) db.session.add(user_list) self.list = List.query.filter_by(name="testplanets").first() favorite = Favorite(list_id=self.list.id, planet_name="GJ 876 c") db.session.add(favorite) self.favorite = Favorite.query.filter_by(list_id=self.list.id).first() db.session.commit()
def post(self): args = parser.parse_args() if not args.name: abort(500) _l = objList.add(args.name) return _l
def add_todo(): if request.method=='GET': return redirect(url_for('home')) else: req = request.form task = req.get('add-list') dt = req.get('date') new_list = { 'task':task, 'date':dt } List.add_todo(new_list) flash('Data Inserted Successfully','success') data = list(List.find_todo()) return redirect(url_for('home'))
def _get_all(self): _lists = objList.get_all() if not _lists: return make_response(dumps([])) return make_response(dumps(_lists))
def test_post_update_desc(self): response = self.post("/admin/api/v1/service-lists/foo", data={"description": "hello"}) self.assertEquals(response.headers["Content-Type"], "application/json") self.assertEquals(response.status_code, 200) service = List.get(self.service_list.key()) self.assertEquals(service.description, "hello")
def test_post_update(self): response = self.post("/admin/api/v1/service-lists/foo", data={"name": "bar"}) self.assertEquals(response.headers["Content-Type"], "application/json") self.assertEquals(response.status_code, 200) service = List.get(self.service_list.key()) self.assertEquals(service.name, "bar")
def get(self): results = [] q = List.query() for list in q.iter(): results.append(list.to_dict()) self.response.headers['Content-Type'] = 'application/json' self.response.out.write(json.dumps(results));
def get(self, version): if not self.valid_version(version): self.error(404, "API Version %s not supported" % version) return query = List.all().order('name') data = [s.rest(self.base_url(version)) for s in query] data = {"lists": data} self.json(data)
def get(self): lists = List.query().fetch(20) newList = [] for item in lists: newList.append({"name": item.name, "listKey": item.key.urlsafe()}) self.response.write(json.dumps(newList))
def put(self, list_id=None): if not list_id: abort(500) args = parser.parse_args() if not args.name: abort(500) _l = objList.update(list_id, args.name) return _l
def get(self): td = { "services_selected": True, "url": "/admin/api/v1/services", "action": "create", "service_lists": List.all().fetch(100), } td.update(site.default_template_data()) self.render(td, 'admin/services_create.html')
def get(self, list_slug): self.list = List.get_by_slug(list_slug) if self.list is None: self.not_found() return td = default_template_data() td.update(self.retrieve("list"+list_slug)) #td.update(self.data()) self.render(td, 'index.html')
def get(self, version, list_slug): if not self.valid_version(version): self.error(404, "API Version %s not supported" % version) return list = List.get_by_slug(list_slug) if not list: self.error(404, "List %s does not exist" % list_slug) return self.json(list.rest(self.base_url(version)))
def get(self, slug): list = List.get_by_slug(slug) if not list: self.not_found() return td = { "listss_selected": True, "list": list, } td.update(site.default_template_data()) self.render(td, 'admin/list_delete.html')
def data(self): default_status = Status.get_default() lists = [] for list in self.lists: l = List.get_by_slug(list) if l is not None: lists.append(l) @ndb.toplevel def get_services(): services = [] for service in Service.query().filter(Service.list in lists).order(Service.name).fetch(100): event = yield service.current_event_async() if event is not None: status = event.status else: status = default_status if len(self.statuses) and not status.slug in self.statuses: continue today = datetime.today() + timedelta(days=1) current = yield service.history_async(1, default_status, start=today) current = current[0] has_issues = current["information"] and status.key == default_status.key history = yield service.history_async(5, default_status) service_dict = { "slug": service.slug, "name": service.name, "url": service.url(), "status": status, "has_issues": has_issues, "history": history, } services.append(service_dict) raise ndb.Return(services) return { "days": get_past_days(5), "statuses": Status.query().fetch(100), "services": get_services(), }
def get(self, slug): list = List.get_by_slug(slug) if not list: self.not_found() return td = { "lists_selected": True, "list": list, "action": "edit", "url": "/admin/api/v1/service-lists/" + slug, "description": list.description, "name": list.name, } td.update(site.default_template_data()) self.render(td, 'admin/list_edit.html')
def delete(self, version, list_slug): if not self.valid_version(version): self.error(404, "API Version %s not supported" % version) return list = List.get_by_slug(list_slug) if not list: self.error(404, "List %s not found" % list_slug) return query = Service.query().filter(Service.list == list) for s in query: s.list = None s.put() invalidate_cache() list.delete() self.json(list.rest(self.base_url(version)))
def post(self, version, service_slug): if not self.valid_version(version): self.error(404, "API Version %s not supported" % version) return service = Service.get_by_slug(service_slug) if not service: self.error(404, "Service %s does not exist" % service_slug) return name = self.request.get('name', default_value=None) description = self.request.get('description', default_value=None) list = self.request.get('list', default_value=None) if description: service.description = description if name: service.name = name if list: l = List.all().filter("slug = ", list).get() if l is None: self.error(400, "Can't find list with slug %s" % list) return service.list = l if "" == list: service.list = None list = "removed" if name or description or list: invalidate_cache() service.put() self.json(service.rest(self.base_url(version)))
def post(self, version): if not self.valid_version(version): self.error(404, "API Version %s not supported" % version) return name = self.request.get('name', default_value=None) description = self.request.get('description', default_value=None) slist = self.request.get('list', default_value=None) l = None if slist: l = List.all().filter("slug =", slist).get() if not name: self.error(400, "Bad name: %s" % name) return if not description: self.error(400, "Bad description: %s" % description) return if slist and not l: self.error(400, "Bad list slug: %s" % slist) return slug = slugify.slugify(name) existing_s = Service.get_by_slug(slug) if existing_s: self.error(404, "A sevice with this name already exists") return s = Service(name=name, slug=slug, description=description, list=l) s.put() invalidate_cache() self.response.set_status(201) self.json(s.rest(self.base_url(version)))
def index(password): print >> sys.stderr, "within index" try: if password == PASSWORD: print >> sys.stderr, "within try" sellerList = Seller.select() smsList = SMS.select() numberList = Number.select() l = List.select() marketList = Market.select() lrList = ListRelationship.select() outboxList = Outbox.select() return render_template("index.html", title = 'TABLES', sellerList = sellerList, smsList = smsList, l = l, marketList = marketList) #return 'hello world' else: print >> sys.stderr, "wrong password" except: print >> sys.stderr, "within except" print >> sys.stderr, str(sys.exc_info()[0]) # These write the nature of the error print >> sys.stderr, str(sys.exc_info()[1]) statement = 'An exception has Occured'+ str(sys.exc_type) + '[' + str(sys.exc_value) + ']' return statement
def get(self, slug): service = Service.get_by_slug(slug) if not service: self.not_found() return td = { "services_selected": True, "url": "/admin/api/v1/services/" + slug, "description": service.description, "slug": service.slug, "name": service.name, "action": "edit", "service_lists": List.all().fetch(100), } if service.list is not None: td["list"] = service.list.name else: td["list"] = "" td.update(site.default_template_data()) self.render(td, 'admin/services_create.html')
def get_List_Object(market): listObject = List.get(List.market == market) return listObject
def get_Mini_Sellers_ListNumbers(sellersListName): sellersListNumbers = [] sellersList = List.get(List.name == sellersListName) for listRelationship in ListRelationship.select().where(ListRelationship.listName == sellersList): sellersListNumbers.append(listRelationship.number) return sellersListNumbers
def check_Mini_Sellers_ListName_Exists(seller, name): for l in List.select(): if l.seller == seller and l.name == name: print 'seller already created this list!' return True
def get_Mini_Sellers_ListNames(seller): sellersListNames = [] for l in List.select().where(List.seller == seller): sellersListNames.append(l.name) return sellersListNames
def get_Mini_Sellers_List(seller, name): l = List.get(List.name == name and List.seller == seller) return l
def get_Mini_List(name): l = List.get(List.name == name) return l
def get(self): td = default_template_data() td["lists_selected"] = True td["lists"] = List.all().order("name").fetch(1000) self.render(td, 'admin/list.html')