JoyUssdEngine

gem 'joy_ussd_engine'

gem 'redis'
gem 'redis-namespace'

# Not required but you can add connection pool for redis if you want
gem 'connection_pool', '~> 2.2', '>= 2.2.2'

# With Connection Pool
require 'connection_pool'
NAMESPACE = :DEFAULT_NAMESPACE
REDIS = ConnectionPool.new(size: 10) { Redis::Namespace.new(NAMESPACE, :redis => Redis.new) }

# Without Connection Pool
NAMESPACE = :DEFAULT_NAMESPACE
REDIS = Redis::Namespace.new(NAMESPACE, :redis => Redis.new)

class MyController < ApplicationController
  skip_before_action :verify_authenticity_token

  def create
    joy_ussd_engine = JoyUssdEngine::Core.new(ussd_params, JoyUssdEngine::HubtelTransformer, start_point: Ussd::Menus::StartMenu, end_point: Ussd::Menus::EndMenu)
    response = joy_ussd_engine.process
    render json: response, status: :created
  end

  def ussd_params
    params.permit(:SessionId, :Mobile, :ServiceCode, :Type, :Message, :Operator, :Sequence, :ClientState)
  end
end

class Ussd::Transformers::HubtelTransformer < JoyUssdEngine::DataTransformer
    # Transforms request payload between hubtel and our application
    # The session_id and message fields are required so we get them from hubtel (session_id: params[:Mobile] and message: params[:Message]).
    # And we pass in other hubtel specific params like (ClientState: params[:ClientState], Type: params[:Type])
    def request_params(params)
        {
            session_id: params[:Mobile],
            message: params[:Message],
            ClientState: params[:ClientState],
            Type: params[:Type],
            data: params
        }
    end

    # We check if hubtel sends a params[:Type] == 'Release' and terminate the application
    # OR
    # the hubtel params[:Type] is not a string with value "Initiation" and state data is blank (@context.get_state.blank?)
    def app_terminator(params)
        params[:Type] == 'Release' || (params[:Type] != "Initiation" && @context.get_state.blank?)
    end

    # Transforms response payload back to the format hubtel accepts by setting the message field (Type: "Response",Message: message, ClientState: client_state)
    def response(message, client_state)
        {
            Type: "Response",
            Message: message,
            ClientState: client_state
        }
    end


    # Transforms response payload back to the format hubtel accepts by setting the message field (Type: "Response",Message: message, ClientState: client_state) and then end the user session
    def release(message)
        {
            Type: "Release",
            Message: message,
            ClientState: "End"
        }
    end


    # Time for which the session has to end if the user does not send a request.
    def expiration
        60.seconds
    end
end

class Ussd::Menus::MainMenu < JoyUssdEngine::Menu
    def on_validate
        # use this method to validate the user's input

        # use @context.get_state with the @field_name value set in the before_render method to get the user inputs
        if @context.get_state[:request] != "john doe"
            # in case of errors set the @field_error value to true and set an error message in @error_text
            @field_error = true
            @error_text = "Wrong Value enter the correct value"
        end
    end

    def before_render
        # Implement before call backs

        # store the input name for this ussd menu in the @field_name variable
        @field_name = "request"

        # store the text to show or render out in the ussd menu with the @menu_text variable
        @menu_text = "Type you name"
    end

    def on_error
        # this method will be executed if @field_error is set to true

        # catch errors and display the errors in the ussd menu by setting the @menu_text to include the error_message from @error_text
        @menu_text = "#{@error_text}\n#{@menu_text}"
    end

    def after_render
        # Implement after call backs
    end

    def render
        # Render ussd menu here

        # the joy_response renders out the ussd menu and takes the class of the next menu to route to as an argument.
        joy_response(Ussd::Menus::NextMenu)
    end
end

# Just call @context.params[key] to access a particular value coming from a post request made available to our app through the DataTransformer.request_params method.

@context.params[:message] # Gets the message the user enters from the post end point.

# Just call @context.set_state(key: value) to set a key with a particular value
@context.set_state(selected_book: selected_book)

# To access the values @context.get_state[:key]
@context.get_state[:selected_book]

# This stores the name of the input field for this menu
@field_name = "user_email"

# @skip_save = true -  user input will not be saved

# We can now get the user's input any where in our application with @context.get_state.
@context.get_state[:user_email]

# We raise an error in our application
return raise_error("Sorry something went wrong!")

