Subversion Repositories SmartDukaan

'''
Created on 14-Jul-2010

@author: ashish
'''
from elixir import *
from email import encoders
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from shop2020.clients.CatalogClient import CatalogClient
from shop2020.helpers.impl import DataService
from shop2020.helpers.impl.DataService import Message, UserEmail, EntitiesShared, \
    Report, ReportRoleAuthority, CatalogDashboardUser, UserEmailArchive, QuickLink, \
    AgentWarehouseMapping, UserSms, UserSmsInfo, UserSmsArchive, DealerAuth
from shop2020.helpers.impl.model.Agent import Agent
from shop2020.helpers.impl.model.DashboardUser import DashboardUser
from shop2020.thriftpy.utils.ttypes import HelperServiceException, Mail, \
    Message as Msg, SmsStatus, SmsType, SmsDeliveryStatus
from shop2020.utils.Utils import log_entry, to_py_date, to_java_date
from sqlalchemy.orm import query
from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
from sqlalchemy.sql import func
from sqlalchemy.sql.expression import and_, or_, desc, not_, distinct, cast, \
    between
from string import Template
import datetime
import os
import smtplib

def initialize(dbname='helper', db_hostname="localhost"):
    log_entry("initialize@DataAccessor", "Initializing data service")
    DataService.initialize(dbname, db_hostname)
    
def save_user_email_for_sending(email_to, email_from, subject, body, source, email_type, cc, bcc, sourceId):
    ## Do not send mail to users except source Website.
    if sourceId != 1:
        return 0
    user_email = UserEmail()
    user_email.emailTo = ';'.join(email_to)
    user_email.emailFrom = email_from
    user_email.subject = subject
    user_email.body = body
    user_email.source = source
    user_email.emailType = email_type
    user_email.status = False
    user_email.timestamp = datetime.datetime.now()
    if cc:
        user_email.cc = ';'.join(cc)
    if bcc:
        user_email.bcc = ';'.join(bcc)
    session.commit()
    return user_email.id

def get_emails_to_be_sent():
    print "get_emails_to_be_sent"
    return UserEmail.query.all()

def mark_email_as_sent(email_id):
    query = 'INSERT INTO ' + str(UserEmailArchive.table) + ' (select * from ' + str(UserEmail.table) + ' where id = ' + str(email_id) + ')'
    session.execute(query, mapper=UserEmailArchive)
    email = UserEmail.get_by(id = email_id)
    if email:
        email.delete()
    session.commit()

def sendMail(mail):
    if not mail:
        raise HelperServiceException(101, "mail not present")
    #msg = MIMEMultipart()
    #mail = Mail()
    if mail.sender:
        mail.data = "This mail is sent by " + mail.sender + "\n" + mail.data
        
    msg = MIMEText(mail.data)
    msg['To'] = ', '.join( mail.to )
    if mail.sender:
        msg['From'] = mail.sender
    else:    
        msg['From'] = "help@saholic.com"
    msg['Subject'] = mail.subject
    #msg.attach(mail.data)
    
    #handle attachments in mail
    if mail.attachments:
        for attach in mail.attachments:
                   
            part = MIMEBase('application', 'octet-stream')
            part.set_payload(open(attach, 'rb').read())
            encoders.encode_base64(part)
            part.add_header('Content-Disposition',
                    'attachment; filename="%s"' % os.path.basename(attach))
            msg.attach(part)
    
    for to in mail.to:
        mail.sender = "help@shop2020.in"
        mail.password = "5h0p2o2o"
        mailServer = smtplib.SMTP("smtp.gmail.com", 587)
        mailServer.ehlo()
        mailServer.starttls()
        mailServer.ehlo()
        mailServer.login(mail.sender, mail.password)
        mailServer.sendmail(mail.password, to, msg.as_string())
        # Should be mailServer.quit(), but that crashes...
        mailServer.close() 
        
def sendText(text):
    pass

def addMessage(message):
    msg = Message.get_by(message_id=message.id)
    if msg:
        raise HelperServiceException(101, "Message is already present. Please try updation api instead")
    msg = Message();
    msg.message_id = message.id
    msg.message = message.message
    session.commit()
    
def getMessage(message_id):
    msg = Message.get_by(id=message_id)
    message = Msg()
    message.id = msg.message_id
    message.message = msg.message
    return message

