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