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, 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 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 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')