def updateMessage(id, message):
    msg = Message.get_by(message_id=id)
    if msg:
        msg.message = message
        session.commit()
    else:
        raise HelperServiceException(101, "message could not be found with id %d" %(id))

def getSubstitutedMessage(id, params):
    #get the message first
    msg = Message.get_by(message_id=id)
    if not msg:
        raise HelperServiceException(101, "message could not be found with id %d" %(id))
    if params:
        s = Template(msg.message)
        s = s.safe_substitute(params)
        return s
    else:
        return msg.message

def add_user(username, password, warehouseId):
    user = DashboardUser()
    user.username = username
    user.password = password
    user.warehouseId = warehouseId
    user.addedOn = datetime.datetime.now()
    user.status = 0
    try:
        session.commit()
        return True
    except:
        raise HelperServiceException(101, "Some error while adding user")
        return False

def delete_user(username):
    user = DashboardUser.get_by(username=username)
    if user is None:
        return False
    user.delete()
    session.commit()
    return True

def authenticate_dashboard_user(username, password):
    user = DashboardUser.get_by(username=username, password=password)
    if user is None:
        raise HelperServiceException(101, "No dashboard user found")
    
    user.loggedOn = datetime.datetime.now()
    session.commit()
    return user.to_thrift_object()
    
def update_password(username, oldPassword, newPassword):
    user = DashboardUser.get_by(username=username)
    if user is None:
        return False
    if user.password == oldPassword:
        user.password = newPassword
        session.commit()
        return True
    return False

def get_reports(role):
    query = session.query(Report).join(ReportRoleAuthority)
    query = query.filter(ReportRoleAuthority.role == role)
    reports = query.all()
    return reports

def share_entities(entityIds, email):
    if entityIds:
        entityIdsStr = ''
        email_body = get_email_body_for_product_sharing(entityIds)
        save_user_email_for_sending(email, '', 'Check out Saholic.com', email_body, '', 'MOBILE_SHARE')
        
        for entityId in entityIds:
            entityIdsStr += str(entityId)
        
        entities_to_be_shared = EntitiesShared()
        entities_to_be_shared.entityIds = entityIdsStr
        entities_to_be_shared.email = email
        entities_to_be_shared.isEmailed = False
        session.commit()

def get_email_body_for_product_sharing(entityIds):
    catalog_client = CatalogClient().get_client()
    
    emailBody = '<html><body><p>Check out following products on Saholic:</p><ul>\n'
    for entityId in entityIds:
        list_items = catalog_client.getItemsByCatalogId(entityId)
        url = 'http://www.saholic.com/entity/%s' % (entityId)
        item = list_items[0]
        name = item.brand + ' '
        name += item.modelName + ' ' if item.modelName is not None else ''
        name += item.modelNumber if item.modelNumber is not None else ''
        emailBody += '<li><a href="%s">%s</a></li>' % (url, name)
    emailBody += '</ul></body></html>'
    return emailBody

def save_quick_link(url, text):
    quickLink = QuickLink()
    quickLink.url = url
    quickLink.text = text
    session.commit()

def get_quick_links():
    return QuickLink.query.all()

def update_quicklink(id, url, text):
    quicklink = QuickLink.get_by(id = id)
    quicklink.url = url
    quicklink.text = text
    session.commit()

def update_password_for_agent(agentEmailId, password):
    agent = Agent.get_by(emailId = agentEmailId)
    agent.password = password
    session.commit()

def get_emails_for_notifications_sent(start_datetime, end_datetime):
    query = UserEmailArchive.query.filter(UserEmailArchive.emailType == 'ProductNotification')
    query = query.filter(UserEmailArchive.timestamp >= start_datetime)
    query = query.filter(UserEmailArchive.timestamp <= end_datetime)
    return query.all()
def get_order_confirmation_mail(order_id):
    email = UserEmailArchive.get_by(emailType = 'TransactionInfo', source = order_id)
    #Start:- Added by Manish Sharma for resolving Exception for getting order delivery and confirmation mail on 27-Jun-2013
    if email:
        return email.body
    else:
        return ''
    #End:- Added by Manish Sharma for resolving Exception for getting order delivery and confirmation mail on 27-Jun-2013
    
def get_order_delivery_mail(order_id):
    email = UserEmailArchive.get_by(emailType = 'DeliverySuccess', source = order_id)
    #Start:- Added by Manish Sharma for resolving Exception for getting order delivery and confirmation mail on 27-Jun-2013
    if email:
        return email.body
    else:
        return ''
    #End:- Added by Manish Sharma for resolving Exception for getting order delivery and confirmation mail on 27-Jun-2013

