wavelabs_client_api 0.3.5

data/lib/wavelabs_client_api/client/api/core/base_api.rb

@@ -0,0 +1,92 @@
+require 'httmultiparty'
+
+module WavelabsClientApi
+  module Client
+    module Api
+      module Core
+        class BaseApi
+
+           include HTTMultiParty
+           
+           #debug_output $stdout
+
+           headers 'Accept' => 'application/json', 'Content-Type' => 'application/json'
+           
+           def base_api_url(uri)
+           	 site_url + uri
+           end
+           	
+           def site_url
+             WavelabsClientApi.configuration.api_host_url	
+           end
+
+           def client_id
+             WavelabsClientApi.configuration.client_key 
+           end
+
+           def client_secret
+             WavelabsClientApi.configuration.client_secret
+           end
+
+           def self.check_connection?
+             begin 
+          	   res = self.get(WavelabsClientApi.configuration.api_host_url)
+          	   if res.code == 200
+          	   	true
+          	   end
+          	 rescue StandardError
+                false
+              end   	  	
+           end	
+
+           def send_request_with_token(method, url, access_token, body = nil, query = nil)
+           	
+           	 begin
+           	  self.class.send(method, url, :body => body, :query => query, :headers => {"Authorization" => "Bearer " + access_token})
+             rescue StandardError
+             end
+
+           end
+
+           def send_request(method, url, body = nil, query_params = nil)
+           	begin
+           	 self.class.send(method, url, :body => body.to_json, :query => query_params)
+            rescue StandardError
+            end
+
+           end 
+
+           def create_login_model(login_params)
+           	 WavelabsClientApi::Client::Api::DataModels::LoginApiModel.new(login_params)
+           end
+
+           def create_member_model(json_response, except_token)
+             WavelabsClientApi::Client::Api::DataModels::MemberApiModel.new(json_response, except_token)
+           end
+
+           def create_token_model(json_response)
+             WavelabsClientApi::Client::Api::DataModels::TokenApiModel.new(json_response)
+           end 
+
+           def create_media_model(json_response)
+             WavelabsClientApi::Client::Api::DataModels::MediaApiModel.new(json_response)	
+           end
+
+           def create_message_model(json_response)	
+             WavelabsClientApi::Client::Api::DataModels::MessageApiModel.new(json_response)	
+           end
+
+           def create_social_model(json_response)  
+             WavelabsClientApi::Client::Api::DataModels::SocialAccountsApiModel.new(json_response) 
+           end
+
+           def create_token_details_model(json_response)
+             WavelabsClientApi::Client::Api::DataModels::TokenDetailsApiModel.new(json_response)
+           end 
+        end
+      end
+    end
+  end
+end
+
+

data/lib/wavelabs_client_api/client/api/core/media_api.rb

@@ -0,0 +1,48 @@
+# This class is responsible for handling
+# Requests from Com::Nbos::Core::MediaController.
+# It will create the request based on Controller request params and 
+# send that request to Wavelabs API server and return the response back.
+# While sending respose back to receiver it will create the virtual models
+# from Com::Nbos::Api::DataModels
+
+class WavelabsClientApi::Client::Api::Core::MediaApi < WavelabsClientApi::Client::Api::Core::BaseApi
+
+ MEDIA_URI = "/api/media/v0/media"
+
+ def get_media(user_id, media_for, access_token)
+   url_path = base_api_url(MEDIA_URI)
+   query_params = { :id => user_id, :mediafor => media_for}
+   api_response = send_request_with_token("get", url_path, access_token, nil, query_params)
+   
+   build_media_response(api_response)	
+ end
+
+
+ def upload_media(file_path, media_for, access_token, user_id)
+ 	 url_path = base_api_url(MEDIA_URI)
+   query_params = { :id => user_id,
+                    :mediafor => media_for
+                  }
+
+   body = {:file => File.new(file_path)}
+
+   api_response = send_request_with_token("post", url_path, access_token, body, query_params)
+   File.delete(file_path) if !file_path.include?("/spec/support/")
+   build_media_response(api_response) 	
+ end
+
+ def build_media_response(api_response)
+  begin
+     if api_response.code == 200
+       media_model = create_media_model(api_response.parsed_response)
+       {status: 200, media: media_model}
+     end
+   rescue StandardError
+     message_model = create_message_model(nil)
+     message_model.message = "Internal Server Error Please Try After Some Time."
+     { status: 500, message: message_model}
+   end   
+ end 
+
+
+end	

