示例#1
0
    def get(self, style=None):
        if style is not None and len(style) > 0:

            # FIXME: Un-urlize the string
            style = re.sub(r'%20', ' ', style)
            style = re.sub(r'%28', '(', style)
            style = re.sub(r'%29', ')', style)

            # Find all the styles by creating a set from all beers b/c
            # app engine won't let us grab just this column from a table
            beers = __weekly_brews__(Beer.all().filter("style = ", style)).order("name")

            template_values = {'beers' : beers, 'search' : style}
            path = os.path.join(os.path.dirname(__file__),
                                    'templates/beers.html')
            self.response.out.write(template.render(path, template_values)) 
            return

        # Use a list to preserve ordering
        styles = []
        tmp = __weekly_brews__(Beer.all())

        for beer in tmp:
            styles.append(beer.style)

        styles = list(set(styles))
        styles.sort()
        template_values = {'styles' : styles}
        path = os.path.join(os.path.dirname(__file__),
                                'templates/search.html')
        self.response.out.write(template.render(path, template_values)) 
示例#2
0
    def test_init_menus(self):
        api_dict = {
            "TestBar":
            self.MockAPIPlan(
                self.mockAPI,
                ["shit", "shit", "Stone", "Stone", "Founders"]).executor(),
        }
        good_menu1 = Menu("TestBar", [
            MenuSection("1", "Title1",
                        [Beer("name Stone", "style", 8, "brewery")])
        ])
        good_menu2 = Menu("TestBar", [
            MenuSection("1", "Title1",
                        [Beer("name Founders", "style", 8, "brewery")])
        ])

        mm = MenuManager(api_dict=api_dict)
        self.assertEqual({}, mm.find_good_bars())

        mm.update_menus()
        self.assertEqual({}, mm.find_good_bars())

        mm.update_menus()
        self.assertEqual({"TestBar": good_menu1}, mm.find_good_bars())

        mm.update_menus()
        self.assertEqual({}, mm.find_good_bars())

        mm.update_menus()
        self.assertEqual({"TestBar": good_menu2}, mm.find_good_bars())
 def test_MenuSectionEquals(self):
     section_1 = MenuSection("123", "Beers")
     section_2 = MenuSection("123", "Beers")
     for i in range(3):
         section_1.beers.append(Beer(str(i), str(i), i, str(i)))
         section_2.beers.append(Beer(str(i), str(i), i, str(i)))
     self.assertEqual(section_1, section_2, "Should be equal")
 def test_GoodBeers(self):
     section = MenuSection("123", "Beers")
     section.beers.append(Beer("One beer", "From", 18.0, "There"))
     section.beers.append(Beer("Breakfast Stout", "From", 9.0, "Founders"))
     good_beers = section.good_beers()
     self.assertEqual(len(good_beers), 1)
     self.assertEqual(good_beers[0],
                      Beer("Breakfast Stout", "From", 9.0, "Founders"))
示例#5
0
 def test_FromDict(self):
     b = Beer("Breakfast stout", "Stout", 8.0, "Founders")
     b_dict = {
         "name": "Breakfast stout",
         "style": "Stout",
         "abv": 8.0,
         "brewery": "Founders"
     }
     self.assertEqual(b, Beer().from_dict(b_dict))
示例#6
0
 def test_ToDict(self):
     b = Beer("Breakfast stout", "Stout", 8.0, "Founders")
     b_dict = {
         "name": "Breakfast stout",
         "style": "Stout",
         "abv": 8.0,
         "brewery": "Founders"
     }
     self.assertEqual(b.to_dict(), b_dict)
示例#7
0
 def test_BeerUnEquals(self):
     b1 = Beer("Breakfast stout", "Stout", 8.0, "Founders")
     b2 = Beer("Breakfast Stout", "Stout", 8.0, "Founders")
     b3 = Beer("Breakfast stout", "IPA", 8.0, "Founders")
     b4 = Beer("Breakfast stout", "Stout", 7.0, "Founders")
     b5 = Beer("Breakfast stout", "Stout", 8.0, "Stone")
     self.assertNotEqual(b1, b2)
     self.assertNotEqual(b1, b3)
     self.assertNotEqual(b1, b4)
     self.assertNotEqual(b1, b5)