def get_warehouseIds_for_agent(agent_emailId):
    agent = Agent.get_by(emailId = agent_emailId)
    agent_warehouse_mappings = AgentWarehouseMapping.query.filter(AgentWarehouseMapping.agentId == agent.id).all()
    warehouseIds = []
    for mapping in agent_warehouse_mappings:
        try:
            warehouseIds.append(mapping.warehouseId)
        except:
            raise HelperServiceException(108, "Exception while getting warehouseIds for Agent")
    return warehouseIds

def save_user_sms_for_sending(userId, mobileNo, text, type):
    userSms = UserSms()
    userSms.user_id = userId
    userSms.createdTimestamp = datetime.datetime.now()
    userSms.mobileNumber = mobileNo
    userSms.attempts = 0
    userSms.smsText = text
    userSms.type = SmsType._VALUES_TO_NAMES[type]
    userSms.status = SmsStatus._VALUES_TO_NAMES[0]
    userSms.deliveryStatus = SmsDeliveryStatus._VALUES_TO_NAMES[0]
    session.commit()
    return userSms.id
    
def get_sms_to_be_sent():
    print "get_emails_to_be_sent"
    return UserSms.query.filter(UserSms.deliveryStatus== SmsDeliveryStatus._VALUES_TO_NAMES[SmsDeliveryStatus.NOT_SENT]).all()

def mark_sms_as_sent(smsId, status, responseId, responseText):
    sms = UserSms.get_by(id=smsId)
    if sms:
        sms.attempts = sms.attempts+1
        sms.status = SmsStatus._VALUES_TO_NAMES[status]
        sms.responseId = responseId
        sms.responseText = responseText
        session.commit()
    query = 'INSERT INTO ' + str(UserSmsArchive.table) + ' (select * from ' + str(UserSms.table) + ' where id = ' + str(smsId) + ')'
    session.execute(query, mapper=UserSmsArchive)
    if sms:
        sms.delete()
    session.commit()
    
def mark_sms_as_retry(smsId, status, responseId, responseText):
    sms = UserSms.get_by(id=smsId)
    if sms:
        if sms.attempts<3:
            sms.attempts = sms.attempts+1
            sms.status = SmsStatus._VALUES_TO_NAMES[status]
            sms.responseId = responseId
            sms.responseText = responseText
            session.commit()
            return True
        else:
            return False
    else:
        return False

def add_user_sms_info(userSms_Info):
    userSmsInfo = UserSmsInfo()
    userSmsInfo.userId = userSms_Info.userId
    userSmsInfo.mobileNo = userSms_Info.mobileNo
    userSmsInfo.createdTimestamp = to_py_date(userSms_Info.createdTimestamp)
    userSmsInfo.updateTimestamp = to_py_date(userSms_Info.updateTimestamp)
    userSmsInfo.dailyCount = 0
    userSmsInfo.weeklyCount = 0
    userSmsInfo.dndStatus = False
    userSmsInfo.smsSubscribed = True
    session.commit()
    
def update_user_sms_info(userSms_Info):
    userSmsInfo = UserSmsInfo.query.filter(UserSmsInfo.userId == userSms_Info.userId).first()
    if userSmsInfo:
        userSmsInfo.mobileNo = userSms_Info.mobileNo
        userSmsInfo.dndStatus = userSms_Info.dndStatus
        userSmsInfo.smsSubscribed = userSms_Info.smsSubscribed
        userSmsInfo.dailyCount = userSms_Info.dailyCount
        userSmsInfo.weeklyCount = userSms_Info.weeklyCount
        userSmsInfo.updateTimestamp = datetime.datetime.now()
        session.commit()
        return True
    else:
        return False
    
def get_user_sms_info(userId):
    return UserSmsInfo.query.filter(UserSmsInfo.userId == userId).first()

def get_all_users_sms_info(dndStatus, smsSubscribed):
    print 'get all users sms infos'
    return UserSmsInfo.query.filter(UserSmsInfo.dndStatus == dndStatus).filter(UserSmsInfo.smsSubscribed == smsSubscribed).all()

