kalibro_entities 0.0.1.rc1

data/lib/kalibro_entities/entities/metric_configuration_snapshot.rb

@@ -0,0 +1,57 @@
+# This file is part of KalibroEntities
+# Copyright (C) 2013  it's respectives authors (please see the AUTHORS file)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "kalibro_entities/entities/model"
+
+module KalibroEntities
+  module Entities
+    class MetricConfigurationSnapshot < Model
+      attr_accessor :code, :weight, :aggregation_form, :metric, :base_tool_name, :range
+
+      def weight=(value)
+        @weight = value.to_f
+      end
+
+      def metric=(value)
+        if value.kind_of?(Hash)
+          @metric = KalibroEntities::Entities::Metric.to_object(value)
+        else
+          @metric = value
+        end
+      end
+
+      def range=(value)
+        value = [value] unless value.kind_of?(Array)
+        @range = []
+
+        value.each do |range_snapshot|
+          @range << KalibroEntities::Entities::RangeSnapshot.to_object(range_snapshot)
+        end
+      end
+
+      def range_snapshot
+        range
+      end
+
+      def to_hash
+        hash = super
+        hash[:attributes!][:range] = {'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:rangeSnapshotXml' }
+        hash
+      end
+    end
+  end
+end

data/lib/kalibro_entities/entities/metric_result.rb

@@ -0,0 +1,63 @@
+# This file is part of KalibroEntities
+# Copyright (C) 2013  it's respectives authors (please see the AUTHORS file)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "kalibro_entities/entities/model"
+
+module KalibroEntities
+  module Entities
+    class MetricResult < Model
+
+      attr_accessor :id, :configuration, :value, :aggregated_value
+
+      def id=(value)
+        @id = value.to_i
+      end
+
+      def configuration=(value)
+        @configuration = KalibroEntities::Entities::MetricConfigurationSnapshot.to_object value
+      end
+
+      def metric_configuration_snapshot
+        @configuration
+      end
+
+      def value=(value)
+        @value = value.to_f
+      end
+
+      def aggregated_value=(value)
+        @aggregated_value = value.to_i
+      end
+
+      def descendant_results
+        response = self.class.request(:descendant_results_of, {:metric_result_id => id})[:descendant_result]
+        response = [] if response.nil?
+        response = [response] if response.is_a?(String)
+        response.map {|descendant_result| descendant_result.to_f}
+      end
+
+      def self.metric_results_of(module_result_id)
+        create_objects_array_from_hash self.request(:metric_results_of, {:module_result_id => module_result_id})[:metric_result]
+      end
+
+      def self.history_of(metric_name, module_result_id)
+        response = self.request(:history_of_metric, {:metric_name => metric_name,
+                                                     :module_result_id => module_result_id})[:date_metric_result]
+        create_array_from_hash(response).map { |date_metric_result| KalibroEntities::Entities::DateMetricResult.new date_metric_result }
+      end
+    end
+  end
+end

data/lib/kalibro_entities/entities/model.rb

