Subversion Repositories SmartDukaan

'''
Created on 14-Jul-2010

@author: ashish
'''
from shop2020.config.client.ConfigClient import ConfigClient
from shop2020.helpers.impl import DataAccessor
from shop2020.helpers.impl.Converters import to_t_luser, to_t_useremail, \
    to_t_suser, to_t_ruser, to_t_report, to_t_catalog_user, to_t_quicklink, \
    to_t_user_sms, to_t_user_sms_info
from shop2020.helpers.impl.DataAccessor import getSubstitutedMessage, getMessage, \
    updateMessage, addMessage, add_user, delete_user, update_password, \
    share_entities, save_user_email_for_sending, get_emails_to_be_sent, \
    mark_email_as_sent, initialize, close_session, get_reports, \
    authenticate_dashboard_user, is_alive, save_quick_link, get_quick_links, \
    update_quicklink, get_emails_for_notifications_sent, update_password_for_agent, \
    get_order_confirmation_mail, get_order_delivery_mail, get_warehouseIds_for_agent, \
    save_user_sms_for_sending, get_sms_to_be_sent, add_user_sms_info, \
    update_user_sms_info, get_all_users_sms_info, list_sms_to_get_delivery_info, \
    mark_messages_as_sent_to_operator, mark_messages_as_submitted_to_smsc, \
    mark_messages_as_sent, mark_messages_as_retry, get_user_sms_info, \
    authorise_dealer, addCampaignNotification
from shop2020.helpers.impl.DataService import LogisticsUser, StatisticsUser, \
    ReportUser, CatalogDashboardUser
from shop2020.helpers.impl.model.Agent import Agent, User_Roles, \
    Roles_Permissions
from shop2020.thriftpy.utils.ttypes import HelperServiceException
from shop2020.utils.Utils import to_py_date