def list_sms_to_get_delivery_info():
    print 'get all message waiting for delivery status'
    return UserSms.query.filter(or_(UserSms.deliveryStatus== SmsDeliveryStatus._VALUES_TO_NAMES[SmsDeliveryStatus.SENT_TO_OPERATOR], UserSms.deliveryStatus== SmsDeliveryStatus._VALUES_TO_NAMES[SmsDeliveryStatus.SUBMITTED_TO_SMSC])).all()

def mark_messages_as_sent_to_operator(userSmsList):
    for userSms in userSmsList:
        sms = UserSms.get_by(id=userSms.id)
        if sms:
            sms.deliveryStatus = SmsDeliveryStatus._VALUES_TO_NAMES[userSms.deliveryStatus]
            sms.attempts = userSms.attempts
            sms.responseId = userSms.responseId
            sms.responseText = userSms.responseText
            session.commit()
    return True
        
def mark_messages_as_submitted_to_smsc(userSmsList):
    for userSms in userSmsList:
        sms = UserSms.get_by(id=userSms.id)
        if sms:
            sms.deliveryStatus = SmsDeliveryStatus._VALUES_TO_NAMES[userSms.deliveryStatus]
            sms.responseText = userSms.responseText
            session.commit()
    return True

def mark_messages_as_sent(userSmsList):
    for userSms in userSmsList:
        sms = UserSms.get_by(id=userSms.id)
        if sms:
            sms.deliveryStatus = SmsDeliveryStatus._VALUES_TO_NAMES[userSms.deliveryStatus]
            sms.responseText = userSms.responseText
            sms.status = SmsStatus._VALUES_TO_NAMES[userSms.status]
            session.commit()
        query = 'INSERT INTO ' + str(UserSmsArchive.table) + ' (select * from ' + str(UserSms.table) + ' where id = ' + str(sms.id) + ')'
        session.execute(query, mapper=UserSmsArchive)
        if sms:
            sms.delete()
        session.commit()
    return True

def mark_messages_as_retry(userSmsList):
    for userSms in userSmsList:
        sms = UserSms.get_by(id=userSms.id)
        if sms:
            sms.deliveryStatus = SmsDeliveryStatus._VALUES_TO_NAMES[userSms.deliveryStatus]
            sms.responseText = userSms.responseText
            sms.status = SmsStatus._VALUES_TO_NAMES[userSms.status]
            session.commit()
        query = 'INSERT INTO ' + str(UserSmsArchive.table) + ' (select * from ' + str(UserSms.table) + ' where id = ' + str(sms.id) + ')'
        session.execute(query, mapper=UserSmsArchive)
        if userSms.attempts < 3:
            new_sms_id= save_user_sms_for_sending(userSms.user_id, userSms.mobileNumber, userSms.smsText, userSms.type)
            new_sms = UserSms.get_by(id=new_sms_id)
            new_sms.status = SmsStatus._VALUES_TO_NAMES[0]
            new_sms.attempts = userSms.attempts
            new_sms.deliveryStatus = SmsDeliveryStatus._VALUES_TO_NAMES[0] 
            session.commit()
        if sms:
            sms.delete()
        session.commit()
    return True

def authorise_dealer(tDealerAuth):
    tDealerAuth.isActive = False
    if tDealerAuth.username:
        dealerAuth = DealerAuth.get_by(username=tDealerAuth.username)
        if dealerAuth:
            if tDealerAuth.password == dealerAuth.password and dealerAuth.isActive == True:
                tDealerAuth.role = dealerAuth.role
                if tDealerAuth.lastLocation and dealerAuth.lattitude and dealerAuth.longitude:
                    dealerAuth.lattitude, dealerAuth.longitude, tDealerAuth.lastLocation.lattitude,tDealerAuth.lastLocation.longitude = tDealerAuth.lastLocation.lattitude,tDealerAuth.lastLocation.longitude, dealerAuth.lattitude, dealerAuth.longitude
                if dealerAuth.lastLoggedIn is not None:
                    tDealerAuth.lastLoggedIn = to_java_date(dealerAuth.lastLoggedIn)
                else:
                    tDealerAuth.lastLoggedIn = None
                dealerAuth.lastLoggedIn = datetime.datetime.now()
                tDealerAuth.isActive = True
                session.commit()
             
    tDealerAuth.password = None
    return tDealerAuth


def close_session():
    if session.is_active:
        print "session is active. closing it."
        session.close()

def is_alive():
    try:
        return True
    except:
        return False