示例#8
0
 def test_IsNotWorthIt(self):
     b1 = Beer("Breakfast stout", "Stout", 5.0, "No Brand")
     b2 = Beer("Breakfast stout", "Stout", 8.0, "Some Brand")
     b3 = Beer("Breakfast stout", "Stout", 6.0, "Founders")
     self.assertEqual(b1.is_worth_it(), False)
     self.assertEqual(b2.is_worth_it(), False)
     self.assertEqual(b3.is_worth_it(), False)
 def test_Constructor(self):
     section_1 = MenuSection("123", "Beers")
     section_2 = MenuSection("124", "More beers",
                             [Beer("B", "EE", 1.0, "R")])
     self.assertEqual(section_1.section_id, "123")
     self.assertEqual(section_1.title, "Beers")
     self.assertEqual(len(section_1.beers), 0)
     self.assertEqual(section_2.section_id, "124")
     self.assertEqual(section_2.title, "More beers")
     self.assertEqual(len(section_2.beers), 1)
     self.assertEqual(section_2.beers[0], Beer("B", "EE", 1.0, "R"))
 def test_MenuSectionUnequals(self):
     section_1 = MenuSection("123", "Beers")
     section_2 = MenuSection("124", "Beers")
     section_3 = MenuSection("123", "beers")
     section_4 = MenuSection("124", "beers")
     for i in range(3):
         section_1.beers.append(Beer(str(i), str(i), i, str(i)))
         section_2.beers.append(Beer(str(i), str(i), i, str(i)))
         section_3.beers.append(Beer(str(i), str(i), i, str(i)))
     section_1.beers.append(Beer("different", "section", 5.0, "brew"))
     self.assertNotEqual(section_1, section_2, "Should not be equal")
     self.assertNotEqual(section_1, section_3, "Should not be equal")
     self.assertNotEqual(section_1, section_4, "Should not be equal")
示例#11
0
    def post(self):

        json_string = self.request.body
        dict_object = json.loads(json_string)

        beer_name = dict_object['beerName']
        beer_style = dict_object['beerStyle']
        beer_price = float(dict_object['beerPrice'])
        beer_abv = float(dict_object['beerAbv'])
        beer_ibus = int(dict_object['beerIbus'])
        beer_srm = int(dict_object['beerSrm'])
        beer_on_tap = bool(dict_object['beerOnTap'])
        beer_tap_list_image = dict_object['beerTapListImage']
        beer_description = dict_object['beerDescription']
        beer_description_image = dict_object['beerDescriptionImage']

        same_name = Beer.query(Beer.name == beer_name).fetch()

        if not same_name:

            #NDB storing
            beer = Beer(name=beer_name,
                        style=beer_style,
                        tap_list_image=beer_tap_list_image,
                        description=beer_description,
                        description_image=beer_description_image,
                        price=beer_price,
                        abv=beer_abv,
                        ibus=beer_ibus,
                        srm=beer_srm,
                        on_tap=beer_on_tap)
            beer_key = beer.put()
            beer_id = str(beer_key.id())

            res = {
                "msg": "Beer successfully added",
                "success": True,
                "beer_id": beer_id
            }
            self.response.out.write(json.dumps(res))

        else:
            res = {
                "msg":
                "That beer already exists in the inventory or something went wrong. Please try again.",
                "success": False
            }
            self.response.out.write(json.dumps(res))
    def get(self):

        beer_id = int(self.request.get('beerId', 0))

        beer = Beer.get_by_id(beer_id)

        if beer != None:
            date = beer.creation_date
            date_string = date.strftime('%m/%d/%Y')
            beer_data = {
                'id': beer.key.id(),
                'name': beer.name,
                'style': beer.style,
                'tap_list_image': beer.tap_list_image,
                'description': beer.description,
                'description_image': beer.description_image,
                'price': beer.price,
                'abv': beer.abv,
                'ibus': beer.ibus,
                'srm': beer.srm,
                'on_tap': beer.on_tap,
                'review': beer.review,
                'review_count': beer.review_count,
                'creation_date': date_string
            }
        else:
            beer_data = {}

        self.response.out.write(json.dumps(beer_data))
    def get(self):

		self.response.headers['Content-Type'] = 'application/json'
		beer_query = Beer.query().order(Beer.name)
		beers = beer_query.fetch()
		beer_list = []

		for beer in beers:
			date = beer.creation_date
			date_string = date.strftime('%m/%d/%Y')
			beer_list.append({
		    	'id': beer.key.id(), 
		    	'key' : str(beer.key),
		    	'name': beer.name, 
		    	'style': beer.style, 
		    	'tap_list_image': beer.tap_list_image, 
		    	'description': beer.description,
		    	'description_image' : beer.description_image, 
		    	'price' : beer.price, 
		    	'abv' : beer.abv, 
		    	'ibus' : beer.ibus, 
		    	'srm' : beer.srm, 
		    	'on_tap' : beer.on_tap, 
		    	'review' : beer.review, 
		    	'review_count' : beer.review_count, 
		    	'creation_date' : date_string
		    })
		    
		self.response.out.write(json.dumps(beer_list))
