atdis 0.2 → 0.3

data/lib/atdis/models/address.rb

@@ -0,0 +1,17 @@
+module ATDIS
+  module Models
+    class Address < Model
+      set_field_mappings ({
+        street: String,
+        suburb: String,
+        postcode: String,
+        state: String
+      })
+
+      # Mandatory parameters
+      validates :street, :suburb, :postcode, :state, presence_before_type_cast: {spec_section: "4.3.3"}
+
+      validates :postcode, format: { with: /\A[0-9]{4}\z/, message: ATDIS::ErrorMessage.new("is not a valid postcode", "4.3.3")}
+    end
+  end
+end

data/lib/atdis/models/application.rb

@@ -0,0 +1,31 @@
+require "atdis/models/info"
+require "atdis/models/reference"
+require "atdis/models/location"
+require "atdis/models/event"
+require "atdis/models/document"
+require "atdis/models/person"
+
+module ATDIS
+  module Models
+    class Application < Model
+      set_field_mappings ({
+        info:      Info,
+        reference: Reference,
+        locations: Location,
+        events:    Event,
+        documents: Document,
+        people:    Person,
+        extended:  Object,
+      })
+
+      # Mandatory attributes
+      validates :info, :reference, :locations, :events, :documents, presence_before_type_cast: {spec_section: "4.3"}
+
+      validates :people, array: {spec_section: "4.3"}
+      validates :locations, :events, :documents, filled_array: {spec_section: "4.3"}
+
+      # This model is only valid if the children are valid
+      validates :info, :reference, :locations, :events, :documents, :people, valid: true
+    end
+  end
+end

data/lib/atdis/models/authority.rb

@@ -0,0 +1,19 @@
+module ATDIS
+  module Models
+    class Authority < Model
+      set_field_mappings ({
+        ref:  URI,
+        name: String
+      })
+
+      # ref is a "Unique Authority Identifier" and should have the form http://www.council.nsw.gov.au/atdis/1.0
+      # It should also be consistent for each council.
+
+      # Mandatory attributes
+      validates :ref, :name, presence_before_type_cast: {spec_section: "4.3.1"}
+
+      validates :ref, http_url: {spec_section: "4.3.1"}
+      validates :ref, format: { with: /atdis\/1.0\z/, message: ATDIS::ErrorMessage.new("is not a valid Unique Authority Identifier", "4.3.1")}
+    end
+  end
+end

data/lib/atdis/models/document.rb

@@ -0,0 +1,16 @@
+module ATDIS
+  module Models
+    class Document < Model
+      set_field_mappings ({
+        ref:          String,
+        title:        String,
+        document_url: URI
+      })
+
+      # Mandatory parameters
+      validates :ref, :title, :document_url, presence_before_type_cast: {spec_section: "4.3.5"}
+      # Other validations
+      validates :document_url, http_url: {spec_section: "4.3.5"}
+    end
+  end
+end

data/lib/atdis/models/event.rb

@@ -0,0 +1,16 @@
+module ATDIS
+  module Models
+    class Event < Model
+      set_field_mappings ({
+        id:          String,
+        timestamp:   DateTime,
+        description: String,
+        event_type:  String,
+        status:      String
+      })
+
+      # Mandatory parameters
+      validates :id, :timestamp, :description, presence_before_type_cast: {spec_section: "4.3.4"}
+    end
+  end
+end

data/lib/atdis/models/info.rb