class Ussd::Menus::InitialMenu < JoyUssdEngine::Menu

    def before_render
        # Implement before call backs
        @field_name='initiation'
        @skip_save = true

        # Store a list of menu items with their routes
        @menu_items = [
            {title: 'Make Payments', route: Ussd::Menus::MakePayments},
            {title: 'View Transaction', route: Ussd::Menus::ViewTransaction}
        ]

        # Show menu items on screen with the show_menu method.
        # The show_menu takes an optional parameter which is used to display the title of the page.
        @menu_text = show_menu('Welcome to JoyUssdEngine')
    end

    def render
        # Render ussd menu here

        # Use the `load_menu` method to load the menus on screen
        # The `get_selected_item` method automatically listens to user inputs and passes the selected menu into the `load_menu` method
        load_menu(get_selected_item)
    end
end

class Ussd::Menus::ViewTransaction < JoyUssdEngine::Menu

    def before_render
        # Implement before call backs

        @menu_text = "Transactions. \n1. ERN_CODE_SSD\n2. ERN_DESA_DAS\nThanks for using our services."
    end

    def render
        # Render ussd menu here
        joy_release
    end
end

 class Ussd::Menus::Books < JoyUssdEngine::PaginateMenu

        def before_render
            # Implement before call backs

            # set an array of items that are going to be paginated
            @paginating_items = [
                {title: "Data Structures", item: {id: 1}},
                {title: "Excel Programming", item: {id: 2}},
                {title: "Economics", item: {id: 3}},
                {title: "Big Bang", item: {id: 4}},
                {title: "Democracy Building", item: {id: 5}},
                {title: "Python for Data Scientist", item: {id: 6}},
                {title: "Money Mind", item: {id: 7}},
                {title: "Design Patterns In C#", item: {id: 8}}
            ]

            # The `paginate` method returns a list of paginated items for the current page when it is called
            paginated_list = paginate

            # In a PaginateMenu the `show_menu` method takes a list and two optional named parameter values (title,key).

            # The title shows the page title for the menu.

            # The key stores the key of the hash which contains the text to be rendered for each list item.

            # If the key is not set the paginating_items is treated as a string and rendered to the user.

            # eg: @paginating_items = ["Data Structures","Excel Programming","Economics","Big Bang","Democracy Building","Python for Data Scientist","Money Mind","Design Patterns In C#"]

            @menu_text = show_menu(paginated_list, title: 'My Books', key: 'title')

            # In other to select a paginating item we have to wrap the selection logic in an if has_selected? block to prevent some weird errors.
            if has_selected?
                # the get_selected_item is used to get the selected item from the paginating list
                selected_book = get_selected_item

                # We save the selected book so we can access later
                @context.set_state(selected_book: selected_book)
            end
        end

        def render
            # Render ussd menu here

            # The load_menu function points to a menu to load when a book is selected.
            load_menu(Ussd::Menus::ShowBook)
        end
    end

class Ussd::Menus::ShowBook < JoyUssdEngine::Menu
    def before_render
        # Implement before call backs
        book = @context.get_state[:selected_book]
        @menu_text = "The selected book is \nid: #{book[:item][:id]}\nname: #{book[:title]}"
    end

    def after_render
        # Implement after call backs
    end

    def render
        # Render ussd menu here
        joy_release
    end
end

class HubtelTransformer < JoyUssdEngine::DataTransformer
    # Tranforms request and response payload between hubtel and our application
    def request_params(params)
        {
            session_id: params[:Mobile],
            message: params[:Message],
            ClientState: params[:ClientState],
            Type: params[:Type]
            data: params
        }
    end

    def app_terminator(params)
        params[:Type] == 'Release' || (params[:Type] != "Initiation" && @context.get_state.blank?)
    end

    def response(message, client_state)
        {
            Type: "Response",
            Message: message,
            ClientState: client_state
        }
    end

    def release(message)
        {
            Type: "Release",
            Message: message,
            ClientState: "End"
        }
    end

    def expiration
        60.seconds
    end
end

class TwilioTransformer < JoyUssdEngine::DataTransformer
    ACCOUNT_SID = "932843hwhjewhje7388"
    AUTH_TOKEN = "3473847hewjrejrheeee"

    def client
        @client ||= Twilio::REST::Client.new(ACCOUNT_SID, AUTH_TOKEN)
    end

    # Tranforms request and response payload between twilio and our application
    def request_params(params)
        {
            session_id: "0#{params[:From].last(9)}",
            message: params[:Body],
            Mobile: "0#{params[:From].last(9)}",
            data: params
        }
    end

    def app_terminator(params)
        params[:Body] == 'end'
    end

    def response(message, client_state)
        client.messages.create(
            from: from,
            to: to,
            body: message
        )
        {message: message}
    end

    def release(message)
        client.messages.create(
            from: from,
            to: to,
            body: message
        )
        {message: message}
    end

    def expiration
        # set expiration for different providers
    end

    def to
        "whatsapp:+233#{@context.params[:Mobile].last(9)}"
    end

    def from
        'whatsapp:+14155238886'
    end
end