示例#14
0
    def get(self):
        beers = __weekly_brews__(Beer.all().filter("type = ", self.type())).order("name")
        template_values = {'beers' : beers, 'type' : self.type()}

        # FIXME: This template sucks b/c it has 4 loops that are duplicates
        path = os.path.join(os.path.dirname(__file__), 'templates/type.html')
        self.response.out.write(template.render(path, template_values)) 
示例#15
0
class TestTelegramBotUtil(unittest.TestCase):

    beer_1 = Beer("Breakfast Stout", "Stout", "8.6", "Founders")
    beer_2 = Beer("Stone IPA", "IPA", "5.6", "Stone")
    section_1 = MenuSection("111", "On Tap (2 bier)", [beer_1, beer_2])
    empty_section = MenuSection("222", "Empty", [])
    menu_1 = Menu("TAP", [section_1, empty_section])
    menu_2 = Menu("FooBar", [section_1, empty_section])

    beer_1_text = "Breakfast Stout\n" \
                    "8.6% ABV\n" \
                    "Stout\n" \
                    "Founders\n"
    beer_2_text = "Stone IPA\n" \
                  "5.6% ABV\n" \
                  "IPA\n" \
                  "Stone\n"
    section_1_text = "_On Tap_ (2 Beers)\n" \
                    "   ---Beer 1---\n" \
                    "{}" \
                    "   ---Beer 2---\n" \
                    "{}".format(beer_1_text, beer_2_text)
    menu_1_text = "*TAP*\n" \
                  "{}".format(section_1_text)

    menu_2_text = "*FooBar*\n" \
                  "{}".format(section_1_text)

    def test_beer_in_markdown(self):
        actual_text = util.beer_to_markdown(self.beer_1)
        self.assertEqual(actual_text, self.beer_1_text)

    def test_menusection_in_markdown(self):
        actual_text = util.section_to_markdown(self.section_1)
        self.assertEqual(actual_text, self.section_1_text)

    def test_menu_in_markdown(self):
        actual_text = util.menu_to_markdown(self.menu_1)
        self.assertEqual(actual_text, self.menu_1_text)

    def test_multiple_menus_in_markdown(self):
        actual_text = util.multiple_menus_to_markdown({
            "TAP": self.menu_1,
            "FooBar": self.menu_2
        })
        self.assertEqual(actual_text,
                         self.menu_1_text + "\n" + self.menu_2_text)
