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.clients.TransactionClient import TransactionClient

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, Campaigns

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.filter_by(UserEmail.status == 0).all()

def mark_email_as_sent(email_id):

    UserEmail.query.filter(UserEmail.status==1).delete()

    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.status=1

    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:

        tclient = TransactionClient().get_client()

        order = tclient.getOrder(order_id)

        if order.logisticsTransactionId:

            email = UserEmailArchive.get_by(emailType = 'DeliverySuccess', source = order.logisticsTransactionId)

            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_sms_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()

        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_sent(userSmsList):

    UserSms.query.filter(UserSms.status==SmsStatus._VALUES_TO_NAMES[SmsStatus.DELIVERED]).delete()

    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]

            query = 'INSERT INTO ' + str(UserSmsArchive.table) + ' (select * from ' + str(UserSms.table) + ' where id = ' + str(sms.id) + ')'

            session.execute(query, mapper=UserSmsArchive)

            sms.status = SmsStatus._VALUES_TO_NAMES[SmsStatus.DELIVERED]

    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 addCampaignNotification(userEmail,campaignType):

    try:

        exist = Campaigns.get_by(userEmail=userEmail,campaignType=campaignType)

        if exist is not None:

            return "You are already registered."

        else:

            c = Campaigns()

            c.userEmail = userEmail

            c.campaignType = campaignType

            session.commit()

            return "Email registered successfully."

    except Exception as e:

        print e

        return "OOPS!!!Please try again."

def close_session():

    if session.is_active:

        print "session is active. closing it."

        session.close()

def is_alive():

    try:

        return True

    except:

        return False