@@ -0,0 +1,81 @@
+require "atdis/models/authority"
+
+module ATDIS
+  module Models
+    class Info < Model
+      set_field_mappings ({
+        dat_id:                  String,
+        development_type:        String,
+        application_type:        String,
+        last_modified_date:      DateTime,
+        description:             String,
+        authority:               Authority,
+        lodgement_date:          DateTime,
+        determination_date:      DateTime,
+        determination_type:      String,
+        status:                  String,
+        notification_start_date: DateTime,
+        notification_end_date:   DateTime,
+        officer:                 String,
+        estimated_cost:          String,
+        related_apps:            URI
+      })
+
+      # Mandatory parameters
+      # determination_date is not in this list because even though it is mandatory
+      # it can be null if there is no value
+      validates :dat_id, :development_type, :last_modified_date, :description,
+        :authority, :lodgement_date, :status,
+        presence_before_type_cast: {spec_section: "4.3.1"}
+      # Other validations
+      validates :application_type, inclusion: { in: [
+        "DA", "CDC", "S96", "Review", "Appeal", "Other"
+        ],
+        message: ATDIS::ErrorMessage.new("does not have one of the allowed types", "4.3.1")}
+      validates :last_modified_date, :lodgement_date, :determination_date,
+        :notification_start_date, :notification_end_date,
+        date_time: {spec_section: "4.3.1"}
+      # We don't need to separately validate presence because this covers it
+      validates :determination_type, inclusion: { in: [
+        "Pending", "Refused by Council", "Refused under delegation", "Withdrawn",
+        "Approved by Council", "Approved under delegation", "Rejected"
+        ],
+        message: ATDIS::ErrorMessage.new("does not have one of the allowed types", "4.3.1")
+      }
+      validate :notification_dates_consistent!
+      validates :related_apps, array: {spec_section: "4.3.1"}
+      validates :related_apps, array_http_url: {spec_section: "4.3.1"}
+      validate :related_apps_url_format
+      validate :dat_id_is_url_encoded!
+
+      # This model is only valid if the children are valid
+      validates :authority, valid: true
+
+      # TODO Validate contents of estimated_cost
+
+      def dat_id_is_url_encoded!
+        if dat_id && CGI::escape(dat_id) != dat_id
+          errors.add(:dat_id, ErrorMessage.new("should be url encoded", "4.3.1"))
+        end
+      end
+
+      def related_apps_url_format
+        if related_apps.respond_to?(:all?) && !related_apps.all? {|url| url.to_s =~ /atdis\/1.0\/[^\/]+\.json/}
+          errors.add(:related_apps, ErrorMessage.new("contains url(s) not in the expected format", "4.3.1"))
+        end
+      end
+
+      def notification_dates_consistent!
+        if notification_start_date_before_type_cast && notification_end_date_before_type_cast.blank?
+          errors.add(:notification_end_date, ErrorMessage["can not be blank if notification_start_date is set", "4.3.1"])
+        end
+        if notification_start_date_before_type_cast.blank? && notification_end_date_before_type_cast
+          errors.add(:notification_start_date, ErrorMessage["can not be blank if notification_end_date is set", "4.3.1"])
+        end
+        if notification_start_date && notification_end_date && notification_start_date > notification_end_date
+          errors.add(:notification_end_date, ErrorMessage["can not be earlier than notification_start_date", "4.3.1"])
+        end
+      end
+    end
+  end
+end

data/lib/atdis/models/land_title_ref.rb

@@ -0,0 +1,26 @@
+require "atdis/models/torrens_title"
+
+module ATDIS
+  module Models
+    class LandTitleRef < Model
+      set_field_mappings ({
+        torrens: TorrensTitle,
+        other:   Hash
+      })
+
+      # This model is only valid if the children are valid
+      validates :torrens, valid: true
+
+      validate :check_title_presence
+
+      def check_title_presence
+        if torrens.nil? && other.nil?
+          errors.add(:torrens, ATDIS::ErrorMessage.new("or other needs be present", "4.3.3"))
+        end
+        if torrens && other
+          errors.add(:torrens, ATDIS::ErrorMessage.new("and other can't both be present", "4.3.3"))
+        end
+      end
+    end
+  end
+end

data/lib/atdis/models/location.rb

@@ -0,0 +1,23 @@
+require 'atdis/models/address'
+require "atdis/models/land_title_ref"
+require "rgeo/geo_json"
+
+module ATDIS
+  module Models
+    class Location < Model
+      set_field_mappings ({
+        address:        Address,
+        land_title_ref: LandTitleRef,
+        geometry:       RGeo::GeoJSON
+      })
+
+      # Mandatory parameters
+      validates :address, :land_title_ref, presence_before_type_cast: {spec_section: "4.3.3"}
+
+      validates :geometry, geo_json: {spec_section: "4.3.3"}
+
+      # This model is only valid if the children are valid
+      validates :address, :land_title_ref, valid: true
+    end
+  end
+end

data/lib/atdis/models/page.rb