data/lib/wavelabs_client_api/client/api/core/social_api.rb

@@ -0,0 +1,78 @@
+# This class is responsible for handling
+# Requests from Com::Nbos::Core::SocialController.
+# It will create the request based on Controller request params and 
+# send that request to Wavelabs API server and return the response back.
+# While sending respose back to receiver it will create the virtual models
+# from Com::Nbos::Api::DataModels
+
+class WavelabsClientApi::Client::Api::Core::SocialApi < WavelabsClientApi::Client::Api::Core::BaseApi
+
+ # Api Server Social Authentication End Point URIs
+ FACEBOOK_LOGIN_URI = "/api/identity/v0/auth/social/facebook/connect"
+ GOOGLE_LOGIN_URI = "/api/identity/v0/auth/social/googlePlus/connect"
+ TWITER_LOGIN_URI = "/api/identity/v0/auth/social/twitter/connect"
+ GITHUB_LOGIN_URI = "/api/identity/v0/auth/social/gitHub/connect"
+ LINKEDIN_LOGIN_URI = "/api/identity/v0/auth/social/linkedIn/connect"
+ INSTAGRAM_LOGIN_URI = "/api/identity/v0/auth/social/instagram/connect"
+ INVALID_SOCIAL_URI  = "/api/identity/v0/auth/social/invalid/connect"
+
+ 
+
+def login(social_params, provider, access_token)
+  social_uri = get_scoial_login_uri(provider)
+  url_path = base_api_url(social_uri)
+
+   connection_options = { :clientId => client_id, 
+                          :accessToken => social_params[:credentials][:token], 
+                          :expiresIn => "#{social_params[:credentials][:expires_at]}"
+                        }
+   api_response = send_request_with_token('post', url_path, access_token, connection_options.to_json)
+   
+
+   if api_response.parsed_response["message"].present?
+     social_member_model = create_member_model(nil, true)
+     social_member_model.add_messages(api_response.parsed_response)
+   else
+     social_member_model = create_member_model(api_response.parsed_response, false)
+   end  
+  
+   begin
+     if api_response.code == 200
+        { status: 200, login: social_member_model}
+     elsif api_response.code == 400
+        social_member_model.add_errors(api_response.parsed_response)
+        { status: 400, login: social_member_model}
+     else
+        social_member_model.add_messages(api_response.parsed_response)
+        { status: api_response.code, login: social_member_model}  
+     end
+   rescue StandardError
+     social_member_model.message = "Internal Server Error Please Try After Some Time."
+     { status: 500, login: social_member_model}
+   end
+
+end
+
+
+# Method to return end point URI for specific social login
+def get_scoial_login_uri(provider)
+  case provider
+  when "facebook"
+    FACEBOOK_LOGIN_URI
+  when "google_oauth2"
+    GOOGLE_LOGIN_URI
+  when "twitter"    
+    TWITER_LOGIN_URI
+  when "github"
+    GITHUB_LOGIN_URI
+  when "linkedin"
+    LINKEDIN_LOGIN_URI
+  when "instagram"
+    INSTAGRAM_LOGIN_URI
+  else
+    INVALID_SOCIAL_URI  
+  end 
+end  
+
+
+end	

data/lib/wavelabs_client_api/client/api/core/users_api.rb