@@ -0,0 +1,162 @@
+# This file is part of KalibroEntities
+# Copyright (C) 2013  it's respectives authors (please see the AUTHORS file)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'savon'
+require 'kalibro_entities/helpers/hash_converters'
+require 'kalibro_entities/helpers/request_methods'
+
+module KalibroEntities
+  module Entities
+    class Model
+      attr_accessor :kalibro_errors
+
+      def initialize(attributes={})
+        attributes.each { |field, value| send("#{field}=", value) if self.class.is_valid?(field) }
+        @kalibro_errors = []
+      end
+
+      def to_hash(options={})
+        hash = Hash.new
+        excepts = options[:except].nil? ? [] : options[:except]
+        excepts << :kalibro_errors
+        fields.each do |field|
+          hash = field_to_hash(field).merge(hash) if !excepts.include?(field)
+        end
+        hash
+      end
+
+      def self.request(action, request_body = nil)
+        response = client(endpoint).call(action, message: request_body )
+        response.to_hash["#{action}_response".to_sym] # response is a Savon::SOAP::Response, and to_hash is a Savon::SOAP::Response method
+      end
+
+      def self.to_object value
+        value.kind_of?(Hash) ? new(value) : value
+      end
+
+      def self.to_objects_array value
+        array = value.kind_of?(Array) ? value : [value]
+        array.each.map { |element| to_object(element) }
+      end
+
+      def save
+        begin
+          self.id = self.class.request(save_action, save_params)["#{instance_class_name.underscore}_id".to_sym]
+          true
+        rescue Exception => exception
+          add_error exception
+          false
+        end
+      end
+
+      def save!
+        save
+      end
+
+      def self.create(attributes={})
+        new_model = new attributes
+        new_model.save
+        new_model
+      end
+
+      def ==(another)
+        unless self.class == another.class then
+          return false
+        end
+        self.variable_names.each {
+          |name|
+          unless self.send("#{name}") == another.send("#{name}") then
+            return false
+          end
+        }
+        true
+      end
+
+      def self.exists?(id)
+        request(exists_action, id_params(id))[:exists]
+      end
+
+      def self.find(id)
+        if(exists?(id))
+          new request(find_action, id_params(id))["#{class_name.underscore}".to_sym]
+        else
+          raise KalibroEntities::Errors::RecordNotFound
+        end
+      end
+
+      def destroy
+        begin
+          self.class.request(destroy_action, destroy_params)
+        rescue Exception => exception
+          add_error exception
+        end
+      end
+
+      def self.create_objects_array_from_hash (response)
+        create_array_from_hash(response).map { |hash| new hash }
+      end
+
+      def self.create_array_from_hash (response)
+        response = [] if response.nil?
+        response = [response] if response.is_a?(Hash)
+        response
+      end
+
+      protected
+
+      def instance_variable_names
+        instance_variables.map { |var| var.to_s }
+      end
+
+      def fields
+        instance_variable_names.each.collect { |variable| variable.to_s.sub(/@/, '').to_sym }
+      end
+
+      def variable_names
+        instance_variable_names.each.collect { |variable| variable.to_s.sub(/@/, '') }
+      end
+
+      def self.client(endpoint)
+        Savon.client({log: false, wsdl: "#{KalibroEntities.config[:address]}#{endpoint}Endpoint/?wsdl"})
+      end
+
+      def self.is_valid?(field)
+        field.to_s[0] != '@' and field != :attributes! and (field.to_s =~ /xsi/).nil?
+      end
+
+      def instance_class_name
+        self.class.name.gsub(/KalibroEntities::Entities::/,"")
+      end
+
+      include RequestMethods
+      extend RequestMethods::ClassMethods
+
+      def add_error(exception)
+        @kalibro_errors << exception
+      end
+
+      def self.endpoint
+        class_name
+      end
+
+      def self.class_name
+        self.name.gsub(/KalibroEntities::Entities::/,"")
+      end
+
+      include HashConverters
+    end
+  end
+end

data/lib/kalibro_entities/entities/module.rb

@@ -0,0 +1,27 @@
+# This file is part of KalibroEntities
+# Copyright (C) 2013  it's respectives authors (please see the AUTHORS file)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "kalibro_entities/entities/model"
+
+module KalibroEntities
+  module Entities
+		class Module < Model
+
+			attr_accessor :name, :granularity
+
+		end
+	end
+end

data/lib/kalibro_entities/entities/module_result.rb

@@ -0,0 +1,69 @@
+# This file is part of KalibroEntities
+# Copyright (C) 2013  it's respectives authors (please see the AUTHORS file)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "kalibro_entities/entities/model"
+
+module KalibroEntities
+  module Entities
+    class ModuleResult < Model
+
+      attr_accessor :id, :module, :grade, :parent_id, :height
+
+      def self.find(id)
+        begin
+          new request(:get_module_result, { :module_result_id => id })[:module_result]
+        rescue Savon::SOAPFault
+          raise KalibroEntities::Errors::RecordNotFound
+        end
+      end
+
+      def children
+        response = self.class.request(:children_of, {:module_result_id => id})[:module_result]
+        self.class.create_objects_array_from_hash(response)
+      end
+
+      def parents
+        if parent_id == 0
+          []
+        else
+          parent = self.class.find(parent_id)
+          parent.parents << parent
+        end
+      end
+
+      def id=(value)
+        @id = value.to_i
+      end
+
+      def module=(value)
+        @module = KalibroEntities::Entities::Module.to_object value
+      end
+
+      def grade=(value)
+        @grade = value.to_f
+      end
+
+      def parent_id=(value)
+        @parent_id = value.to_i
+      end
+
+      def self.history_of(module_result_id)
+        response = self.create_array_from_hash self.request(:history_of_module, {:module_result_id => module_result_id})[:date_module_result]
+        response.map {|date_module_result| KalibroEntities::Entities::DateModuleResult.new date_module_result}
+      end
+    end
+  end
+end