@@ -0,0 +1,56 @@
+require "atdis/models/response"
+require "atdis/models/pagination"
+
+module ATDIS
+  module Models
+    class Page < Model
+      set_field_mappings ({
+        response:   Response,
+        count:      Fixnum,
+        pagination: Pagination,
+      })
+
+      # Mandatory parameters
+      validates :response, presence_before_type_cast: {spec_section: "4.3"}
+      # section 6.5 is not explicitly about this but it does contain an example which should be helpful
+      validates :response, array: {spec_section: "6.4"}
+      validate :count_is_consistent, :all_pagination_is_present
+
+      # This model is only valid if the children are valid
+      validates :response, valid: true
+      validates :pagination, valid: true
+
+      # If some of the pagination fields are present all of the required ones should be present
+      def all_pagination_is_present
+        if pagination && count.nil?
+          errors.add(:count, ErrorMessage["should be present if pagination is being used", "6.4"])
+        end
+      end
+
+      def count_is_consistent
+        if count
+          errors.add(:count, ErrorMessage["is not the same as the number of applications returned", "6.4"]) if count != response.count
+          errors.add(:count, ErrorMessage["should not be larger than the number of results per page", "6.4"]) if count > pagination.per_page
+        end
+      end
+
+      def previous_url
+        raise "Can't use previous_url when loaded with read_json" if url.nil?
+        ATDIS::SeparatedURL.merge(url, page: pagination.previous) if pagination && pagination.previous
+      end
+
+      def next_url
+        raise "Can't use next_url when loaded with read_json" if url.nil?
+        ATDIS::SeparatedURL.merge(url, page: pagination.next) if pagination && pagination.next
+      end
+
+      def previous_page
+        Page.read_url(previous_url) if previous_url
+      end
+
+      def next_page
+        Page.read_url(next_url) if next_url
+      end
+    end
+  end
+end

data/lib/atdis/models/pagination.rb

@@ -0,0 +1,68 @@
+module ATDIS
+  module Models
+    class Pagination < Model
+      set_field_mappings ({
+        previous: Fixnum,
+        next:     Fixnum,
+        current:  Fixnum,
+        per_page: Fixnum,
+        count:    Fixnum,
+        pages:    Fixnum
+      })
+
+      validate :all_pagination_is_present, :previous_is_consistent,
+        :next_is_consistent, :current_is_consistent,
+        :count_is_consistent
+
+      # If some of the pagination fields are present all of the required ones should be present
+      def all_pagination_is_present
+        errors.add(:current, ErrorMessage["should be present if pagination is being used", "6.4"]) if current.nil?
+        errors.add(:per_page, ErrorMessage["should be present if pagination is being used", "6.4"]) if per_page.nil?
+        errors.add(:count, ErrorMessage["should be present if pagination is being used", "6.4"]) if count.nil?
+        errors.add(:pages, ErrorMessage["should be present if pagination is being used", "6.4"]) if pages.nil?
+      end
+
+      def previous_is_consistent
+        if previous && current && previous != current - 1
+          errors.add(:previous, ErrorMessage["should be one less than current page number or null if first page", "6.4"])
+        end
+        if previous && current && current == 1
+          errors.add(:previous, ErrorMessage["should be null if on the first page", "6.4"])
+        end
+        if previous.nil? && current && current > 1
+          errors.add(:previous, ErrorMessage["can't be null if not on the first page", "6.4"])
+        end
+      end
+
+      def next_is_consistent
+        if self.next && current && self.next != current + 1
+          errors.add(:next, ErrorMessage["should be one greater than current page number or null if last page", "6.4"])
+        end
+        if self.next.nil? && current != pages
+          errors.add(:next, ErrorMessage["can't be null if not on the last page", "6.4"])
+        end
+        if self.next && current == pages
+          errors.add(:next, ErrorMessage["should be null if on the last page", "6.4"])
+        end
+      end
+
+      def current_is_consistent
+        if current && pages && current > pages
+          errors.add(:current, ErrorMessage["is larger than the number of pages", "6.4"])
+        end
+        if current && current < 1
+          errors.add(:current, ErrorMessage["can not be less than 1", "6.4"])
+        end
+      end
+
+      def count_is_consistent
+        if pages && per_page && count && count > pages * per_page
+          errors.add(:count, ErrorMessage["is larger than can be retrieved through paging", "6.4"])
+        end
+        if pages && per_page && count && count <= (pages - 1) * per_page
+          errors.add(:count, ErrorMessage["could fit into a smaller number of pages", "6.4"])
+        end
+      end
+    end
+  end
+end

data/lib/atdis/models/person.rb

@@ -0,0 +1,14 @@
+module ATDIS
+  module Models
+    class Person < Model
+      set_field_mappings ({
+        name:    String,
+        role:    String,
+        contact: String
+      })
+
+      # Mandatory parameters
+      validates :name, :role, presence_before_type_cast: {spec_section: "4.3.6"}
+    end
+  end
+end