@@ -0,0 +1,90 @@
+# This class is responsible for handling
+# Requests from Com::Nbos::Core::UsersController.
+# It will create the request based on Controller request params and 
+# send that request to Wavelabs API server and return the response back.
+# While sending respose back to receiver it will create the virtual models
+# from Com::Nbos::Api::DataModels
+
+class WavelabsClientApi::Client::Api::Core::UsersApi < WavelabsClientApi::Client::Api::Core::BaseApi
+
+  SIGNUP_URI = "/api/identity/v0/users/signup"
+  USER_URI = "/api/identity/v0/users"
+  
+ def sign_up(sign_up_params, access_token)
+ 	 url_path = base_api_url(SIGNUP_URI)
+ 	 connection_options = { :clientId  =>  client_id,
+                          :username  =>  sign_up_params[:username],
+                          :password  =>  sign_up_params[:password],
+                          :email     =>  sign_up_params[:email],
+                          :firstName =>  sign_up_params[:firstName],
+                          :lastName  =>  sign_up_params[:lastName]
+                        }                  
+   api_response = send_request_with_token('post', url_path, access_token, connection_options.to_json)
+   
+   new_member_model =  create_login_model(sign_up_params)
+   
+   begin
+     if api_response.code == 200
+       member_api_model = create_member_model(api_response.parsed_response, false)
+       {status: 200, member: member_api_model}
+     elsif api_response.code == 400
+       new_member_model.add_errors(api_response.parsed_response)
+       {status: api_response.code, member: new_member_model}
+     else
+       new_member_model.add_messages(api_response.parsed_response)
+       {status: api_response.code, member: new_member_model}  
+     end
+   rescue StandardError
+     new_member_model.message = "Internal Server Error Please Try After Some Time."
+     { status: 500, member: new_member_model}
+   end  
+
+ end
+
+ def show(user_params, access_token)
+ 	 url_path = base_api_url(USER_URI + "/#{user_params[:id]}")
+ 	 api_response = send_request_with_token('get', url_path, access_token)
+   begin
+     if api_response.code == 200
+       normalized_res = {"member" => api_response.parsed_response}
+       {status: 200, member: create_member_model(normalized_res, true)}
+     else
+       login_model = create_login_model(nil)
+       login_model.add_messages(api_response.parsed_response)
+       { status: api_response.code, member: login_model}  
+     end
+   rescue StandardError
+     login_model = create_login_model(nil)
+     login_model.message = "Internal Server Error Please Try After Some Time."
+     { status: 500, member: login_model}
+   end   
+ end
+
+ def update(user_params, access_token)
+ 	 url_path = base_api_url(USER_URI + "/#{user_params[:id]}")
+ 	 connection_options = { 
+                          :email     =>  user_params[:email],
+                          :firstName =>  user_params[:firstName],
+                          :lastName  =>  user_params[:lastName],
+                          :description => user_params[:description],
+                          :phone => user_params[:phone]
+                        }
+   api_response = send_request_with_token('put', url_path, access_token, connection_options.to_json)
+    
+   begin 
+     if api_response.code == 200
+       normalized_res = {"member" => api_response.parsed_response}
+       {status: 200, member: create_member_model(normalized_res, true)}
+     elsif api_response.code == 400
+       member_model = create_member_model({"member" => user_params}, true)
+       member_model.add_errors(api_response.parsed_response)
+       {status: 400, member: member_model}
+     end
+   rescue StandardError
+     member_model = create_member_model(nil, true)
+     member_model.message = "Internal Server Error Please Try After Some Time."
+     { status: 500, member: member_model}
+   end                           
+ end	
+
+end	

data/lib/wavelabs_client_api/client/api/data_models/base_api_model.rb

@@ -0,0 +1,40 @@
+module WavelabsClientApi
+  module Client
+    module Api
+      module DataModels
+				class BaseApiModel
+
+					include ActiveModel::Validations
+					include ActiveModel::Conversion
+					extend ActiveModel::Naming
+
+					def create_login_model(login_params)
+						  WavelabsClientApi::Client::Api::DataModels::LoginApiModel.new(login_params)
+					end
+
+					def create_member_model(json_response, except_token)
+					  WavelabsClientApi::Client::Api::DataModels::MemberApiModel.new(json_response, except_token)
+					end
+
+					def create_token_model(json_response)
+					  WavelabsClientApi::Client::Api::DataModels::TokenApiModel.new(json_response)
+					end 
+
+					def create_media_model(json_response)
+					  WavelabsClientApi::Client::Api::DataModels::MediaApiModel.new(json_response)	
+					end
+
+					def create_message_model(json_response)	
+					  WavelabsClientApi::Client::Api::DataModels::MessageApiModel.new(json_response)	
+					end
+
+					def create_social_model(json_response)  
+					  WavelabsClientApi::Client::Api::DataModels::SocialAccountsApiModel.new(json_response) 
+					end
+
+				end 
+
+      end
+    end
+  end
+end

data/lib/wavelabs_client_api/client/api/data_models/login_api_model.rb