示例#16
0
def request_menu():
    logging.info("Retrieving TAP Craft Beer Menu")
    try:
        # Get menu location
        headers = {
            'Accept-Language':
            'en-GB,en-US;q=0.9,en;q=0.8',
            'User-Agent':
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36',
            'Accept':
            'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
        }

        response1 = requests.get('http://menu.tapthat.com.sg/',
                                 headers=headers)
        # print(response1.content)

        response_string = response1.content.decode('utf-8')

        groups = re.search(
            'PreloadEmbedMenu\("menu-container",([0-9]+),([0-9]+)\)',
            response_string)
        # print(groups[1], groups[2])

        # Retrieve menu
        response2 = requests.get(
            'https://business.untappd.com/locations/{}/themes/{}/js'.format(
                groups.group(1), groups.group(2)),
            headers=headers)

        # print(response.content)

        menu_html = str(response2.content)
        menu_html = ' '.join(
            menu_html.replace('\\n', '').replace('\\', '').split())
        menu_html = html.unescape(menu_html)
        # print(menu_html)

        beer_regex = re.compile(
            '<!-- Beer Name \+ Style -->.+?<\/span>(.+?)\s<\/a>.+?item-title-color">(.+?)<\/span>.+?"abv">(.+?)%\sABV',
            re.DOTALL)
        beer_groups = beer_regex.finditer(menu_html)

        beers = []
        for beer_group in beer_groups:
            beers.append(
                Beer(beer_group.group(1), beer_group.group(2),
                     float(beer_group.group(3))))

        logging.info("Retrieved {} beers from Tap Craft Beer.".format(
            len(beers)))
        return beers
    except:
        logging.error("Error getting Tap Craft Beer menu: {}".format(
            sys.exc_info()[0]))
        traceback.print_exc()
        return []
示例#17
0
def parse_beer_data(beers_data):
    beer_dicts = []
    variables = [x for x in dir(Beer) if not (x.startswith('_'))]
    for b in beers_data:
        # print json.dumps(b)
        bb = Beer(b)
        beer_dict = dict((name, getattr(bb, name)) for name in variables)
        beer_dicts.append(beer_dict)
    return beer_dicts
示例#18
0
    def get(self):
        # Have to filter name afterwards b/c datastore requires the inequality
        # operators to have a order FIRST if there is going to be any order
        # clauses at all (see datastore docs)
        drafts = __weekly_brews__(Beer.all().filter("type = ", "Draft")).order("name")
        bottles = __weekly_brews__(Beer.all().filter("type = ", "Bottle")).order("name")
        cans = __weekly_brews__(Beer.all().filter("type = ", "Can")).order("name")
        casks = __weekly_brews__(Beer.all().filter("type = ", "Cask")).order("name")

        beers = {}
        beers['drafts'] = drafts
        beers['bottles'] = bottles
        beers['cans'] = cans
        beers['casks'] = casks

        template_values = {'beers' : beers}

        # FIXME: This template sucks b/c it has 4 loops that are duplicates
        path = os.path.join(os.path.dirname(__file__), 'templates/index.html')
        self.response.out.write(template.render(path, template_values)) 
示例#19
0
    def post(self, name):
        name = self.request.get('name')

        if name is None or not len(name):
            self.redirect("/search")
            return
        beers = __weekly_brews__(Beer.all().filter("name = ", name))

        template_values = {'beers' : beers}
        path = os.path.join(os.path.dirname(__file__), 'templates/beers.html')
        self.response.out.write(template.render(path, template_values))
