cloudrail_si 0.1.5

data/lib/cloudrail_si/servicecode/commands/object/GetKeyArray.rb

@@ -0,0 +1,21 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class GetKeyArray
+            def get_identifier
+                'object.getKeyArray'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length === 2 &&
+                              Helper.is_var_address(parameters[0]) &&
+                              Helper.is_var_address(parameters[1]))
+                result_var = parameters[0]
+                container = Helper.resolve(environment, parameters[1])
+                keys = container.keys
+                environment.set_variable(result_var, keys)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/object/GetKeyValueArrays.rb

@@ -0,0 +1,29 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class GetKeyValueArrays
+            def get_identifier
+                'object.getKeyValueArrays'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length === 3 &&
+                              Helper.is_var_address(parameters[0]) &&
+                              Helper.is_var_address(parameters[1]) &&
+                              Helper.is_var_address(parameters[2]))
+                result_keys_var = parameters[0]
+                result_values_var = parameters[1]
+                container = Helper.resolve(environment, parameters[2])
+                keys = container.keys
+                values = []
+                (0..keys.length - 1).each do |i|
+                    key = keys[i]
+                    values.push(container[key])
+                end
+                environment.set_variable(result_keys_var, keys)
+                environment.set_variable(result_values_var, values)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/stream/MakeJoinedStream.rb

@@ -0,0 +1,38 @@
+require_relative '../../../helpers/Helper'
+require_relative '../../../helpers/SequenceReadableStream'
+
+module CloudRailSi
+    module ServiceCode
+        class MakeJoinedStream
+            def get_identifier
+                'stream.makeJoinedStream'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length >= 3 &&
+                              Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source = Helper.resolve(environment, parameters[1])
+                Helper.assert(Helper.is_stream(source))
+
+                stream_stack = []
+                (0..parameters.length - 1).each do |i|
+                    stream_1 = Helper.resolve(environment, parameters[i])
+                    Helper.assert(Helper.is_stream(stream_1))
+                    stream_stack.push(stream_1)
+                end
+                result = join_streams(stream_stack)
+                environment.set_variable(result_var, result)
+            end
+
+        private
+            def join_streams(streams)
+                if (streams.length > 1)
+                    return SequenceReadableStream.new(streams.pop(), join_streams(streams))
+                else
+                    return streams.pop()
+                end
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/stream/MakeLimitedStream.rb

@@ -0,0 +1,23 @@
+require_relative '../../../helpers/Helper'
+require_relative '../../../helpers/LimitedReadableStream'
+
+module CloudRailSi
+    module ServiceCode
+        class MakeLimitedStream
+            def get_identifier
+                'stream.makeLimitedStream'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length == 3 &&
+                              Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source = Helper.resolve(environment, parameters[1])
+                limit = Helper.resolve(environment, parameters[2])
+                Helper.assert(Helper.is_stream(source) && Helper.is_number(limit))
+                res_stream = LimitedReadableStream.new(source, limit)
+                environment.set_variable(result_var, res_stream)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/stream/StreamToString.rb

@@ -0,0 +1,25 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class StreamToString
+            def get_identifier
+                'stream.streamToString'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length == 2 &&
+                              Helper.is_var_address(parameters[0]))
+
+                result_var = parameters[0]
+                source = Helper.resolve(environment, parameters[1])
+                if Helper.is_stream(source)
+                    str = Helper.dump_stream(source)
+                else
+                    str = source
+                end
+                environment.set_variable(result_var, str)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/stream/StringToStream.rb

@@ -0,0 +1,20 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class StringToStream
+            def get_identifier
+                'stream.stringToStream'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length == 2 &&
+                              Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source = Helper.resolve(environment, parameters[1])
+                Helper.assert(Helper.is_string(source))
+                environment.set_variable(result_var, Helper.streamify_string(source, nil))
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/string/Base64Encode.rb

