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 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 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 _get_all(self):
		_lists = objList.get_all()

		if not _lists:
			return make_response(dumps([]))

		return make_response(dumps(_lists))

	def post(self):		
		args = parser.parse_args()
		if not args.name:
			abort(500)

		_l = objList.add(args.name)
		return _l

    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 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 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, 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 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 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, 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 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 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 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 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_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_List_Object(market):
    listObject = List.get(List.market == market)
    return listObject