示例#20
0
    def get(self):

        self.response.headers['Content-Type'] = 'application/json'
        order_query = Order.query().order(-Order.timestamp)
        orders = order_query.fetch()
        order_list = []

        for order in orders:
            date = order.timestamp
            date_string = date.strftime('%m/%d/%Y %H:%M:%S')

            order_beer_query = OrderBeer.query(OrderBeer.order_id == order.key.
                                               id()).order(-OrderBeer.quantity)
            order_beers = order_beer_query.fetch()
            order_beer_list = []

            for order_beer in order_beers:

                beer = Beer.get_by_id(order_beer.beer_id)
                beer_list = ""

                if beer != None:
                    beer_name = beer.name
                else:
                    beer_name = "Unknown beer id " + beer_id

                order_beer_list.append({
                    'id': order_beer.beer_id,
                    'beer_name': beer_name,
                    'quantity': order_beer.quantity
                })

                customers = User.query(
                    User.fb_user_id == order.fb_user_id).fetch()
                customer_name = ""
                for customer in customers:
                    customer_name = customer.name

            order_list.append({
                'id': order.key.id(),
                'order_total': order.order_total,
                'customer_name': customer_name,
                'user_id': order.fb_user_id,
                'status': order.status,
                'reward_id': order.reward_id,
                'discount': order.discount,
                'invoice_number': order.invoice_number,
                'timestamp': date_string,
                'details': order_beer_list
            })

        self.response.out.write(json.dumps(order_list))
 def test_FromDict(self):
     section = MenuSection("123", "Beers")
     section.beers.append(Beer("One beer", "From", 18.0, "There"))
     section.beers.append(Beer("Two beer", "From", 9.0, "Here"))
     section_dict = {
         "section_id":
         "123",
         "title":
         "Beers",
         "beers": [{
             "name": "One beer",
             "style": "From",
             "abv": 18.0,
             "brewery": "There"
         }, {
             "name": "Two beer",
             "style": "From",
             "abv": 9.0,
             "brewery": "Here"
         }]
     }
     self.assertEqual(section, MenuSection().from_dict(section_dict))
    def get(self):

        self.response.headers['Content-Type'] = 'application/json'

        user_id = self.request.get('userId', 0)
        limit = int(self.request.get('limit', 3))

        order_query = Order.query(
            Order.fb_user_id == user_id).order(-Order.timestamp)
        orders = order_query.fetch(limit)
        order_list = []

        for order in orders:
            date = order.timestamp
            # Please we need to use only 1 format!
            date_string = date.strftime('%m/%d/%Y %H:%M:%S')

            order_beer_query = OrderBeer.query(OrderBeer.order_id == order.key.
                                               id()).order(-OrderBeer.quantity)
            order_beers = order_beer_query.fetch()
            order_beer_list = []

            for order_beer in order_beers:

                beer = Beer.get_by_id(order_beer.beer_id)

                if beer != None:
                    beer_name = beer.name
                else:
                    beer_name = "Unknown beer id " + beer_id

                order_beer_list.append({
                    'id': order_beer.beer_id,
                    'beer_name': beer_name,
                    'quantity': order_beer.quantity
                })

            order_list.append({
                'id': order.key.id(),
                'order_total': order.order_total,
                'user_id': order.fb_user_id,
                'status': order.status,
                'reward_id': order.reward_id,
                'discount': order.discount,
                'invoice_number': order.invoice_number,
                'timestamp': date_string,
                'details': order_beer_list
            })

        self.response.out.write(json.dumps(order_list))
示例#23
0
    def build_menu_from_html(self, page):
        tree = html.document_fromstring(page)
        m = Menu(self.bar_name)

        # Get all menu sections
        sections = tree.find_class("menu-section")

        for section in sections:
            # Get section details
            section_id_string = section.get("id")
            section_id = re.search("section_(.+?)$",
                                   section_id_string).group(1)
            title = self.sanitize_markdown_characters(
                section.find_class("menu-section-header")[0].text_content())
            beer_list = section.find_class("menu-section-list")
            beers = beer_list[0].getchildren()
            # If not all beers are loaded
            if len(section.find_class("show-more-section")) > 0:
                logging.debug(
                    "Loading more beers for {}.".format(section_id_string))
                beers += self.load_section(section_id)

            # There are beers in this section
            if len(beers) > 0:
                ms = MenuSection(section_id, title)
                for beer in beers:
                    details = beer.find_class("beer-details")[0]
                    h5, h6 = details.getchildren()
                    name, style = h5.getchildren()
                    abv = h6.getchildren()[0]
                    brewery = h6.getchildren()[0].getchildren()[0]
                    ms.beers.append(
                        Beer(
                            self.sanitize_markdown_characters(
                                name.text_content()),
                            self.sanitize_markdown_characters(
                                style.text_content()),
                            self.sanitize_markdown_characters(
                                self.get_abv_from_span(abv.text_content())),
                            self.sanitize_markdown_characters(
                                brewery.text_content())))
                m.sections.append(ms)
        return m
    def post(self):

        json_string = self.request.body
        dict_object = json.loads(json_string)

        review = int(dict_object['review'])
        beer_id = int(dict_object['beer_id'])

        beer = Beer.get_by_id(beer_id)

        if beer != None:
            beer.review_sum = beer.review_sum + review
            beer.review_count = beer.review_count + 1
            beer.review = beer.review_sum / beer.review_count

            beer.put()

            self.response.set_status(200)

        else:
            self.response.set_status(500)
    def post(self):

		json_string = self.request.body
		dict_object = json.loads(json_string)

		beer_id = int( dict_object['beerId'] ) 
		beer_name = dict_object['beerName']
		beer_style = dict_object['beerStyle']
		beer_price = float( dict_object['beerPrice'] )
		beer_abv = float( dict_object['beerAbv'] )
		beer_ibus = int( dict_object['beerIbus'] )
		beer_srm = int( dict_object['beerSrm'] ) 
		beer_on_tap = bool( dict_object['beerOnTap'] )
		beer_tap_list_image = dict_object['beerTapListImage']
		beer_description = dict_object['beerDescription']
		beer_description_image = dict_object['beerDescriptionImage']

		beer = Beer.get_by_id(beer_id)

		if beer != None:
			beer.name = beer_name
			beer.style = beer_style
			beer.price = beer_price
			beer.abv = beer_abv
			beer.ibus = beer_ibus
			beer.srm = beer_srm
			beer.on_tap = beer_on_tap
			beer.tap_list_image = beer_tap_list_image
			beer.description = beer_description
			beer.description_image = beer_description_image

			beer.put()

			res = { "msg" : "Beer successfully updated", "success": True, "beer_id" : beer_id }
			self.response.out.write(json.dumps(res))
		else:
			res = { "msg" : "Oops! Something went wrong. Please try again.", "success": False, "beer_id" : beer_id }
			self.response.out.write(json.dumps(res))