@@ -0,0 +1,42 @@
+require_relative '../../../helpers/Helper'
+require 'base64'
+
+module CloudRailSi
+    module ServiceCode
+        class Base64Encode
+            @base64chars_default = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+            @base64chars_web_safe = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
+
+            def get_identifier
+                'string.base64encode'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length >= 2 &&
+                              Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source_string = Helper.resolve(environment, parameters[1])
+                Helper.assert(Helper.is_string(source_string))
+                line_break = false
+                web_safe = false
+                line_break = !!Helper.resolve(environment, parameters[2]) if (parameters.length >= 3)
+                web_safe = !!Helper.resolve(environment, parameters[3]) if (parameters.length >= 4)
+
+                result_string = Base64Encode::encode(source_string, line_break, web_safe)
+                environment.set_variable(result_var, result_string)
+            end
+
+            def self.encode(s, line_break, web_safe)
+                if (!line_break && !web_safe)
+                    return Base64.strict_encode64(s)
+                elsif (!line_break && web_safe)
+                    return Base64.urlsafe_encode64(s)
+                elsif  (line_break && !web_safe)            # breaks after every 60 characters which is slightly different than the node version
+                    return Base64.encode64(s)
+                else
+                    raise Errors::InternalError.new('param combination not supported for Ruby Base64Encode')
+                end
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/string/Format.rb

@@ -0,0 +1,43 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class Format
+            def get_identifier
+                return 'string.format'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length >= 3 &&
+                              Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                format = Helper.resolve(environment, parameters[1])
+                Helper.assert(Helper.is_string(format))
+                element = Helper.resolve(environment, parameters[2])
+                Helper.debug() if (parameters[3] == "break")
+
+                res = nil
+                case format
+                when '%d'
+                    res = element.to_s
+                when '%01x', '%01X'
+                    res = to_one_char_hex(element)
+                when '%02x', '%02X'
+                    res = to_two_char_hex(element)
+                else
+                    raise Errors::InternalError.new("Format with unsupported parameters attempted")
+                end
+                environment.set_variable(result_var, res)
+            end
+
+            def to_one_char_hex(element)
+                ("%01x" % element).upcase
+            end
+
+            def to_two_char_hex(element)
+                # ruby-like sprintf: http://stackoverflow.com/questions/9336550/ruby-sprintf-about-the-2-in-02x
+                ("%02x" % element).upcase
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/string/IndexOf.rb