data/lib/kalibro_entities/entities/process_time.rb

@@ -0,0 +1,31 @@
+# This file is part of KalibroEntities
+# Copyright (C) 2013  it's respectives authors (please see the AUTHORS file)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "kalibro_entities/entities/model"
+
+module KalibroEntities
+  module Entities
+    class ProcessTime < Model
+      
+     attr_accessor :state, :time
+
+      def time=(time)
+        @time = time.to_i
+      end
+      
+    end
+  end
+end

data/lib/kalibro_entities/entities/processing.rb

@@ -0,0 +1,113 @@
+# This file is part of KalibroEntities
+# Copyright (C) 2013  it's respectives authors (please see the AUTHORS file)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "kalibro_entities/entities/model"
+
+module KalibroEntities
+  module Entities
+    class Processing < Model
+      
+      attr_accessor :id, :date, :state, :error, :process_time, :results_root_id
+
+      def id=(value)
+        @id = value.to_i
+      end
+
+      def date=(value)
+        @date = value.is_a?(String) ? DateTime.parse(value) : value
+      end
+
+      def process_times=(value)
+        @process_time = value
+      end
+
+      def process_time=(value)
+        @process_time = KalibroEntities::Entities::ProcessTime.to_objects_array value
+      end
+
+      def process_times
+        @process_time
+      end
+
+      def error=(value)
+        @error = KalibroEntities::Entities::Throwable.to_object value
+      end
+
+      def results_root_id=(value)
+        @results_root_id = value.to_i
+      end
+
+      def self.processing_of(repository_id)
+        if has_ready_processing(repository_id)
+          last_ready_processing_of(repository_id)
+        else
+          last_processing_of(repository_id)
+        end
+      end
+
+      def self.processing_with_date_of(repository_id, date)
+        date = date.is_a?(String) ? DateTime.parse(date) : date
+        if has_processing_after(repository_id, date)
+          first_processing_after(repository_id, date)
+        elsif has_processing_before(repository_id, date)
+          last_processing_before(repository_id, date)
+        else
+          nil
+        end
+      end
+
+      def self.has_processing(repository_id)
+        request(:has_processing, {:repository_id => repository_id})[:exists]
+      end
+
+      def self.has_ready_processing(repository_id)
+        request(:has_ready_processing, {:repository_id => repository_id})[:exists]
+      end
+
+      def self.has_processing_after(repository_id, date)
+        request(:has_processing_after, {:repository_id => repository_id, :date => date})[:exists]
+      end
+
+      def self.has_processing_before(repository_id, date)
+        request(:has_processing_before, {:repository_id => repository_id, :date => date})[:exists]
+      end
+
+      def self.last_processing_state_of(repository_id)
+        request(:last_processing_state, {:repository_id => repository_id})[:process_state]
+      end
+
+      def self.last_ready_processing_of(repository_id)
+        new request(:last_ready_processing, {:repository_id => repository_id})[:processing]
+      end
+
+      def self.first_processing_of(repository_id)
+        new request(:first_processing, {:repository_id => repository_id})[:processing]
+      end
+
+      def self.last_processing_of(repository_id)
+        new request(:last_processing, {:repository_id => repository_id})[:processing]
+      end
+
+      def self.first_processing_after(repository_id, date)
+        new request(:first_processing_after, {:repository_id => repository_id, :date => date})[:processing]
+      end
+
+      def self.last_processing_before(repository_id, date)
+        new request(:last_processing_before, {:repository_id => repository_id, :date => date})[:processing]
+      end
+    end
+  end
+end