class HelperServiceHandler():
    

    def __init__(self, dbname='helper', db_hostname='localhost'):
        initialize(dbname, db_hostname)
        
        '''
        try:
            config_client = ConfigClient()
            self.customer_care_mail = config_client.get_property('saholic_customer_care_mail')
        except:    
            self.customer_care_mail = "help@saholic.com"
        ''' 

    def saveUserEmailForSending(self, emailTo, emailFrom, subject, body, source, emailType, cc, bcc, sourceId):
        try:
            return save_user_email_for_sending(emailTo, emailFrom, subject, body, source, emailType, cc, bcc, sourceId)
        finally:
            close_session()
    
    def getEmailsToBeSent(self):
        try:
            return [to_t_useremail(user_email) for user_email in get_emails_to_be_sent()]
        finally:
            close_session()
    
    def markEmailAsSent(self, emailId):
        try:
            mark_email_as_sent(emailId)
        finally:
            close_session()
    
    def sendMail(self, mail):
        try:
            DataAccessor.sendMail(mail)
        finally:
            close_session()
            
    def sendText(self, message):
        """
        Parameters:
         - message
        """
        try:
            DataAccessor.sendText(message)
        finally:
            close_session()
            
    def addMessage(self, message):
        """
        Parameters:
         - message
        """
        try:
            addMessage(message)
        finally:
            close_session()
            
    def updateMessage(self, id, message):
        """
        Parameters:
         - id
         - message
        """
        try:
            return updateMessage(id, message)
        finally:
            close_session()
            
    def getMessage(self, id):
        """
        Parameters:
         - id
        """
        try:
            return getMessage(id)
        finally:
            close_session()
            
    def getSubstitutedMessage(self, id, params):
        """
        Parameters:
         - id
         - params
        """
        try:
            return getSubstitutedMessage(id, params)
        finally:
            close_session()
            
    def addUser(self, username, password, warehouseId):
        """
        Parameters:
         - username
         - password
         - warehouseId
        """
        try:
            return add_user(username, password, warehouseId)
        finally:
            close_session()
    
    def deleteUser(self, username):
        """
        Parameters:
         - username
        """
        try:
            return delete_user(username)
        finally:
            close_session()
                
    def authenticateDashboardUser(self, username, password):
        """
        Returns the dashboard user if the supplied username and password match. Raises an exception otherwise.
        The loggedOn timestamp for the dashboard user is updated .
        
        Parameters:
         - username
         - password
        """
        try:
            return authenticate_dashboard_user(username, password)
        finally:
            close_session()
            
    
    def updatePassword(self, username, oldPassword, newPassword):
        """
        Parameters:
         - username
         - oldPassword
         - newPassword
        """
        try:
            update_password(username, oldPassword, newPassword)
        finally:
            close_session()

    def authenticateLogisticsUser(self, username, password):
        """
        Returns the LogisticsUser struct associated with the given username and password if they match.
        Throws an exception otherwise.
        
        Parameters:
         - username
         - password
        """
        try:
            luser = LogisticsUser.get_by(username=username, password=password)
            return to_t_luser(luser)
        except:
            raise HelperServiceException(101, "No such user")
        finally:
            close_session()
            
    def authenticateStatisticsUser(self, username, password):
        """
        Returns the StatisticsUser struct associated with the given username and password if they match.
        Throws an exception otherwise.
        
        Parameters:
         - username
         - password
        """
        try:
            suser = StatisticsUser.get_by(username=username, password=password)
            return to_t_suser(suser)
        except:
            raise HelperServiceException(101, "No such user")
        finally:
            close_session()

    def authenticateReportUser(self, username, password):
        """
        Returns the ReportUser struct associated with the given username and password if they match.
        Throws an exception otherwise.
        
        Parameters:
         - username
         - password
        """
        try:
            ruser = ReportUser.get_by(username=username, password=password)
            return to_t_ruser(ruser)
        except:
            raise HelperServiceException(101, "No such user")
        finally:
            close_session()

    def getReports(self, role):
        """
        Returns list of reports which are configured for the given role.
        
        Parameters:
         - role
        """
        try:
            reports = get_reports(role) 
            return [to_t_report(report) for report in reports]
        finally:
            close_session()
            
    def authenticateCatalogUser(self, username, password):
        """
        Returns the CatalogDashboardUser struct associated with the given username and password if they match.
        Throws an exception otherwise.
        
        Parameters:
         - username
         - password
        """
        try:
            catalog_user = CatalogDashboardUser.get_by(username=username, password=password)
            return to_t_catalog_user(catalog_user)
        except:
            raise HelperServiceException(101, "No such catalog user")
        finally:
            close_session()
    
    def shareEntities(self, entityIds, email):
        '''
        Shares the entities with en email
        
        Parameters:
         - entityIds
         - email
        '''
        try:
            share_entities(entityIds, email)
        finally:
            close_session()

    def getAgents(self, ):
        return [Agent.to_thrift_object(t) for t in Agent.query.all()]

    def validateLogIn(self, emailId, password):
        """
        Parameters:
         - emailId
         - password
        """
        pass

    def updatePasswordForAgent(self, agentEmailId, password):
        """
        Parameters:
         - agentEmailId
         - password
        """
        try:
            update_password_for_agent(agentEmailId, password)
        finally:
            close_session()

    def getRoleNamesForAgent(self, agentEmailId):
        """
        Parameters:
         - agentEmailId
        """
        try:
            agent = Agent.get_by(emailId = agentEmailId)
            return [a.role_name for a in User_Roles.query.filter_by(agentId = agent.id).all()]
        finally:
            close_session()

    def getPermissionsForRoleName(self, roleName):
        """
        Parameters:
         - roleName
        """
        try:
            return [a.permission for a in Roles_Permissions.query.filter_by(role_name = roleName).all()]
        finally:
            close_session()
    
    def saveQuickLink(self, url, text):
        try:
            save_quick_link(url, text)
        finally:
            close_session()
    
    def getQuickLinks(self):
        try:
            return [to_t_quicklink(quicklink) for quicklink in get_quick_links()]
        finally:
            close_session()
    
    def updateQuickLink(self, id, url, text):
        try:
            update_quicklink(id, url, text)
        finally:
            close_session()
    
    def getEmailsForNotificationsSent(self, startDatetime, endDatetime):
        '''
        '''
        try:
            return [notification.emailTo for notification in get_emails_for_notifications_sent(to_py_date(startDatetime), to_py_date(endDatetime))]
        finally:
            close_session()
    
    def getOrderConfirmationMail(self, orderId):
        try:
            return get_order_confirmation_mail(orderId)
        finally:
            close_session()
    
    def getOrderDeliveryMail(self,order_id):
        try:
            return get_order_delivery_mail(order_id)
        finally:
            close_session()
            
    def getWarehouseIdsForAgent(self, agentEmailId):
        try:
            return get_warehouseIds_for_agent(agentEmailId)
        finally:
            close_session()
            
    def saveUserSmsForSending(self, userId, mobileNo, text, type):
        try:
            return save_user_sms_for_sending(userId, mobileNo, text, type)
        finally:
            close_session()
            
    def getSmsToBeSent(self):
        ret_Sms = []
        try:
            sms_list = get_sms_to_be_sent()
            for sms in sms_list:
                ret_Sms.append(to_t_user_sms(sms))
            return ret_Sms
        finally:
            close_session()
            
    def addUserSmsInfo(self, userSmsInfo):
        try:
            add_user_sms_info(userSmsInfo)
        finally:
            close_session()
            
    def updateUserSmsInfo(self, userSmsInfo):
        try:
            return update_user_sms_info(userSmsInfo)
        finally:
            close_session()
            
    def getUserSmsInfo(self, userId):
        try:
            return to_t_user_sms_info(get_user_sms_info(userId))
        finally:
            close_session()
            
    def authoriseDealer(self, dealerAuth):
        try:
            return authorise_dealer(dealerAuth)
        finally:
            close_session() 
        
    def getAllUsersSmsInfo(self):
        try:
            ret_all_user_smsInfo = []
            users_smsInfo = get_all_users_sms_info()
            for smsInfo in users_smsInfo:
                ret_all_user_smsInfo.append(to_t_user_sms_info(smsInfo))
            return ret_all_user_smsInfo
        finally:
            close_session()
    
    def listSmsToGetDeliveryInfo(self):
        ret_Sms = []
        try:
            sms_list = list_sms_to_get_delivery_info()
            for sms in sms_list:
                ret_Sms.append(to_t_user_sms(sms))
            return ret_Sms
        finally:
            close_session()
            
    def markMessagesAsSentToOperator(self, userSmsList):
        try:
            return mark_messages_as_sent_to_operator(userSmsList)
        finally:
            close_session()
            
    def markMessagesAsSubmittedToSmsc(self, userSmsList):
        try:
            return mark_messages_as_submitted_to_smsc(userSmsList)
        finally:
            close_session()
            
    def markMessagesAsSent(self, userSmsList):
        try:
            return mark_messages_as_sent(userSmsList)
        finally:
            close_session()
                
    def markMessagesAsRetry(self, userSmsList):
        try:
            return mark_messages_as_retry(userSmsList)
        finally:
            close_session()
    
    def addCampaignNotification(self,userEmail,campaignType):
        try:
            return addCampaignNotification(userEmail,campaignType)
        finally:
            close_session()
                
    def closeSession(self, ):
        close_session()
        
    def isAlive(self, ):
        """
        For checking weather service is active alive or not. It also checks connectivity with database
        """
        try:
            return is_alive()
        finally:
            close_session()