data/lib/atdis/models/reference.rb

@@ -0,0 +1,13 @@
+module ATDIS
+  module Models
+    class Reference < Model
+      set_field_mappings ({
+        more_info_url: URI,
+        comments_url:  URI
+      })
+
+      validates :more_info_url, presence_before_type_cast: {spec_section: "4.3.2"}
+      validates :more_info_url, :comments_url, http_url: {spec_section: "4.3.2"}
+    end
+  end
+end

data/lib/atdis/models/response.rb

@@ -0,0 +1,16 @@
+require "atdis/models/application"
+
+module ATDIS
+  module Models
+    class Response < Model
+      set_field_mappings ({
+        application: Application
+      })
+
+      validates :application, presence_before_type_cast: {spec_section: "4.3"}
+
+      # This model is only valid if the children are valid
+      validates :application, valid: true
+    end
+  end
+end

data/lib/atdis/models/torrens_title.rb

@@ -0,0 +1,24 @@
+module ATDIS
+  module Models
+    class TorrensTitle < Model
+      set_field_mappings ({
+        lot:     String,
+        section: String,
+        dpsp_id: String
+      })
+
+      # Mandatory attributes
+      # section is not in this list because it can be null (even though it is mandatory)
+      validates :lot, :dpsp_id, presence_before_type_cast: {spec_section: "4.3.3"}
+      # TODO: Provide warning if dpsp_id doesn't start with "DP" or "SP"
+
+      validate :section_can_not_be_empty_string
+
+      def section_can_not_be_empty_string
+        if section == ""
+          errors.add(:section, ATDIS::ErrorMessage.new("can't be blank", "4.3.3"))
+        end
+      end
+    end
+  end
+end

data/lib/atdis/validators.rb

@@ -22,35 +22,51 @@ module ATDIS
       end
     end
 
-    class DateTimeOrNoneValidator < ActiveModel::EachValidator
+    class HttpUrlValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         raw_value = record.send("#{attribute}_before_type_cast")
-        if raw_value.present? && raw_value != "none" && !value.kind_of?(DateTime)
-          message = "is not a valid date or none"
+        if raw_value.present? && !value.kind_of?(URI::HTTP) && !value.kind_of?(URI::HTTPS)
+          message = "is not a valid URL"
           message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
           record.errors.add(attribute, message)
         end
       end
     end
 
-    class HttpUrlValidator < ActiveModel::EachValidator
+    class ArrayHttpUrlValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
-        raw_value = record.send("#{attribute}_before_type_cast")
-        if raw_value.present? && !value.kind_of?(URI::HTTP) && !value.kind_of?(URI::HTTPS) 
-          message = "is not a valid URL"
+        if value.present? && value.kind_of?(Array) &&
+          value.any?{|v| !v.kind_of?(URI::HTTP) && !v.kind_of?(URI::HTTPS)}
+            message = "contains an invalid URL"
+            message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
+            record.errors.add(attribute, message)
+        end
+      end
+    end
+
+    class ArrayValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value && !value.kind_of?(Array)
+          message = "should be an array"
           message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
           record.errors.add(attribute, message)
         end
       end
     end
 
-    class ArrayValidator < ActiveModel::EachValidator
+    # Can't be an empty array
+    class FilledArrayValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         if value && !value.kind_of?(Array)
           message = "should be an array"
           message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
           record.errors.add(attribute, message)
         end
+        if value && value.kind_of?(Array) && value.empty?
+          message = "should not be an empty array"
+          message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
+          record.errors.add(attribute, message)
+        end
       end
     end
 
@@ -59,7 +75,7 @@ module ATDIS
       def validate_each(record, attribute, value)
         raw_value = record.send("#{attribute}_before_type_cast")
         if !raw_value.kind_of?(Array) && !raw_value.present?
-          message = "can't be blank"          
+          message = "can't be blank"
           message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
           record.errors.add(attribute, message)
         end
@@ -70,7 +86,7 @@ module ATDIS
     class ValidValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         if (value.respond_to?(:valid?) && !value.valid?) || (value && !value.respond_to?(:valid?) && !value.all?{|v| v.valid?})
-          record.errors.add(attribute, ErrorMessage["is not valid", nil])
+          record.errors.add(attribute, ErrorMessage["is not valid (see further errors for details)", nil])
         end
       end
     end