mutx 0.1.69 → 0.2.0

data/lib/mutx/routes/admin_routes.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Mutx
+  module Routes
+    module Admin
+      class Routes < App
+        define do
+          with_authentication do
+            on('tasks') { run Tasks::Routes }
+            on('custom-params') { run CustomParams::Routes }
+            on('repositories') { run Repositories::Routes }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutx/routes/admin_routes/custom_params_routes.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+module Mutx
+  module Routes
+    module Admin
+      module CustomParams
+        class Routes < App
+          define do
+
+            on get do
+
+              on root do
+                custom_params = Mutx::API::CustomParams.list
+                res.write view('Admin Custom Params', custom_params: custom_params)
+              end
+
+              on 'new' do
+                res.write view('Admin Custom Params New')
+              end
+
+              on ':custom_param_id/edit' do |custom_param_id|
+                unless Mutx::Tasks::Custom::Params.exist? custom_param_id
+                  flash[:error] = 'Could not find Custom Parameter'
+                  res.redirect path_for(:admin_custom_params_index)
+                end
+                custom_param = Mutx::Tasks::Custom::Param.get(custom_param_id).structure
+                res.write view('Admin Custom Params Edit', custom_param: custom_param)
+              end
+
+              on ':custom_param_id/delete' do |custom_param_id|
+                custom_param = Mutx::Tasks::Custom::Param.get(custom_param_id).structure
+                res.write view('Admin Custom Params Delete', custom_param: custom_param)
+              end
+            end
+
+            on post do
+
+              # TO CREATE CUSTOM PARAM
+              on root do
+                Mutx::Support::Log.debug "data is => #{post_data}"
+                response = Mutx::API::CustomParams.set post_data # Creates or update
+                # Si success es true
+                Mutx::Support::Log.debug "#{response}"
+                unless response[:success]
+                  flash[:error] = response[:message]
+                  res.redirect path_for(:admin_custom_params_new,
+                                        query_string: {
+                                          name: post_data['name'],
+                                          action: post_data['action'],
+                                          type: post_data['type'],
+                                          value: post_data['value'],
+                                          options: post_data['options'],
+                                          required: post_data['required'],
+                                          clean: false
+                                        })
+                else
+                  flash[:success] = response[:message]
+                  res.redirect path_for(:admin_custom_params_index)
+                end
+              end
+
+               on ':custom_param_id/delete' do |custom_param_id|
+                response = Mutx::API::CustomParams.set post_data # Creates or update
+                flash[:info] = response[:message]
+                res.redirect path_for(:admin_custom_params_index)
+              end
+
+              # TO EDIT CUSTOM PARAM
+              on ':custom_param_id' do |custom_param_id|
+                Mutx::Support::Log.debug "data is => #{post_data}"
+                response = Mutx::API::CustomParams.set(post_data) # Creates or update
+                # Si success es true
+                Mutx::Support::Log.debug "#{response}"
+                unless response[:success]
+                  flash[:error] = response[:message]
+                  res.redirect path_for(:admin_custom_params_edit,
+                                        custom_param_id: custom_param_id,
+                                        query_string: {
+                                          name: post_data['name'],
+                                          action: post_data['action'],
+                                          type: post_data['type'],
+                                          value: post_data['value'],
+                                          options: post_data['options'],
+                                          required: post_data['required'],
+                                          clean: false
+                                        })
+                else
+                  flash[:success] = response[:message]
+                  res.redirect path_for(:admin_custom_params_index)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutx/routes/admin_routes/repositories_routes.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Mutx
+  module Routes
+    module Admin
+      module Repositories
+        class Routes < App
+          define do
+            on post do
+    
+              # TO CREATE A REPO
+              on root do
+                Mutx::Support::Log.debug "data is => #{post_data}" #only has a repo_name
+                response = Mutx::API::Repo.validate_and_create post_data # Creates a new 'repo'
+                # Si success es true
+                Mutx::Support::Log.debug "#{response}"
+                res.redirect path_for(:admin_repositories_index)
+              end
+            end
+
+            on get do
+              on "new" do
+                res.write view('Admin Repositories New', action: 'new')
+              end
+
+              on root do
+                repositories = Mutx::Database::MongoConnector.all_repos
+                res.write view('Admin Repositories', repositories: repositories)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutx/routes/admin_routes/tasks_routes.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+module Mutx
+  module Routes
+    module Admin
+      module Tasks
+        class Routes < App
+          
+          define do
+            on post do 
+              on root do
+                Mutx::Support::Log.debug "New Task - Recieved data => #{post_data}"
+                # Extracts custom params
+                custom_params = post_data.keys.select do |field|
+                  field.start_with? "custom_param_" and post_data.delete(field)
+                end.inject([]) do |res, value|
+                  res<<value.gsub("custom_param_",""); res
+                end
+                post_data["custom_params"] = custom_params
+                Mutx::Support::Log.debug "DATA SENT TO Task.set is => #{post_data}"
+                response = Mutx::API::Tasks.set post_data # Creates or update
+                Mutx::Support::Log.debug "response => []#{response}"
+                Mutx::Support::Log.debug "#{response}"
+                unless response[:success]
+                  flash[:error] = response[:message]
+                  res.redirect path_for(:admin_tasks_new, query_string: {
+                      name: post_data['name'],
+                      action: post_data['action'],
+                      type: post_data['type'],
+                      value: post_data['value'],
+                      options: post_data['options'],
+                      required: post_data['required'],
+                      clean: false
+                    })
+                else
+                  flash[:success] = response[:message]
+                  res.redirect path_for(:admin_tasks_index)
+                end
+              end
+
+              on ':task_id/delete' do |task_id|
+                Mutx::Support::Log.debug "DATA SENT TO Task.delete is => #{post_data}"
+                result = Mutx::Tasks.delete! task_id
+                flash[:info] = result[:message]
+                res.redirect path_for(:admin_tasks_index)
+              end
+
+              on ':task_id' do
+                Mutx::Support::Log.debug "Edit Task - Recieved data => #{post_data}"
+                # Extracts custom params
+                custom_params = post_data.keys.select do |field|
+                  field.start_with? "custom_param_" and post_data.delete(field)
+                end.inject([]) do |res, value|
+                  res<<value.gsub("custom_param_",""); res
+                end
+                post_data["custom_params"] = custom_params
+                Mutx::Support::Log.debug "DATA SENT TO Task.set is => #{post_data}"
+                response = Mutx::API::Tasks.set post_data # Creates or update
+                Mutx::Support::Log.debug "response => []#{response}"
+                Mutx::Support::Log.debug "#{response}"
+                unless response[:success]
+                  flash[:error] = response[:message]
+                  res.redirect path_for(:admin_tasks_edit, query_string: {
+                      name: post_data['name'],
+                      action: post_data['action'],
+                      type: post_data['type'],
+                      value: post_data['value'],
+                      options: post_data['options'],
+                      required: post_data['required'],
+                      clean: false
+                    })
+                else
+                  flash[:success] = response[:message]
+                  res.redirect path_for(:admin_tasks_index)
+                end
+              end
+
+            end
+
+            on get do
+              on root do
+                tasks = Mutx::API::Tasks.list["tasks"]
+                res.write view('Admin Tasks', tasks: tasks)
+              end
+
+              on 'new' do
+                res.write view('Admin Tasks New')
+              end
+
+              on ':task_id/edit' do |task_id|
+                task = Mutx::Tasks::Task.get(task_id).task_data_structure
+                res.write view('Admin Tasks Edit', task: task)
+              end
+
+              on ':task_id/delete' do |task_id|
+                task = Mutx::Tasks::Task.get(task_id).task_data_structure
+                res.write view('Admin Tasks Delete', task: task)
+              end
+
+              on ':task_id/view' do |task_id|
+                task = Mutx::Tasks::Task.get(task_id).task_data_structure
+                res.write view('Admin Task', task: task)
+              end
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutx/routes/api_routes.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Mutx
+  module Routes
+    module Api
+      class Routes < App
+        define do
+          begin
+            
+            on('input') { run Api::Input::Routes }
+            on('repositories') { run Api::Repositories::Routes }
+            on('results') { run Api::Results::Routes }
+            on('tasks') { run Api::Tasks::Routes }
+            on('tests') { run Api::Tasks::Routes }
+            on('custom/params') { run Api::CustomParams::Routes }
+
+            on get do
+              on "version" do
+                output = { "version" => Mutx::VERSION}
+                res.write output.to_json
+              end
+
+              on "error" do
+                query_string = Mutx::Support::QueryString.new req
+                output = Mutx::API::Error.show(query_string)
+                res.write output.to_json
+              end
+
+              on root do
+                response = {"message" => "Please, refer to /help/api for more information"}
+                res.write response.to_json
+              end
+
+            end
+
+          rescue => exception
+            Mutx::Support::Log.error "Cuba: #{exception} #{exception.backtrace}" if Mutx::Support::Log
+            error_title , error_msg = Mutx::Support::ErrorHandlerHelper.evaluate exception
+            response = { 
+                        error_title: error_title,
+                        error_msg: error_msg
+                      }.to_json
+            res.write response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutx/routes/api_routes/custom_params_routes.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Mutx
+  module Routes
+    module Api
+      module CustomParams
+        class Routes < App
+          define do
+            on get do
+
+              on ":name/value" do |name|
+                output = {}
+                param = Mutx::API::CustomParams.get(name)
+                output["app"] = Mutx::Support::Configuration.project_name
+                output["request"] = "Custom Parameter value"
+                output["custom_param_name"] = param["name"]
+                output["value"] = param["value"]
+                res.write output.to_json
+              end
+
+              on ":name" do |name|
+                output = {}
+                param = Mutx::API::CustomParams.get(name)
+                output["custom_param"] = param
+                output["app"] = Mutx::Support::Configuration.project_name
+                res.write output.to_json
+              end
+
+              on root do
+                output ={}
+                output["custom_params"] = Mutx::API::CustomParams.list()
+                output["request"]="Custom Params"
+                output["app"]=Mutx::Support::Configuration.project_name
+                res.write output.to_json
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutx/routes/api_routes/input_routes.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+module Mutx
+  module Routes
+    module Api
+      module Input
+        class Routes < App
+          define do
+            on post do
+
+              on ":id" do |id|
+                $result = basic_auth(env) do |user, pass|
+                 user == "inputs" && pass == "InputsAdmin"
+                end
+                if $result.eql? true
+                  Mutx::Support::Log.debug "REFERENCE IS => #{id}"
+                  data = req.params.dup
+                  data.store("reference", "#{id}")
+                  Mutx::Support::Log.debug "DATA TO INPUT IS => #{data}"
+                  response = Mutx::API::Input.validate_and_create data
+                  Mutx::Support::Log.debug "RESPONSE => #{response}"
+                  (res.status = 201
+                  res.write "status 201") if response.to_s.include? "success=>true"
+                  (res.status = 404
+                  res.write "status 404") if response.to_s.include? "success=>false"
+                  Mutx::Support::Log.debug "STATUS CODE => #{res.status}"
+                else
+                 on default do
+                   res.status = 401
+                   res.headers["WWW-Authenticate"] = 'Basic realm="MyApp"'
+                   res.write "status 401"
+                   res.write "Access Denied, Mutx don't let you POST without authorization"
+                 end
+                end
+              end
+            end
+
+            on get do
+              on ":id" do |id|
+                output = Mutx::API::Input.get_data(id, query_string.raw)        
+                res.write output.to_json
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutx/routes/api_routes/repos_routes.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+module Mutx
+  module Routes
+    module Api
+      module Repositories
+        class Routes < App
+          define do
+
+            on put do
+              # UPDATE A REPO!
+              on ":token/:name" do |token, name|
+                value = JSON.parse(req.body.read) #passed values in body as json
+                Mutx::Support::Log.debug "REPO NAME IS => #{name}"
+                data = req.params.dup
+                data.store("token", "#{token}")
+                data.store("name", "#{name}")
+                data.store("value", "#{value}")
+                Mutx::Support::Log.debug "DATA TO INPUT IS => #{data}"
+                response = Mutx::API::Repo.update! data
+                Mutx::Support::Log.debug "RESPONSE => #{response}"
+                (res.status = 200
+                 res.write "status 200") if response.to_s.include? "success=>true"
+                (res.status = 404
+                res.write "status 404") if response.to_s.include? "success=>false"
+                Mutx::Support::Log.debug "STATUS CODE => #{res.status}"
+              end
+
+              on ":repository_id" do |repository_id|
+                repository = Mutx::API::Repo.get_data(repository_id)
+                value = JSON.parse(req.body.read) #passed values in body as json
+                Mutx::Support::Log.debug "REPO NAME IS => #{repository['repo_name']}"
+                data = req.params.dup
+                data.store("token", headers['X_REPOSITORY_TOKEN'])
+                data.store("name", repository['repo_name'])
+                data.store("value", "#{value}")
+                Mutx::Support::Log.debug "DATA TO INPUT IS => #{data}"
+                response = Mutx::API::Repo.update! data
+                Mutx::Support::Log.debug "RESPONSE => #{response}"
+                (res.status = 200
+                 res.write "status 200") if response.to_s.include? "success=>true"
+                (res.status = 404
+                res.write "status 404") if response.to_s.include? "success=>false"
+                Mutx::Support::Log.debug "STATUS CODE => #{res.status}"
+              end
+
+            end
+
+
+
+            on get do
+              on ":repository_id" do |repository_id|
+                query_string = Mutx::Support::QueryString.new req
+                output = Mutx::API::Repo.get_data(repository_id, query_string.raw)     
+                (res.status = 200
+                 output.delete("repo_token")
+                 res.write output.to_json) if !output.to_s.include? "success=>false"
+                (res.status = 404
+                res.write "Not Found => status 404") if output.to_s.include? "success=>false"
+                Mutx::Support::Log.debug "STATUS CODE => #{res.status}"
+              end
+
+              on root do
+                query_string = Mutx::Support::QueryString.new req
+                output = Mutx::API::Repo.all
+                res.status = 200
+                res.write output.map { |item| item.delete("repo_token") && item }.to_json
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end