示例#26
0
	def text_order(self, order_beers, user_id):
		account_sid = ""
		auth_token = ""
		client = Client(account_sid, auth_token)
		
		customers = User.query(User.fb_user_id == user_id).fetch()
		for customer in customers:
			customer_name = customer.name
		beer_list = ""

		for beer in order_beers:
			beer_name = Beer.get_by_id(int(beer['id'])).name
			beer_quantity = beer['quantity']
			beer = '\n{} x{}'.format(beer_name, beer_quantity)
			beer_list += beer;

		msg_body = 'Beer Order for {}! {}'.format(customer_name, beer_list)		

		bartending_employees = Employee.query(Employee.bartending == True).fetch()

		for employee in bartending_employees:
			msg_to = "+1"+employee.phone
			
			rv = client.messages.create(to=msg_to, from_="+15126400776 ",body=msg_body)
    def post(self):

        json_string = self.request.body
        dict_object = json.loads(json_string)

        beer_id = int(dict_object['beerId'])

        beer = Beer.get_by_id(beer_id)

        if beer != None:
            beer.key.delete()
            res = {
                "msg": "Beer successfully deleted",
                "success": True,
                "beer_id": beer_id
            }
            self.response.out.write(json.dumps(res))
        else:
            res = {
                "msg": "Oops! Something went wrong. Please try again.",
                "success": False,
                "beer_id": beer_id
            }
            self.response.out.write(json.dumps(res))
示例#28
0
 def test_IsWorthIt(self):
     b1 = Beer("Breakfast stout", "Stout", 8.0, "Founders")
     b2 = Beer("Founders Breakfast stout", "Stout", 8.0, "None")
     self.assertEqual(b1.is_worth_it(), True)
     self.assertEqual(b2.is_worth_it(), True)
示例#29
0
 def get_model(self, param):
     return Beer(param)
示例#30
0
 def test_repr(self):
     b = Beer("Breakfast stout", "Stout", 8.0, "Founders")
     self.assertEqual(str(b), "Beer(name=Breakfast stout, style=Stout, abv=8.0, brewery=Founders)")
示例#31
0
 def test_BeerEquals(self):
     b1 = Beer("Breakfast stout", "Stout", 8.0, "Founders")
     b2 = Beer("Breakfast stout", "Stout", 8.0, "Founders")
     self.assertEqual(b1, b2)
示例#32
0
 def mockAPI(self, beername=""):
     return Menu("TestBar", [
         MenuSection("1", "Title1",
                     [Beer("name " + beername, "style", 8, "brewery")])
     ])
示例#33
0
 def make_beer(self, data, **kwargs):
     beer_args = {'id': str(uuid1()), **data}
     return Beer(**beer_args)
示例#34
0
 def make_beer(self, data, **kwargs):
     return Beer(**data)