@@ -0,0 +1,29 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class IndexOf
+            def get_identifier
+                return 'string.indexOf'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert((parameters.length === 3 || parameters.length === 4) &&
+                               Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source_string = Helper.resolve(environment, parameters[1])
+
+                Helper.assert(Helper.is_string(source_string))
+                find = Helper.resolve(environment, parameters[2])
+                from_index = 0
+                if (parameters.length === 4)
+                    from_index = Helper.resolve(environment, parameters[3])
+                    Helper.assert(Helper.is_number(from_index))
+                    Helper.assert(from_index <= source_string.length)
+                end
+                res = source_string.index(find, from_index)
+                environment.set_variable(result_var, res)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/string/LastIndexOf.rb

@@ -0,0 +1,29 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class LastIndexOf
+            def get_identifier
+                return 'string.lastIndexOf'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert((parameters.length === 3 || parameters.length === 4) &&
+                               Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source_string = Helper.resolve(environment, parameters[1])
+
+                Helper.assert(Helper.is_string(source_string))
+                find = Helper.resolve(environment, parameters[2])
+                from_index = source_string.length
+                if (parameters.length === 4)
+                    from_index = Helper.resolve(environment, parameters[3])
+                    Helper.assert(Helper.is_number(from_index))
+                    Helper.assert(from_index <= source_string.length)
+                end
+                res = source_string.rindex(find, from_index)
+                environment.set_variable(result_var, res)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/string/Split.rb

@@ -0,0 +1,29 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class Split
+            def get_identifier
+                'string.split'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert((parameters.length === 3 || parameters.length === 4) &&
+                               Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source_string = Helper.resolve(environment, parameters[1])
+
+                Helper.assert(Helper.is_string(source_string))
+                separator = Helper.resolve(environment, parameters[2])
+                Helper.assert(Helper.is_string(separator))
+                limit = 0
+                if (parameters.length === 4)
+                    limit = Helper.resolve(environment, parameters[3])
+                    Helper.assert(Helper.is_number(limit))
+                end
+                res = source_string.split(Regexp.new(separator))[0..limit - 1]
+                environment.set_variable(result_var, res)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/string/StringTransform.rb

@@ -0,0 +1,29 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class StringTransform
+            def initialize(identifier, transform)
+                @identifier = identifier
+                @transform = transform
+            end
+
+            def get_identifier
+                @identifier
+            end
+
+            def execute(environment, parameters)
+                Helper.assert(parameters.length === 2 &&
+                              Helper.is_var_address(parameters[0]))
+
+                result_var = parameters[0]
+                source_string = Helper.resolve(environment, parameters[1])
+                Helper.assert(Helper.is_string(source_string))
+
+                res = @transform.call(source_string)
+
+                environment.set_variable(result_var, res)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/string/Substr.rb

@@ -0,0 +1,30 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class Substr
+            def get_identifier
+                'string.substr'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert((parameters.length === 3 ||
+                               parameters.length === 4) &&
+                               Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source_string = Helper.resolve(environment, parameters[1])
+                Helper.assert(Helper.is_string(source_string))
+                start_idx = Helper.resolve(environment, parameters[2])
+                Helper.assert(Helper.is_number(start_idx))
+                length = source_string.length - start_idx
+                if (parameters.length === 4)
+                    length = Helper.resolve(environment, parameters[3])
+                    Helper.assert(Helper.is_number(length))
+                    Helper.assert(length + start_idx <= source_string.length)
+                end
+                res = source_string[start_idx..start_idx + length - 1]
+                environment.set_variable(result_var, res)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/commands/string/Substring.rb

@@ -0,0 +1,30 @@
+require_relative '../../../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class Substring
+            def get_identifier
+                'string.substring'
+            end
+
+            def execute(environment, parameters)
+                Helper.assert((parameters.length === 3) ||
+                              (parameters.length === 4) &&
+                              Helper.is_var_address(parameters[0]))
+                result_var = parameters[0]
+                source_string = Helper.resolve(environment, parameters[1])
+                Helper.assert(Helper.is_string(source_string))
+                start_idx = Helper.resolve(environment, parameters[2])
+                Helper.assert(Helper.is_number(start_idx))
+                end_idx = source_string.length
+                if (parameters.length === 4)
+                    end_idx = Helper.resolve(environment, parameters[3])
+                    Helper.assert(Helper.is_number(end_idx))
+                    Helper.assert(end_idx <= source_string.length)
+                end
+                res = source_string[start_idx..end_idx - 1]
+                environment.set_variable(result_var, res)
+            end
+        end
+    end
+end

data/lib/cloudrail_si/services/Facebook.rb

@@ -0,0 +1,528 @@
+require_relative '../servicecode/Interpreter'
+require_relative '../servicecode/Sandbox'
+require_relative '../errors/DetailErrors'
+require_relative '../servicecode/InitSelfTest'
+require_relative '../statistics/Statistics'
+
+module CloudRailSi
+  module Services
+    class Facebook
+
+      SERVICE_CODE = {
+        
+          "init" => [
+            [ "set", "$P0.boundary", "Amgrmg43ghg3g39glv0k2ldk"]
+            
+          ],
+        
+          "AdvancedRequestSupporter:advancedRequest" => [
+            [ "create", "$L0", "Object"],
+            [ "create", "$L0.url", "String"],
+            [ "if!=than", "$P2.appendBaseUrl", 0, 1],
+            [ "set", "$L0.url", "https://graph.facebook.com"],
+            [ "string.concat", "$L0.url", "$L0.url", "$P2.url"],
+            [ "set", "$L0.requestHeaders", "$P2.headers"],
+            [ "set", "$L0.method", "$P2.method"],
+            [ "set", "$L0.requestBody", "$P2.body"],
+            [ "if!=than", "$P2.appendAuthorization", 0, 2],
+            [ "callFunc", "checkAuthentication", "$P0"],
+            [ "string.concat", "$L0.requestHeaders.Authorization", "Bearer ", "$S0.accessToken"],
+            [ "http.requestCall", "$L1", "$L0"],
+            [ "if!=than", "$P2.checkErrors", 0, 1],
+            [ "callFunc", "validateResponse", "$P0", "$L1"],
+            [ "create", "$P1", "AdvancedRequestResponse"],
+            [ "set", "$P1.status", "$L1.code"],
+            [ "set", "$P1.headers", "$L1.responseHeaders"],
+            [ "set", "$P1.body", "$L1.responseBody"]
+            
+          ],
+        
+          "Social:postUpdate" => [
+            [ "if==than", "$P1", nil, 2],
+            [ "create", "$L0", "Error", "The content is not allowed to be null.", "IllegalArgument"],
+            [ "throwError", "$L0"],
+            [ "callFunc", "checkAuthentication", "$P0"],
+            [ "create", "$L3", "String"],
+            [ "string.urlEncode", "$L3", "$P1"],
+            [ "create", "$L0", "Object"],
+            [ "set", "$L0.method", "POST"],
+            [ "create", "$L1", "String"],
+            [ "string.concat", "$L1", "https://graph.facebook.com/v2.8/me/feed?message=", "$L3"],
+            [ "set", "$L0.url", "$L1"],
+            [ "create", "$L0.requestHeaders", "Object"],
+            [ "string.concat", "$L0.requestHeaders.Authorization", "Bearer ", "$S0.accessToken"],
+            [ "create", "$L2", "Object"],
+            [ "http.requestCall", "$L2", "$L0"],
+            [ "callFunc", "validateResponse", "$P0", "$L2"]
+            
+          ],
+        
+          "Social:postImage" => [
+            [ "if==than", "$P1", nil, 2],
+            [ "create", "$L0", "Error", "The message is not allowed to be null.", "IllegalArgument"],
+            [ "throwError", "$L0"],
+            [ "if==than", "$P2", nil, 2],
+            [ "create", "$L0", "Error", "The image is not allowed to be null.", "IllegalArgument"],
+            [ "throwError", "$L0"],
+            [ "callFunc", "checkAuthentication", "$P0"],
+            [ "create", "$L0", "Object"],
+            [ "set", "$L0.method", "POST"],
+            [ "set", "$L0.url", "https://graph.facebook.com/v2.8/me/photos"],
+            [ "create", "$L0.requestHeaders", "Object"],
+            [ "string.concat", "$L0.requestHeaders.Content-Type", "multipart/form-data; boundary=", "$P0.boundary"],
+            [ "string.concat", "$L0.requestHeaders.Authorization", "Bearer ", "$S0.accessToken"],
+            [ "string.concat", "$L1", "--", "$P0.boundary", "\r\n"],
+            [ "string.concat", "$L1", "$L1", "Content-Disposition: form-data; name=\"caption\"\r\n\r\n"],
+            [ "string.concat", "$L1", "$L1", "$P1", "\r\n"],
+            [ "string.concat", "$L1", "$L1", "--", "$P0.boundary", "\r\n"],
+            [ "string.concat", "$L1", "$L1", "Content-Disposition: form-data; name=\"source\"; filename=\"somename\"\r\n"],
+            [ "string.concat", "$L1", "$L1", "Content-Transfer-Encoding: binary\r\n\r\n"],
+            [ "stream.stringToStream", "$L1", "$L1"],
+            [ "string.concat", "$L2", "\r\n--", "$P0.boundary", "--"],
+            [ "stream.stringToStream", "$L2", "$L2"],
+            [ "stream.makeJoinedStream", "$L0.requestBody", "$L1", "$P2", "$L2"],
+            [ "http.requestCall", "$L4", "$L0"],
+            [ "callFunc", "validateResponse", "$P0", "$L4"]
+            
+          ],
+        
+          "Social:postVideo" => [
+            [ "if==than", "$P1", nil, 2],
+            [ "create", "$L0", "Error", "The message is not allowed to be null.", "IllegalArgument"],
+            [ "throwError", "$L0"],
+            [ "if==than", "$P2", nil, 2],
+            [ "create", "$L0", "Error", "The image is not allowed to be null.", "IllegalArgument"],
+            [ "throwError", "$L0"],
+            [ "callFunc", "checkAuthentication", "$P0"],
+            [ "create", "$L0", "Object"],
+            [ "set", "$L0.method", "POST"],
+            [ "set", "$L0.url", "https://graph-video.facebook.com/v2.8/me/videos"],
+            [ "string.indexOf", "$L20", "$P4", "/"],
+            [ "math.add", "$L20", "$L20", 1],
+            [ "string.substring", "$L21", "$P4", "$L20"],
+            [ "create", "$L0.requestHeaders", "Object"],
+            [ "string.concat", "$L0.requestHeaders.Content-Type", "multipart/form-data; boundary=", "$P0.boundary"],
+            [ "string.concat", "$L0.requestHeaders.Authorization", "Bearer ", "$S0.accessToken"],
+            [ "string.concat", "$L1", "--", "$P0.boundary", "\r\n"],
+            [ "string.concat", "$L1", "$L1", "Content-Disposition: form-data; name=\"description\"\r\n\r\n"],
+            [ "string.concat", "$L1", "$L1", "$P1", "\r\n"],
+            [ "string.concat", "$L1", "$L1", "--", "$P0.boundary", "\r\n"],
+            [ "string.concat", "$L1", "$L1", "Content-Disposition: form-data; name=\"source\"; filename=\"somename.", "$L21", "\"\r\n"],
+            [ "string.concat", "$L1", "$L1", "Content-Transfer-Encoding: binary\r\n\r\n"],
+            [ "stream.stringToStream", "$L1", "$L1"],
+            [ "string.concat", "$L2", "\r\n--", "$P0.boundary", "--"],
+            [ "stream.stringToStream", "$L2", "$L2"],
+            [ "stream.makeJoinedStream", "$L0.requestBody", "$L1", "$P2", "$L2"],
+            [ "http.requestCall", "$L4", "$L0"],
+            [ "callFunc", "validateResponse", "$P0", "$L4"]
+            
+          ],
+        
+          "Social:getConnections" => [
+            [ "callFunc", "checkAuthentication", "$P0"],
+            [ "create", "$L0", "Object"],
+            [ "set", "$L0.method", "GET"],
+            [ "create", "$L1", "String"],
+            [ "string.concat", "$L1", "https://graph.facebook.com/v2.8/me/friends"],
+            [ "set", "$L0.url", "$L1"],
+            [ "create", "$L0.requestHeaders", "Object"],
+            [ "string.concat", "$L0.requestHeaders.Authorization", "Bearer ", "$S0.accessToken"],
+            [ "create", "$L2", "Object"],
+            [ "http.requestCall", "$L2", "$L0"],
+            [ "callFunc", "validateResponse", "$P0", "$L2"],
+            [ "create", "$L3", "String"],
+            [ "stream.streamToString", "$L3", "$L2.responseBody"],
+            [ "json.parse", "$L4", "$L3"],
+            [ "create", "$L9", "Number"],
+            [ "size", "$L9", "$L4.data"],
+            [ "create", "$P1", "Array"],
+            [ "if!=than", "$L9", 0, 11],
+            [ "set", "$L5", "$L4.data.items"],
+            [ "create", "$L6", "Number"],
+            [ "size", "$L6", "$L5"],
+            [ "create", "$L7", "Number", 0],
+            [ "if<than", "$L7", "$L6", 6],
+            [ "create", "$L8", "Object"],
+            [ "get", "$L8", "$L5", "$L7"],
+            [ "string.concat", "$L9", "facebook-", "$L8.id"],
+            [ "push", "$P1", "$L9"],
+            [ "math.add", "$L7", "$L7", 1],
+            [ "jumpRel", -7]
+            
+          ],
+        
+          "Authenticating:login" => [
+            [ "callFunc", "checkAuthentication", "$P0"]
+            
+          ],
+        
+          "Authenticating:logout" => [
+            [ "set", "$P0.userInfo", nil],
+            [ "if!=than", "$S0.accessToken", nil, 10],
+            [ "create", "$L0", "Object"],
+            [ "set", "$L0.method", "DELETE"],
+            [ "create", "$L1", "String"],
+            [ "string.concat", "$L1", "https://graph.facebook.com/v2.8/me/permissions"],
+            [ "set", "$L0.url", "$L1"],
+            [ "create", "$L0.requestHeaders", "Object"],
+            [ "string.concat", "$L0.requestHeaders.Authorization", "Bearer ", "$S0.accessToken"],
+            [ "create", "$L2", "Object"],
+            [ "http.requestCall", "$L2", "$L0"],
+            [ "callFunc", "validateResponse", "$P0", "$L2"]
+            
+          ],
+        
+          "Profile:getIdentifier" => [
+            [ "callFunc", "checkUserInfo", "$P0"],
+            [ "string.concat", "$P1", "facebook-", "$P0.userInfo.id"]
+            
+          ],
+        
+          "Profile:getFullName" => [
+            [ "callFunc", "checkUserInfo", "$P0"],
+            [ "if!=than", "$P0.userInfo.name", nil, 1],
+            [ "set", "$P1", "$P0.userInfo.name"]
+            
+          ],
+        
+          "Profile:getEmail" => [
+            [ "callFunc", "checkUserInfo", "$P0"],
+            [ "if!=than", "$P0.userInfo.email", nil, 1],
+            [ "set", "$P1", "$P0.userInfo.email"]
+            
+          ],
+        
+          "Profile:getGender" => [
+            [ "callFunc", "checkUserInfo", "$P0"],
+            [ "if!=than", "$P0.userInfo.gender", nil, 7],
+            [ "if==than", "$P0.userInfo.gender", "male", 2],
+            [ "set", "$P1", "$P0.userInfo.gender"],
+            [ "return"],
+            [ "if==than", "$P0.userInfo.gender", "female", 2],
+            [ "set", "$P1", "$P0.userInfo.gender"],
+            [ "return"],
+            [ "set", "$P1", "other"]
+            
+          ],
+        
+          "Profile:getDescription" => [
+            [ "callFunc", "checkUserInfo", "$P0"],
+            [ "if!=than", "$P0.userInfo.about", nil, 1],
+            [ "set", "$P1", "$P0.userInfo.about"]
+            
+          ],
+        
+          "Profile:getDateOfBirth" => [
+            [ "callFunc", "checkUserInfo", "$P0"],
+            [ "create", "$P1", "DateOfBirth"],
+            [ "if!=than", "$P0.userInfo.birthday", nil, 10],
+            [ "string.split", "$L0", "$P0.userInfo.birthday", "/"],
+            [ "get", "$L1", "$L0", 0],
+            [ "if!=than", "$L1", "00", 1],
+            [ "math.add", "$P1.month", "$L1", 0],
+            [ "get", "$L1", "$L0", 1],
+            [ "if!=than", "$L1", "00", 1],
+            [ "math.add", "$P1.day", "$L1", 0],
+            [ "get", "$L1", "$L0", 2],
+            [ "if!=than", "$L1", "0000", 1],
+            [ "math.add", "$P1.year", "$L1", 0]
+            
+          ],
+        
+          "Profile:getLocale" => [
+            [ "callFunc", "checkUserInfo", "$P0"],
+            [ "if!=than", "$P0.userInfo.locale", nil, 3],
+            [ "create", "$L1", "String"],
+            [ "string.substring", "$L1", "$P0.userInfo.locale", 0, 2],
+            [ "set", "$P1", "$L1"]
+            
+          ],
+        
+          "Profile:getPictureURL" => [
+            [ "callFunc", "checkUserInfo", "$P0"],
+            [ "if!=than", "$P0.userInfo.picture.data.url", nil, 1],
+            [ "set", "$P1", "$P0.userInfo.picture.data.url"]
+            
+          ],
+        
+          "checkUserInfo" => [
+            [ "create", "$L0", "Date"],
+            [ "if!=than", "$P0.userInfo", nil, 2],
+            [ "if>than", "$P0.expirationTime", "$L0", 1],
+            [ "return"],
+            [ "callFunc", "checkAuthentication", "$P0"],
+            [ "create", "$L2", "Object"],
+            [ "set", "$L2.url", "https://graph.facebook.com/v2.8/me?fields=locale,gender,name,birthday,email,about"],
+            [ "create", "$L2.requestHeaders", "Object"],
+            [ "string.concat", "$L2.requestHeaders.Authorization", "Bearer ", "$S0.accessToken"],
+            [ "set", "$L2.method", "GET"],
+            [ "http.requestCall", "$L3", "$L2"],
+            [ "callFunc", "validateResponse", "$P0", "$L3"],
+            [ "json.parse", "$P0.userInfo", "$L3.responseBody"],
+            [ "create", "$L2", "Object"],
+            [ "set", "$L2.url", "https://graph.facebook.com/v2.8/me/picture?fields=url&type=large&redirect=false"],
+            [ "create", "$L2.requestHeaders", "Object"],
+            [ "string.concat", "$L2.requestHeaders.Authorization", "Bearer ", "$S0.accessToken"],
+            [ "set", "$L2.method", "GET"],
+            [ "http.requestCall", "$L3", "$L2"],
+            [ "callFunc", "validateResponse", "$P0", "$L3"],
+            [ "json.parse", "$L4", "$L3.responseBody"],
+            [ "set", "$P0.userInfo.picture", "$L4"],
+            [ "create", "$P0.expirationTime", "Date"],
+            [ "math.add", "$P0.expirationTime.time", "$P0.expirationTime.time", 60000]
+            
+          ],
+        
+          "checkAuthentication" => [
+            [ "create", "$L0", "Date"],
+            [ "if==than", "$S0.accessToken", nil, 2],
+            [ "callFunc", "authenticate", "$P0"],
+            [ "return"],
+            [ "create", "$L1", "Date"],
+            [ "set", "$L1.time", "$S0.expireIn"],
+            [ "if<than", "$L1", "$L0", 1],
+            [ "callFunc", "authenticate", "$P0"]
+            
+          ],
+        
+          "authenticate" => [
+            [ "create", "$L0", "String"],
+            [ "create", "$L1", "String"],
+            [ "string.urlEncode", "$L3", "$P0.redirectUri"],
+            [ "string.concat", "$L0", "https://www.facebook.com/dialog/oauth?response_type=code&client_id=", "$P0.clientID", "&redirect_uri=", "$L3", "&state=", "$P0.state", "&scope=public_profile%2Cemail%2Cuser_birthday%2Cuser_about_me%2Cpublish_actions%2Cuser_friends%2Cuser_photos"],
+            [ "awaitCodeRedirect", "$L2", "$L0"],
+            [ "string.concat", "$L1", "https://graph.facebook.com/v2.8/oauth/access_token?client_id=", "$P0.clientID", "&redirect_uri=", "$L3", "&client_secret=", "$P0.clientSecret", "&code=", "$L2"],
+            [ "create", "$L5", "Object"],
+            [ "set", "$L5.url", "$L1"],
+            [ "set", "$L5.method", "GET"],
+            [ "http.requestCall", "$L6", "$L5"],
+            [ "callFunc", "validateResponse", "$P0", "$L6"],
+            [ "stream.streamToString", "$L7", "$L6.responseBody"],
+            [ "json.parse", "$L8", "$L7"],
+            [ "set", "$S0.accessToken", "$L8.access_token"],
+            [ "create", "$L0", "Object"],
+            [ "set", "$L0.method", "GET"],
+            [ "string.concat", "$L0.url", "https://graph.facebook.com/v2.8/oauth/access_token?client_id=", "$P0.clientID", "&client_secret=", "$P0.clientSecret", "&grant_type=fb_exchange_token&fb_exchange_token=", "$S0.accessToken"],
+            [ "http.requestCall", "$L1", "$L0"],
+            [ "callFunc", "validateResponse", "$P0", "$L1"],
+            [ "json.parse", "$L2", "$L1.responseBody"],
+            [ "set", "$S0.accessToken", "$L2.access_token"],
+            [ "create", "$L10", "Date"],
+            [ "math.multiply", "$L9", 60, 24, 60, 60, 1000],
+            [ "math.add", "$L9", "$L9", "$L10.time", -60000],
+            [ "set", "$S0.expireIn", "$L9"]
+            
+          ],
+        
+          "validateResponse" => [
+            [ "if>=than", "$P1.code", 400, 3],
+            [ "stream.streamToString", "$L2", "$P1.responseBody"],
+            [ "create", "$L3", "Error", "$L2", "Http"],
+            [ "throwError", "$L3"]
+            
+          ]
+        
+      }
+
+      def initialize(redirect_receiver, client_id, client_secret, redirect_uri, state)
+          @interpreter_storage = {}
+          @persistent_storage = [{}]
+          @instance_dependency_storage = {
+              redirect_receiver: redirect_receiver
+          }
+
+          ServiceCode::InitSelfTest.init_test('Facebook')
+
+          @interpreter_storage['clientID'] = client_id
+          @interpreter_storage['clientSecret'] = client_secret
+          @interpreter_storage['redirectUri'] = redirect_uri
+          @interpreter_storage['state'] = state
+          
+
+          
+
+          # call init servicecode function
+          ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+          # check and call the initialization function if is available
+
+          ip.call_function_sync('init', @interpreter_storage) if (SERVICE_CODE['init'])
+      end
+
+      def check_for_error(error)
+        if (error)
+          ServiceCode::Statistics.add_error('Facebook', '')
+          case (error.type)
+          when 'IllegalArgument'
+            raise Errors::IllegalArgumentError.new(error.message)
+          when 'Authentication'
+            raise Errors::AuthenticationError.new(error.message)
+          when 'NotFound'
+            raise Errors::NotFoundError.new(error.message)
+          when 'Http'
+            raise Errors::HttpError.new(error.message)
+          when 'ServiceUnavailable'
+            raise Errors::ServiceUnavailableError.new(error.message)
+          else
+            raise Errors::StandardError.new(error.message)
+          end
+        end
+      end
+
+      
+      def get_identifier()
+        ServiceCode::Statistics.add_call('Facebook', 'get_identifier')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Profile:getIdentifier', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def get_full_name()
+        ServiceCode::Statistics.add_call('Facebook', 'get_full_name')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Profile:getFullName', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def get_email()
+        ServiceCode::Statistics.add_call('Facebook', 'get_email')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Profile:getEmail', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def get_gender()
+        ServiceCode::Statistics.add_call('Facebook', 'get_gender')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Profile:getGender', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def get_description()
+        ServiceCode::Statistics.add_call('Facebook', 'get_description')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Profile:getDescription', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def get_date_of_birth()
+        ServiceCode::Statistics.add_call('Facebook', 'get_date_of_birth')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Profile:getDateOfBirth', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def get_locale()
+        ServiceCode::Statistics.add_call('Facebook', 'get_locale')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Profile:getLocale', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def get_picture_url()
+        ServiceCode::Statistics.add_call('Facebook', 'get_picture_url')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Profile:getPictureURL', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def login()
+        ServiceCode::Statistics.add_call('Facebook', 'login')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Authenticating:login', @interpreter_storage)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil
+      end
+      
+      def logout()
+        ServiceCode::Statistics.add_call('Facebook', 'logout')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Authenticating:logout', @interpreter_storage)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil
+      end
+      
+      def advanced_request(specification)
+        ServiceCode::Statistics.add_call('Facebook', 'advanced_request')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('AdvancedRequestSupporter:advancedRequest', @interpreter_storage, nil, specification)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+      def post_update(content)
+        ServiceCode::Statistics.add_call('Facebook', 'post_update')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Social:postUpdate', @interpreter_storage, content)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil
+      end
+      
+      def post_image(message, image)
+        ServiceCode::Statistics.add_call('Facebook', 'post_image')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Social:postImage', @interpreter_storage, message, image)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil
+      end
+      
+      def post_video(message, video, size, mime_type)
+        ServiceCode::Statistics.add_call('Facebook', 'post_video')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Social:postVideo', @interpreter_storage, message, video, size, mime_type)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil
+      end
+      
+      def get_connections()
+        ServiceCode::Statistics.add_call('Facebook', 'get_connections')
+        ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+        ip.call_function('Social:getConnections', @interpreter_storage, nil)
+
+        check_for_error(ip.sandbox.thrown_error)
+        return nil || ip.get_parameter(1)
+      end
+      
+
+    	def save_as_string
+    		ip = ServiceCode::Interpreter.new(ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage))
+    		return ip.save_as_string()
+    	end
+
+    	def load_as_string(saved_state)
+    		sandbox = ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage)
+    		ip = ServiceCode::Interpreter.new(sandbox)
+    		ip.load_as_string(saved_state)
+    		@persistent_storage = sandbox.persistent_storage
+    	end
+
+      def resume_login(execution_state, callback)
+        sandbox = ServiceCode::Sandbox.new(SERVICE_CODE, @persistent_storage, @instance_dependency_storage)
+        sandbox.load_state_from_string(execution_state)
+        ip = ServiceCode::Interpreter.new(sandbox)
+        ip.resume_function('Authenticating:login', @interpreter_storage, callback)
+      end
+    end
+  end
+end