Subversion Repositories SmartDukaan

'''
Created on 31-Aug-2011

@author: Varun Gupta
'''
    
import tornado.httpserver
import tornado.ioloop
import tornado.web
import json, os, ConfigParser, sys
from PyLucene.Retriever import Retriever
from Utils import getItemsWithTopScore, isPriceSame


#shop2020/clients/CatalogClient.py
cmd_folder = os.path.dirname(os.path.abspath("/home/varungupta/code/trunk/PyProj/src/shop2020/"))
if cmd_folder not in sys.path:
    sys.path.insert(0, cmd_folder)

from shop2020.clients.CatalogClient import CatalogClient
    
class BaseHandler(tornado.web.RequestHandler):
    def get_current_user(self):
        return self.get_secure_cookie('userauth')
    
class LoginHandler(BaseHandler):
    def get(self):
        self.loader = tornado.template.Loader('HTMLTemplates')
        self.write(self.loader.load('LoginForm.html').generate())
    
    def post(self):
        config = ConfigParser.SafeConfigParser()
        config.read('app.cfg')
        
        username = self.get_argument('username')
        password = self.get_argument('password')
        
        if username == config.get('auth', 'username') and password == config.get('auth', 'password'):
            print 'Password Matched'
            self.set_secure_cookie("userauth", username + '_' + password)
            self.redirect('/')
        else:
            self.redirect('/login')

class MainHandler(BaseHandler):

    @tornado.web.authenticated
    def get(self):
        self.loader = tornado.template.Loader('HTMLTemplates')
        catalog_client = CatalogClient().get_client()
        items = catalog_client.getAllItems(True)
        
        retriever = Retriever()
        products = {}
        
        for item in items:
            if item.category in (10002, 10003, 10004, 10005, 10010):  products[item.catalogItemId] = item

        comparative_prices = []
        count_all, count_success, count_conflict, count_notfound = 0, 0, 0, 0
        
        for item in sorted(products.itervalues(), key = lambda item: item.brand):
            count_all += 1
            try:
                model_name = item.modelName.strip() if len(item.modelName.strip()) > 0 else None
                model_number = item.modelNumber.strip() if len(item.modelNumber.strip()) > 0 else None
                
                search_results = retriever.retrieve(model_number = model_number, model_name = model_name, brand = item.brand)
                phones_with_top_score = getItemsWithTopScore(search_results)
                
                if len(phones_with_top_score) > 0:
                    if isPriceSame(phones_with_top_score):
                        flipkart_price = phones_with_top_score[0]['price']
                        count_success += 1
                        data = ''
                        url = "http://www.flipkart.com%s" % phones_with_top_score[0]['url']
                    else:
                        flipkart_price = 'Conflict'
                        print item.brand, model_name, model_number
                        print 'CONFLICT\n'
                        print search_results
                        print phones_with_top_score
                        count_conflict += 1
                        data = json.dumps(phones_with_top_score)
                        url = '#'
                        
                else:
                    flipkart_price = 'Not Found'
                    print item.brand, model_name, model_number
                    print 'NOT FOUND\n'
                    print search_results
                    print phones_with_top_score
                    count_notfound += 1
                    data = ''
                    url = ''
                
                product_name = "%s " % item.brand
                product_name += "%s " % model_name if model_name is not None else ''
                product_name += model_number if model_number is not None else ''
                
                comparative_prices.append({
                    'product_name': product_name,
                    'saholic_price': item.sellingPrice,
                    'flipkart_price': flipkart_price.replace('Rs. ', ''),
                    'td_class': 'conflict' if flipkart_price in ('Conflict') else '',
                    'data': data,
                    'url': url
                })
            except Exception as e:
                print e.message
        
        print count_all, count_success, count_conflict, count_notfound
        self.write(self.loader.load('PriceChart.html').generate(data = comparative_prices))


class SearchHandler(tornado.web.RequestHandler):
    
    def get(self):
        self.loader = tornado.template.Loader('HTMLTemplates')
        
        try:
            search_query = self.get_argument("q")
            results = Retriever().retrieve(search_query)
            self.write(self.loader.load('SearchResults.html').generate(phones = results, query = search_query))
        
        except Exception:
            self.write(self.loader.load('SearchForm.html').generate())

settings  = {
        'static_path': os.path.join(os.path.dirname(__file__), 'static'),
        'login_url': '/login', 
        'cookie_secret' :"61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo="
}

application = tornado.web.Application([
                (r"/", MainHandler),
                (r"/search", SearchHandler),
                (r"/login", LoginHandler),
                (r"/(jquery-1.6.2.min\.js)", tornado.web.StaticFileHandler, dict(path=settings['static_path']))
            ], **settings)

if __name__ == '__main__':
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(8889)
    tornado.ioloop.IOLoop.instance().start()