@@ -0,0 +1,41 @@
+# This class is a virtual Model for LoginApiModel.
+# It have required attributes to create the LoginApiModel object.
+# And also it included the Rails ActiveModel::Validations to 
+# add errors which will populate on views. Based on the response from
+# Wavelabs API server 'add_errors' or 'add_messages' methods add appropriate
+# messages to LoginApi model object.
+
+class WavelabsClientApi::Client::Api::DataModels::LoginApiModel < WavelabsClientApi::Client::Api::DataModels::BaseApiModel
+
+  attr_accessor :username, :password, :email, :firstName, :lastName, :phone, :newPassword, :message
+
+  def initialize(login_params = nil)
+    if login_params.present?
+      @username = login_params["username"]
+      @password = login_params["password"]
+      @email = login_params["email"]
+      @firstName = login_params["firstName"]
+      @lastName = login_params["lastName"]
+      @phone = login_params["phone"]
+      @newPassword = login_params["newPassword"]
+    end  
+  end
+
+  def add_errors(json_response)
+    json_response["errors"].each do |e| 
+      property_name = e['propertyName']
+      msg = e['message'] 	
+      self.errors[property_name] << msg
+    end 	
+  end
+
+  def add_messages(json_response)
+    if json_response["message"].present?
+      @message = json_response["message"]
+    elsif json_response["error"].present?
+      @message = json_response["error"]
+    end  
+          
+  end	
+
+end

data/lib/wavelabs_client_api/client/api/data_models/media_api_model.rb

@@ -0,0 +1,26 @@
+# This class is a virtual Model for MediaApi model.
+# It have required attributes to create the MediaApi model.
+# And also it included the Rails ActiveModel::Validations to 
+# add errors which will populate on views. Based on the response from
+# Wavelabs API server aading appropriate
+# message to MediaApi model object w hile initialize.
+
+
+# To-Do
+# Right now we are getting 200 status code for invalid file formates
+# Need to Cahnge the logic based on API server.
+class WavelabsClientApi::Client::Api::DataModels::MediaApiModel < WavelabsClientApi::Client::Api::DataModels::BaseApiModel
+
+  attr_accessor :extension, :mediaFileDetailsList, :supportedsizes, :newMedia, :message
+
+  def initialize(media_params = nil)
+  	if media_params.present? && media_params["extension"].present?
+	  	@extension = media_params["extension"]
+	  	@mediaFileDetailsList = media_params["mediaFileDetailsList"]
+	  	@supportedsizes = media_params["supportedsizes"]
+	  elsif media_params.present? && media_params["message"].present?
+	    @message = media_params["message"]	
+	  end	
+  end
+
+end	

data/lib/wavelabs_client_api/client/api/data_models/member_api_model.rb

@@ -0,0 +1,55 @@
+# This class is a virtual Model for MemberApi model.
+# It have required attributes to create the MemberApi model.
+# It will create associated TokenApi & SocialAccountsApi model objects based on Response. 
+# And also it included the Rails ActiveModel::Validations to 
+# add errors which will populate on views. Based on the response from
+# Wavelabs API server 'add_errors' or 'add_messages' methods add appropriate
+# messages to MemberAPi model object.
+
+class WavelabsClientApi::Client::Api::DataModels::MemberApiModel < WavelabsClientApi::Client::Api::DataModels::BaseApiModel
+
+  attr_accessor :id, :uuid, :username, :description, :email, :firstName, :lastName, :phone, :social_accounts, :token, :message
+
+  def initialize(option_params, except_token = false)
+    if option_params.present?
+      @id =  option_params["member"]["id"]
+      @uuid = option_params["member"]["uuid"]
+      @description = option_params["member"]["description"]
+      @email = option_params["member"]["email"]
+      @firstName = option_params["member"]["firstName"]
+      @lastName = option_params["member"]["lastName"]
+      @phone = option_params["member"]["phone"]
+      build_associated_models(option_params["token"], option_params["member"]["socialAccounts"], except_token)
+    end
+  end
+
+  def build_associated_models(token_params, social_params, except_token)
+    @token = create_token_model(token_params) if !except_token
+    @social_accounts = []
+    if social_params.presence && social_params.size > 0
+      social_params.each do |sp|
+        @social_accounts << create_social_model(sp)
+      end
+    else
+      @social_accounts << create_social_model(nil)
+    end  
+ 
+  end 
+
+  def add_errors(json_response)
+    json_response["errors"].each do |e| 
+      property_name = e['propertyName']
+      msg = e['message']  
+      self.errors[property_name] << msg
+    end 
+  end
+
+  def add_messages(json_response)
+    if json_response["message"].present?
+      @message = json_response["message"]
+    elsif json_response["error"].present?
+      @message = json_response["error"]
+    end        
+  end  
+
+end