diff --git a/app/services/bulk_upload/sales/year2024/csv_parser.rb b/app/services/bulk_upload/sales/year2024/csv_parser.rb new file mode 100644 index 000000000..aa0a5f729 --- /dev/null +++ b/app/services/bulk_upload/sales/year2024/csv_parser.rb @@ -0,0 +1,108 @@ +require "csv" + +class BulkUpload::Sales::Year2024::CsvParser + include CollectionTimeHelper + + MAX_COLUMNS = 142 + FORM_YEAR = 2024 + + attr_reader :path + + def initialize(path:) + @path = path + end + + def row_offset + if with_headers? + rows.find_index { |row| row[0].match(/field number/i) } + 1 + else + 0 + end + end + + def col_offset + with_headers? ? 1 : 0 + end + + def cols + @cols ||= ("A".."EK").to_a + end + + def row_parsers + @row_parsers ||= body_rows.map do |row| + stripped_row = row[col_offset..] + hash = Hash[field_numbers.zip(stripped_row)] + + BulkUpload::Sales::Year2024::RowParser.new(hash) + end + end + + def body_rows + rows[row_offset..] + end + + def rows + @rows ||= CSV.parse(normalised_string, row_sep:) + end + + def column_for_field(field) + cols[field_numbers.find_index(field) + col_offset] + end + + def wrong_template_for_year? + collection_start_year_for_date(first_record_start_date) != FORM_YEAR + rescue Date::Error + false + end + +private + + def default_field_numbers + [6, 3, 4, 5, nil, 28, 30, 38, 47, 51, 55, 59, 31, 39, 48, 52, 56, 60, 37, 46, 50, 54, 58, 35, 43, 49, 53, 57, 61, 32, 33, 78, 80, 79, 81, 83, 84, nil, 62, 66, 64, 65, 63, 67, 69, 70, 68, 76, 77, 16, 17, 18, 26, 24, 25, 27, 8, 91, 95, 96, 97, 92, 93, 94, 98, 100, 101, 103, 104, 106, 110, 111, 112, 113, 114, 9, 116, 117, 118, 120, 124, 125, 126, 10, 11, nil, 127, 129, 133, 134, 135, 1, 2, nil, 73, nil, 75, 107, 108, 121, 122, 130, 131, 82, 109, 123, 132, 115, 15, 86, 87, 29, 7, 12, 13, 14, 36, 44, 45, 88, 89, 102, 105, 119, 128, 19, 20, 21, 22, 23, 34, 40, 41, 42, 71, 72, 74, 85, 90, 99].map do |number| + if number.to_s.match?(/^[0-9]+$/) + "field_#{number}" + else + "field_blank" + end + end + end + + def field_numbers + @field_numbers ||= if with_headers? + rows[row_offset - 1][col_offset..].map { |number| number.to_s.match?(/^[0-9]+$/) ? "field_#{number}" : "field_blank" } + else + default_field_numbers + end + end + + def headers + @headers ||= ("field_1".."field_135").to_a + end + + def with_headers? + rows.map { |r| r[0] }.any? { |cell| cell&.match?(/field number/i) } + end + + def row_sep + "\n" + end + + def normalised_string + return @normalised_string if @normalised_string + + @normalised_string = File.read(path, encoding: "bom|utf-8") + @normalised_string.gsub!("\r\n", "\n") + @normalised_string.scrub!("") + @normalised_string.tr!("\r", "\n") + + @normalised_string + end + + def first_record_start_date + if with_headers? + Date.new(row_parsers.first.field_4.to_i + 2000, row_parsers.first.field_3.to_i, row_parsers.first.field_2.to_i) + else + Date.new(rows.first[3].to_i + 2000, rows.first[2].to_i, rows.first[1].to_i) + end + end +end diff --git a/app/services/bulk_upload/sales/year2024/row_parser.rb b/app/services/bulk_upload/sales/year2024/row_parser.rb new file mode 100644 index 000000000..96b075bc6 --- /dev/null +++ b/app/services/bulk_upload/sales/year2024/row_parser.rb @@ -0,0 +1,1335 @@ +class BulkUpload::Sales::Year2024::RowParser + include ActiveModel::Model + include ActiveModel::Attributes + include InterruptionScreenHelper + + QUESTIONS = { + field_1: "Which organisation owned this property before the sale?", + field_2: "Which organisation is reporting this sale?", + field_2: "Username", + field_3: "What is the day of the sale completion date? - DD", + field_4: "What is the month of the sale completion date? - MM", + field_5: "What is the year of the sale completion date? - YY", + field_6: "What is the purchaser code?", + field_7: "Was this purchase made through an ownership scheme?", + field_8: "What is the type of shared ownership sale?", + field_9: "What is the type of discounted ownership sale?", + field_10: "What is the type of outright sale?", + + field_11: "If 'other', what is the 'other' type?", + field_12: "Is the buyer a company?", + field_13: "Will the buyers live in the property?", + field_14: "Is this a joint purchase?", + field_15: "Are there more than two joint purchasers of this property?", + field_16: "How many bedrooms does the property have?", + field_17: "What type of unit is the property?", + field_18: "Which type of bulding is the property?", + field_19: "If known, enter this property's UPRN", + field_20: "Address line 1", + + field_21: "Address line 2", + field_22: "Town or city", + field_23: "County", + field_24: "Part 1 of postcode of property", + field_25: "Part 2 of postcode of property", + field_26: "What is the local authority of the property?", + field_27: "Is the property built or adapted to wheelchair user standards?", + field_28: "Was the buyer interviewed for any of the answers you will provide on this log?", + field_29: "Data Protection question", + field_30: "Age of buyer 1", + + field_31: "Gender identity of buyer 1", + field_32: "What is buyer 1's ethnic group?", + field_33: "What is buyer 1's nationality?", + field_34: "If 'Any other country', what is buyer 1's nationality?", + field_35: "Working situation of buyer 1", + field_36: "Will buyer 1 live in the property?", + field_37: "Relationship to buyer 1 for person 2", + field_38: "Age of person 2", + field_39: "Gender identity of person 2", + field_40: "Which of the following best describes buyer 2's ethnic background?", + + field_41: "What is buyer 2's nationality?", + field_42: "If 'Any other country', what is buyer 2's nationality?", + field_43: "What is buyer 2 or person 2's working situation?", + field_44: "Will buyer 2 live in the property?", + field_45: "Besides the buyers, how many people will live in the property?", + field_46: "Relationship to buyer 1 for person 3", + field_47: "Age of person 3", + field_48: "Gender identity of person 3", + field_49: "Working situation of person 3", + field_50: "Relationship to buyer 1 for person 4", + + field_51: "Age of person 4", + field_52: "Gender identity of person 4", + field_53: "Working situation of person 4", + field_54: "Relationship to buyer 1 for person 5", + field_55: "Age of person 5", + field_56: "Gender identity of person 5", + field_57: "Working situation of person 5", + field_58: "Relationship to buyer 1 for person 6", + field_59: "Age of person 6", + field_60: "Gender identity of person 6", + + field_61: "Working situation of person 6", + field_62: "What was buyer 1's previous tenure?", + field_63: "Do you know the postcode of buyer 1's last settled home?", + field_64: "Part 1 of postcode of buyer 1's last settled home", + field_65: "Part 2 of postcode of buyer 1's last settled home", + field_66: "What is the local authority of buyer 1's last settled home?", + field_67: "Was the buyer registered with their PRP (HA)?", + field_68: "Was the buyer registered with another PRP (HA)?", + field_69: "Was the buyer registered with the local authority?", + field_70: "Was the buyer registered with a Help to Buy agent?", + + field_71: "At the time of purchase, was buyer 2 living at the same address as buyer 1?", + field_72: "What was buyer 2's previous tenure?", + field_73: "Has the buyer ever served in the UK Armed Forces and for how long?", + field_74: "Is the buyer still serving in the UK armed forces?", + field_75: "Are any of the buyers a spouse or civil partner of a UK Armed Forces regular who died in service within the last 2 years?", + field_76: "Does anyone in the household consider themselves to have a disability?", + field_77: "Does anyone in the household use a wheelchair?", + field_78: "What is buyer 1's gross annual income?", + field_79: "Was buyer 1's income used for a mortgage application?", + field_80: "What is buyer 2's gross annual income?", + + field_81: "Was buyer 2's income used for a mortgage application?", + field_82: "Were the buyers receiving any of these housing-related benefits immediately before buying this property?", + field_83: "What is the total amount the buyers had in savings before they paid any deposit for the property?", + field_84: "Have any of the purchasers previously owned a property?", + field_85: "Was the previous property under shared ownership?", + field_86: "How long have the buyers been living in the property before the purchase? - Shared ownership", + field_87: "Is this a staircasing transaction?", + field_88: "What percentage of the property has been bought in this staircasing transaction?", + field_89: "What percentage of the property does the buyer now own in total?", + field_90: "Was this transaction part of a back-to-back staircasing transaction to facilitate sale of the home on the open market?", + + field_91: "Is this a resale?", + field_92: "What is the day of the exchange of contracts date?", + field_93: "What is the month of the exchange of contracts date?", + field_94: "What is the year of the exchange of contracts date?", + field_95: "What is the day of the practical completion or handover date?", + field_96: "What is the month of the practical completion or handover date?", + field_97: "What is the year of the practical completion or handover date?", + field_98: "Was the household re-housed under a local authority nominations agreement?", + field_99: "Was the buyer a private registered provider, housing association or local authority tenant immediately before this sale?", + field_100: "How many bedrooms did the buyer's previous property have?", + + field_101: "What was the type of the buyer's previous property?", + field_102: "What was the rent type of the buyer's previous property?", + field_103: "What was the full purchase price?", + field_104: "What was the initial percentage equity stake purchased?", + field_105: "Was a mortgage used for the purchase of this property? - Shared ownership", + field_106: "What is the mortgage amount?", + field_107: "What is the name of the mortgage lender? - Shared ownership", + field_108: "If 'other', what is the name of the mortgage lender?", + field_109: "What is the length of the mortgage in years? - Shared ownership", + field_110: "Does this include any extra borrowing?", + + field_111: "How much was the cash deposit paid on the property?", + field_112: "How much cash discount was given through Social Homebuy?", + field_113: "What is the basic monthly rent?", + field_114: "What are the total monthly leasehold charges for the property?", + field_115: "How long have the buyers been living in the property before the purchase? - Discounted ownership", + field_116: "What was the full purchase price?", + field_117: "What was the amount of any loan, grant, discount or subsidy given?", + field_118: "What was the percentage discount?", + field_119: "Was a mortgage used for the purchase of this property? - Discounted ownership", + field_120: "What is the mortgage amount?", + + field_121: "What is the name of the mortgage lender? - Discounted ownership", + field_122: "If 'other', what is the name of the mortgage lender?", + field_123: "What is the length of the mortgage in years? - Discounted ownership", + field_124: "Does this include any extra borrowing?", + field_125: "How much was the cash deposit paid on the property?", + field_126: "What are the total monthly leasehold charges for the property?", + field_127: "What is the full purchase price?", + field_128: "Was a mortgage used for the purchase of this property? - Outright sale", + field_129: "What is the mortgage amount?", + field_130: "What is the name of the mortgage lender? - Outright sale", + + field_131: "If 'other', what is the name of the mortgage lender?", + field_132: "What is the length of the mortgage in years? - Outright sale", + field_133: "Does this include any extra borrowing?", + field_134: "How much was the cash deposit paid on the property?", + field_135: "What are the total monthly leasehold charges for the property?", + }.freeze + + attribute :bulk_upload + attribute :block_log_creation, :boolean, default: -> { false } + + attribute :field_blank + + attribute :field_1, :string + attribute :field_2, :string + attribute :field_3, :integer + attribute :field_4, :integer + attribute :field_5, :integer + attribute :field_6, :string + attribute :field_7, :integer + attribute :field_8, :integer + attribute :field_9, :integer + attribute :field_10, :integer + + attribute :field_11, :string + attribute :field_12, :integer + attribute :field_13, :integer + attribute :field_14, :integer + attribute :field_15, :integer + attribute :field_16, :integer + attribute :field_17, :integer + attribute :field_18, :integer + attribute :field_19, :string + attribute :field_20, :string + + attribute :field_21, :string + attribute :field_22, :string + attribute :field_23, :string + attribute :field_24, :string + attribute :field_25, :string + attribute :field_26, :string + attribute :field_27, :integer + attribute :field_28, :integer + attribute :field_29, :integer + attribute :field_30, :string + + attribute :field_31, :string + attribute :field_32, :integer + attribute :field_33, :integer + attribute :field_34, :string + attribute :field_35, :integer + attribute :field_36, :integer + attribute :field_37, :string + attribute :field_38, :string + attribute :field_39, :string + attribute :field_40, :integer + + attribute :field_41, :integer + attribute :field_42, :string + attribute :field_43, :integer + attribute :field_44, :integer + attribute :field_45, :integer + attribute :field_46, :string + attribute :field_47, :string + attribute :field_48, :string + attribute :field_49, :integer + attribute :field_50, :string + + attribute :field_51, :string + attribute :field_52, :string + attribute :field_53, :integer + attribute :field_54, :string + attribute :field_55, :string + attribute :field_56, :string + attribute :field_57, :integer + attribute :field_58, :string + attribute :field_59, :string + attribute :field_60, :string + + attribute :field_61, :integer + attribute :field_62, :integer + attribute :field_63, :integer + attribute :field_64, :string + attribute :field_65, :string + attribute :field_66, :string + attribute :field_67, :integer + attribute :field_68, :integer + attribute :field_69, :integer + attribute :field_70, :integer + + attribute :field_71, :integer + attribute :field_72, :string + attribute :field_73, :integer + attribute :field_74, :integer + attribute :field_75, :integer + attribute :field_76, :integer + attribute :field_77, :integer + attribute :field_78, :integer + attribute :field_79, :integer + attribute :field_80, :integer + + attribute :field_81, :integer + attribute :field_82, :integer + attribute :field_83, :integer + attribute :field_84, :integer + attribute :field_85, :integer + attribute :field_86, :integer + attribute :field_87, :integer + attribute :field_88, :integer + attribute :field_89, :integer + attribute :field_90, :integer + + attribute :field_91, :integer + attribute :field_92, :integer + attribute :field_93, :integer + attribute :field_94, :integer + attribute :field_95, :integer + attribute :field_96, :integer + attribute :field_97, :integer + attribute :field_98, :integer + attribute :field_99, :integer + attribute :field_100, :integer + + attribute :field_101, :integer + attribute :field_102, :integer + attribute :field_103, :integer + attribute :field_104, :integer + attribute :field_105, :integer + attribute :field_106, :integer + attribute :field_107, :integer + attribute :field_108, :string + attribute :field_109, :integer + attribute :field_110, :integer + + attribute :field_111, :integer + attribute :field_112, :integer + attribute :field_113, :decimal + attribute :field_114, :decimal + attribute :field_115, :integer + attribute :field_116, :integer + attribute :field_117, :integer + attribute :field_118, :integer + attribute :field_119, :integer + attribute :field_120, :integer + + attribute :field_121, :integer + attribute :field_122, :string + attribute :field_123, :integer + attribute :field_124, :integer + attribute :field_125, :integer + attribute :field_126, :integer + attribute :field_127, :integer + attribute :field_128, :integer + attribute :field_129, :integer + attribute :field_130, :integer + + attribute :field_131, :string + attribute :field_132, :integer + attribute :field_133, :integer + attribute :field_134, :integer + attribute :field_135, :integer + + validates :field_3, + presence: { + message: I18n.t("validations.not_answered", question: "sale completion date (day)"), + category: :setup, + }, + on: :after_log + + validates :field_4, + presence: { + message: I18n.t("validations.not_answered", question: "sale completion date (month)"), + category: :setup, + }, on: :after_log + + validates :field_5, + presence: { + message: I18n.t("validations.not_answered", question: "sale completion date (year)"), + category: :setup, + }, + format: { + with: /\A\d{2}\z/, + message: I18n.t("validations.setup.saledate.year_not_two_digits"), + category: :setup, + if: proc { field_5.present? }, + }, on: :after_log + + validates :field_7, + presence: { + message: I18n.t("validations.not_answered", question: "purchase made under ownership scheme"), + category: :setup, + }, + on: :after_log + + validates :field_8, + inclusion: { + in: [2, 30, 18, 16, 24, 28, 31, 32], + if: proc { field_8.present? }, + category: :setup, + question: QUESTIONS[:field_8].downcase, + }, + on: :before_log + + validates :field_8, + presence: { + message: I18n.t("validations.not_answered", question: "type of shared ownership sale"), + category: :setup, + if: :shared_ownership?, + }, + on: :after_log + + validates :field_9, + inclusion: { + in: [8, 14, 27, 9, 29, 21, 22], + if: proc { field_9.present? }, + category: :setup, + question: QUESTIONS[:field_9].downcase, + }, + on: :before_log + + validates :field_9, + presence: { + message: I18n.t("validations.not_answered", question: "type of discounted ownership sale"), + category: :setup, + if: :discounted_ownership?, + }, + on: :after_log + + validates :field_10, + inclusion: { + in: [10, 12], + if: proc { field_10.present? }, + category: :setup, + question: QUESTIONS[:field_10].downcase, + }, + on: :before_log + + validates :field_10, + presence: { + message: I18n.t("validations.not_answered", question: "type of outright sale"), + category: :setup, + if: :outright_sale?, + }, + on: :after_log + + validates :field_11, + presence: { + message: I18n.t("validations.not_answered", question: "type of outright sale"), + category: :setup, + if: proc { field_10 == 12 }, + }, + on: :after_log + + validates :field_12, + inclusion: { + in: [1, 2], + if: proc { outright_sale? && field_12.present? }, + category: :setup, + question: QUESTIONS[:field_12].downcase, + }, + on: :before_log + + validates :field_12, + presence: { + message: I18n.t("validations.not_answered", question: "company buyer"), + category: :setup, + if: :outright_sale?, + }, + on: :after_log + + validates :field_13, + inclusion: { + in: [1, 2], + if: proc { outright_sale? && field_13.present? }, + category: :setup, + question: QUESTIONS[:field_13].downcase, + }, + on: :before_log + + validates :field_13, + presence: { + message: I18n.t("validations.not_answered", question: "buyers living in property"), + category: :setup, + if: :outright_sale?, + }, + on: :after_log + + validates :field_14, + presence: { + message: I18n.t("validations.not_answered", question: "joint purchase"), + category: :setup, + if: :joint_purchase_asked?, + }, + on: :after_log + + validates :field_15, + presence: { + message: I18n.t("validations.not_answered", question: "more than 2 joint buyers"), + category: :setup, + if: :joint_purchase?, + }, + on: :after_log + + validate :validate_buyer1_economic_status, on: :before_log + validate :validate_nulls, on: :after_log + validate :validate_valid_radio_option, on: :before_log + + validate :validate_owning_org_data_given, on: :after_log + validate :validate_owning_org_exists, on: :after_log + validate :validate_owning_org_owns_stock, on: :after_log if FeatureToggle.sales_managing_organisation_enabled? + validate :validate_owning_org_permitted, on: :after_log + + validate :validate_created_by_exists, on: :after_log + validate :validate_created_by_related, on: :after_log + validate :validate_managing_org_related, on: :after_log if FeatureToggle.sales_managing_organisation_enabled? + validate :validate_relevant_collection_window, on: :after_log + validate :validate_incomplete_soft_validations, on: :after_log + + validate :validate_uprn_exists_if_any_key_address_fields_are_blank, on: :after_log + validate :validate_address_fields, on: :after_log + validate :validate_if_log_already_exists, on: :after_log, if: -> { FeatureToggle.bulk_upload_duplicate_log_check_enabled? } + + validate :validate_data_protection_answered, on: :after_log + validate :validate_buyers_organisations, on: :after_log + + def self.question_for_field(field) + QUESTIONS[field] + end + + def attribute_set + @attribute_set ||= instance_variable_get(:@attributes) + end + + def blank_row? + attribute_set + .to_hash + .reject { |k, _| %w[bulk_upload block_log_creation].include?(k) } + .values + .compact + .empty? + end + + def log + @log ||= SalesLog.new(attributes_for_log) + end + + def valid? + errors.clear + + return true if blank_row? + + super(:before_log) + before_errors = errors.dup + + log.valid? + + super(:after_log) + errors.merge!(before_errors) + + log.errors.each do |error| + fields = field_mapping_for_errors[error.attribute] || [] + + fields.each do |field| + next if errors.include?(field) + + question = log.form.get_question(error.attribute, log) + + if question.present? && setup_question?(question) + errors.add(field, error.message, category: :setup) + else + errors.add(field, error.message) + end + end + end + + errors.blank? + end + + def block_log_creation? + block_log_creation + end + + def inspect + "#" + end + + def log_already_exists? + @log_already_exists ||= SalesLog + .where(status: %w[not_started in_progress completed]) + .exists?(duplicate_check_fields.index_with { |field| log.public_send(field) }) + end + + def purchaser_code + field_6 + end + + def spreadsheet_duplicate_hash + attributes.slice( + "field_1", # owning org + "field_3", # saledate + "field_4", # saledate + "field_5", # saledate + "field_6", # purchaser_code + "field_24", # postcode + "field_25", # postcode + "field_30", # age1 + "field_31", # sex1 + "field_35", # ecstat1 + ) + end + + def add_duplicate_found_in_spreadsheet_errors + spreadsheet_duplicate_hash.each_key do |field| + errors.add(field, :spreadsheet_dupe, category: :setup) + end + end + +private + + def validate_data_protection_answered + unless field_29 == 1 + errors.add(:field_29, I18n.t("validations.not_answered", question: QUESTIONS[:field_29].downcase), category: :setup) + end + end + + def validate_buyers_organisations + organisations_fields = %i[field_67 field_68 field_69 field_70] + if organisations_fields.all? { |field| attributes[field.to_s].blank? } + organisations_fields.each do |field| + errors.add(field, "At least one option must be selected of these four") + end + end + end + + def prevtenbuy2 + case field_72 + when "R" + 0 + else + field_72 + end + end + + def infer_buyer2_ethnic_group_from_ethnic + case field_40 + when 1, 2, 3, 18 + 0 + when 4, 5, 6, 7 + 1 + when 8, 9, 10, 11, 15 + 2 + when 12, 13, 14 + 3 + when 16, 19 + 4 + else + field_40 + end + end + + def validate_uprn_exists_if_any_key_address_fields_are_blank + if field_19.blank? && (field_20.blank? || field_22.blank?) + errors.add(:field_19, I18n.t("validations.not_answered", question: "UPRN")) + end + end + + def validate_address_fields + if field_19.blank? || log.errors.attribute_names.include?(:uprn) + if field_20.blank? + errors.add(:field_20, I18n.t("validations.not_answered", question: "address line 1")) + end + + if field_22.blank? + errors.add(:field_22, I18n.t("validations.not_answered", question: "town or city")) + end + end + end + + def shared_ownership? + field_7 == 1 + end + + def discounted_ownership? + field_7 == 2 + end + + def outright_sale? + field_7 == 3 + end + + def joint_purchase? + field_116 == 1 + end + + def joint_purchase_asked? + shared_ownership? || discounted_ownership? || field_114 == 2 + end + + def field_mapping_for_errors + { + purchid: %i[field_6], + saledate: %i[field_3 field_4 field_5], + noint: %i[field_28], + age1_known: %i[field_30], + age1: %i[field_30], + age2_known: %i[field_38], + age2: %i[field_38], + age3_known: %i[field_47], + age3: %i[field_47], + age4_known: %i[field_51], + age4: %i[field_51], + age5_known: %i[field_55], + age5: %i[field_55], + age6_known: %i[field_59], + age6: %i[field_59], + sex1: %i[field_31], + sex2: %i[field_39], + sex3: %i[field_48], + + sex4: %i[field_52], + sex5: %i[field_56], + sex6: %i[field_60], + relat2: %i[field_37], + relat3: %i[field_46], + relat4: %i[field_50], + relat5: %i[field_54], + relat6: %i[field_58], + + ecstat1: %i[field_35], + ecstat2: %i[field_43], + ecstat3: %i[field_49], + + ecstat4: %i[field_53], + ecstat5: %i[field_57], + ecstat6: %i[field_61], + ethnic_group: %i[field_32], + ethnic: %i[field_32], + national: %i[field_33], + income1nk: %i[field_78], + income1: %i[field_78], + income2nk: %i[field_80], + income2: %i[field_80], + inc1mort: %i[field_79], + inc2mort: %i[field_81], + savingsnk: %i[field_83], + savings: %i[field_83], + prevown: %i[field_84], + prevten: %i[field_62], + prevloc: %i[field_66], + previous_la_known: %i[field_66], + ppcodenk: %i[field_63], + ppostcode_full: %i[field_64 field_65], + pregyrha: %i[field_67], + pregla: %i[field_69], + pregghb: %i[field_70], + pregother: %i[field_68], + disabled: %i[field_76], + + wheel: %i[field_77], + beds: %i[field_16], + proptype: %i[field_17], + builtype: %i[field_18], + la_known: %i[field_26], + la: %i[field_26], + + is_la_inferred: %i[field_26], + pcodenk: %i[field_24 field_25], + postcode_full: %i[field_24 field_25], + wchair: %i[field_27], + + type: %i[field_8 field_9 field_10 field_7], + resale: %i[field_91], + hodate: %i[field_95 field_96 field_97], + exdate: %i[field_92 field_93 field_94], + + lanomagr: %i[field_98], + frombeds: %i[field_100], + fromprop: %i[field_101], + value: %i[field_103 field_116 field_127], + equity: %i[field_104], + mortgage: %i[field_106 field_120 field_129], + extrabor: %i[field_110 field_124 field_133], + deposit: %i[field_111 field_125 field_134], + cashdis: %i[field_112], + mrent: %i[field_113], + + has_mscharge: %i[field_114 field_126 field_135], + mscharge: %i[field_114 field_126 field_135], + grant: %i[field_117], + discount: %i[field_118], + othtype: %i[field_11], + owning_organisation_id: %i[field_1], + created_by: %i[field_2], + hhregres: %i[field_73], + hhregresstill: %i[field_74], + armedforcesspouse: %i[field_75], + + mortgagelender: %i[field_107 field_121 field_130], + mortgagelenderother: %i[field_108 field_122 field_131], + + hb: %i[field_82], + mortlen: %i[field_109 field_123 field_132], + proplen: %i[field_115 field_86], + + jointmore: %i[field_15], + staircase: %i[field_87], + privacynotice: %i[field_29], + ownershipsch: %i[field_7], + companybuy: %i[field_12], + buylivein: %i[field_13], + + jointpur: %i[field_14], + buy1livein: %i[field_36], + buy2livein: %i[field_44], + hholdcount: %i[field_45], + stairbought: %i[field_88], + stairowned: %i[field_89], + socprevten: %i[field_102], + mortgageused: %i[field_105 field_119 field_128], + soctenant: %i[field_99], + + uprn: %i[field_19], + address_line1: %i[field_20], + address_line2: %i[field_21], + town_or_city: %i[field_22], + county: %i[field_23], + + ethnic_group2: %i[field_40], + ethnicbuy2: %i[field_40], + nationalbuy2: %i[field_41], + + buy2living: %i[field_71], + prevtenbuy2: %i[field_72], + + prevshared: %i[field_85], + + staircasesale: %i[field_90], + } + end + + def attributes_for_log + attributes = {} + + attributes["purchid"] = purchaser_code + attributes["saledate"] = saledate + attributes["noint"] = 2 if field_28 == 1 + + attributes["age1_known"] = age1_known? + attributes["age1"] = field_30 if attributes["age1_known"]&.zero? && field_30&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age2_known"] = age2_known? + attributes["age2"] = field_38 if attributes["age2_known"]&.zero? && field_38&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age3_known"] = age3_known? + attributes["age3"] = field_47 if attributes["age3_known"]&.zero? && field_47&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age4_known"] = age4_known? + attributes["age4"] = field_51 if attributes["age4_known"]&.zero? && field_51&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age5_known"] = age5_known? + attributes["age5"] = field_55 if attributes["age5_known"]&.zero? && field_55&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age6_known"] = age6_known? + attributes["age6"] = field_59 if attributes["age6_known"]&.zero? && field_59&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["sex1"] = field_31 + attributes["sex2"] = field_39 + attributes["sex3"] = field_48 + attributes["sex4"] = field_52 + attributes["sex5"] = field_56 + attributes["sex6"] = field_60 + + attributes["relat2"] = field_37 + attributes["relat3"] = field_46 + attributes["relat4"] = field_50 + attributes["relat5"] = field_54 + attributes["relat6"] = field_58 + + attributes["ecstat1"] = field_35 + attributes["ecstat2"] = field_43 + attributes["ecstat3"] = field_49 + attributes["ecstat4"] = field_53 + attributes["ecstat5"] = field_57 + attributes["ecstat6"] = field_61 + + attributes["details_known_2"] = details_known?(2) + attributes["details_known_3"] = details_known?(3) + attributes["details_known_4"] = details_known?(4) + attributes["details_known_5"] = details_known?(5) + attributes["details_known_6"] = details_known?(6) + + attributes["ethnic_group"] = ethnic_group_from_ethnic + attributes["ethnic"] = field_32 + attributes["national"] = field_33 + + attributes["income1nk"] = field_78.present? ? 0 : 1 + attributes["income1"] = field_78 + + attributes["income2nk"] = field_80.present? ? 0 : 1 + attributes["income2"] = field_80 + + attributes["inc1mort"] = field_79 + attributes["inc2mort"] = field_81 + + attributes["savingsnk"] = field_83.present? ? 0 : 1 + attributes["savings"] = field_83 + attributes["prevown"] = field_84 + + attributes["prevten"] = field_62 + attributes["prevloc"] = field_66 + attributes["previous_la_known"] = previous_la_known + attributes["ppcodenk"] = previous_postcode_known + attributes["ppostcode_full"] = ppostcode_full + + attributes["pregyrha"] = field_67 + attributes["pregla"] = field_69 + attributes["pregghb"] = field_70 + attributes["pregother"] = field_68 + + attributes["disabled"] = field_76 + attributes["wheel"] = field_77 + attributes["beds"] = field_16 + attributes["proptype"] = field_17 + attributes["builtype"] = field_18 + attributes["la_known"] = field_26.present? ? 1 : 0 + attributes["la"] = field_26 + attributes["is_la_inferred"] = false + attributes["pcodenk"] = 0 if postcode_full.present? + attributes["postcode_full"] = postcode_full + attributes["wchair"] = field_27 + + attributes["type"] = sale_type + attributes["resale"] = field_91 + + attributes["hodate"] = hodate + attributes["exdate"] = exdate + + attributes["lanomagr"] = field_98 + + attributes["frombeds"] = field_100 + attributes["fromprop"] = field_101 + + attributes["value"] = value + attributes["equity"] = field_104 + attributes["mortgage"] = mortgage + attributes["extrabor"] = extrabor + attributes["deposit"] = deposit + + attributes["cashdis"] = field_112 + attributes["mrent"] = field_113 + attributes["mscharge"] = mscharge if mscharge&.positive? + attributes["has_mscharge"] = attributes["mscharge"].present? ? 1 : 0 + attributes["grant"] = field_117 + attributes["discount"] = field_118 + + attributes["othtype"] = field_11 + + attributes["owning_organisation"] = owning_organisation + attributes["managing_organisation"] = managing_organisation + attributes["created_by"] = created_by || bulk_upload.user + attributes["hhregres"] = field_73 + attributes["hhregresstill"] = field_74 + attributes["armedforcesspouse"] = field_75 + + attributes["mortgagelender"] = mortgagelender + attributes["mortgagelenderother"] = mortgagelenderother + + attributes["hb"] = field_82 + + attributes["mortlen"] = mortlen + + attributes["proplen"] = proplen if proplen&.positive? + attributes["proplen_asked"] = attributes["proplen"]&.present? ? 0 : 1 + attributes["jointmore"] = field_15 + attributes["staircase"] = field_87 + attributes["privacynotice"] = field_29 + attributes["ownershipsch"] = field_7 + attributes["companybuy"] = field_12 + attributes["buylivein"] = field_13 + attributes["jointpur"] = field_14 + attributes["buy1livein"] = field_36 + attributes["buy2livein"] = field_44 + attributes["hholdcount"] = field_45 + attributes["stairbought"] = field_88 + attributes["stairowned"] = field_89 + attributes["socprevten"] = field_102 + attributes["mortgageused"] = mortgageused + + attributes["uprn"] = field_19 + attributes["uprn_known"] = field_19.present? ? 1 : 0 + attributes["uprn_confirmed"] = 1 if field_19.present? + attributes["skip_update_uprn_confirmed"] = true + attributes["address_line1"] = field_20 + attributes["address_line2"] = field_21 + attributes["town_or_city"] = field_22 + attributes["county"] = field_23 + + attributes["ethnic_group2"] = infer_buyer2_ethnic_group_from_ethnic + attributes["ethnicbuy2"] = field_40 + attributes["nationalbuy2"] = field_41 + + attributes["buy2living"] = field_71 + attributes["prevtenbuy2"] = prevtenbuy2 + + attributes["prevshared"] = field_85 + + attributes["staircasesale"] = field_90 + + attributes["soctenant"] = field_99 + + attributes + end + + def saledate + Date.new(field_5 + 2000, field_4, field_3) if field_5.present? && field_4.present? && field_3.present? + rescue Date::Error + Date.new + end + + def hodate + Date.new(field_97 + 2000, field_96, field_95) if field_97.present? && field_96.present? && field_95.present? + rescue Date::Error + Date.new + end + + def exdate + Date.new(field_94 + 2000, field_93, field_92) if field_94.present? && field_93.present? && field_92.present? + rescue Date::Error + Date.new + end + + def age1_known? + return 1 if field_30 == "R" + + 0 + end + + [ + { person: 2, field: :field_38 }, + { person: 3, field: :field_47 }, + { person: 4, field: :field_51 }, + { person: 5, field: :field_55 }, + { person: 6, field: :field_59 }, + ].each do |hash| + define_method("age#{hash[:person]}_known?") do + return 1 if public_send(hash[:field]) == "R" + return 0 if send("person_#{hash[:person]}_present?") + end + end + + def person_2_present? + field_38.present? || field_39.present? || field_37.present? + end + + def person_3_present? + field_47.present? || field_48.present? || field_46.present? + end + + def person_4_present? + field_51.present? || field_52.present? || field_50.present? + end + + def person_5_present? + field_55.present? || field_56.present? || field_54.present? + end + + def person_6_present? + field_59.present? || field_60.present? || field_58.present? + end + + def details_known?(person_n) + send("person_#{person_n}_present?") ? 1 : 2 + end + + def ethnic_group_from_ethnic + return nil if field_32.blank? + + case field_32 + when 1, 2, 3, 18 + 0 + when 4, 5, 6, 7 + 1 + when 8, 9, 10, 11, 15 + 2 + when 12, 13, 14 + 3 + when 16, 19 + 4 + when 17 + 17 + end + end + + def postcode_full + "#{field_24} #{field_25}" if field_24 && field_25 + end + + def ppostcode_full + "#{field_64} #{field_65}" if field_64 && field_65 + end + + def sale_type + return field_8 if shared_ownership? + return field_9 if discounted_ownership? + return field_10 if outright_sale? + end + + def value + return field_103 if shared_ownership? + return field_116 if discounted_ownership? + return field_127 if outright_sale? + end + + def mortgage + return field_106 if shared_ownership? + return field_120 if discounted_ownership? + return field_129 if outright_sale? + end + + def extrabor + return field_110 if shared_ownership? + return field_124 if discounted_ownership? + return field_133 if outright_sale? + end + + def deposit + return field_111 if shared_ownership? + return field_125 if discounted_ownership? + return field_134 if outright_sale? + end + + def mscharge + return field_114 if shared_ownership? + return field_126 if discounted_ownership? + return field_135 if outright_sale? + end + + def mortgagelender + return field_107 if shared_ownership? + return field_121 if discounted_ownership? + return field_130 if outright_sale? + end + + def mortgagelenderother + return field_108 if shared_ownership? + return field_122 if discounted_ownership? + return field_131 if outright_sale? + end + + def mortlen + return field_109 if shared_ownership? + return field_123 if discounted_ownership? + return field_132 if outright_sale? + end + + def proplen + return field_86 if shared_ownership? + return field_115 if discounted_ownership? + end + + def mortgageused + return field_105 if shared_ownership? + return field_119 if discounted_ownership? + return field_128 if outright_sale? + end + + def owning_organisation + @owning_organisation ||= Organisation.find_by_id_on_multiple_fields(field_1) + end + + def created_by + @created_by ||= User.where("lower(email) = ?", field_2&.downcase).first + end + + def previous_la_known + field_66.present? ? 1 : 0 + end + + def previous_postcode_known + return 1 if field_63 == 2 + + 0 if field_63 == 1 + end + + def block_log_creation! + self.block_log_creation = true + end + + def questions + @questions ||= log.form.subsections.flat_map { |ss| ss.applicable_questions(log) } + end + + def duplicate_check_fields + %w[ + saledate + age1 + sex1 + ecstat1 + owning_organisation + postcode_full + purchid + ] + end + + def validate_owning_org_data_given + if field_1.blank? + block_log_creation! + + if errors[:field_1].blank? + errors.add(:field_1, "The owning organisation code is incorrect", category: :setup) + end + end + end + + def validate_owning_org_exists + if owning_organisation.nil? + block_log_creation! + + if errors[:field_1].blank? + errors.add(:field_1, "The owning organisation code is incorrect", category: :setup) + end + end + end + + def validate_owning_org_owns_stock + if owning_organisation && !owning_organisation.holds_own_stock? + block_log_creation! + + if errors[:field_1].blank? + errors.add(:field_1, "The owning organisation code provided is for an organisation that does not own stock", category: :setup) + end + end + end + + def validate_owning_org_permitted + if owning_organisation && !bulk_upload.user.organisation.affiliated_stock_owners.include?(owning_organisation) + block_log_creation! + + if errors[:field_1].blank? + errors.add(:field_1, "You do not have permission to add logs for this owning organisation", category: :setup) + end + end + end + + def validate_created_by_exists + return if field_2.blank? + + unless created_by + errors.add(:field_2, "User with the specified email could not be found") + end + end + + def validate_created_by_related + return unless created_by + return if created_by.organisation == owning_organisation || created_by.organisation == managing_organisation + return if created_by.organisation == owning_organisation&.absorbing_organisation || created_by.organisation == managing_organisation&.absorbing_organisation + + block_log_creation! + errors.add(:field_2, "User must be related to owning organisation or managing organisation", category: :setup) + end + + def managing_organisation + return owning_organisation if created_by&.organisation&.absorbed_organisations&.include?(owning_organisation) + + created_by&.organisation || bulk_upload.user.organisation + end + + def validate_managing_org_related + if owning_organisation && managing_organisation && !owning_organisation.can_be_managed_by?(organisation: managing_organisation) + block_log_creation! + + if errors[:field_2].blank? + errors.add(:field_2, "This user belongs to an organisation that does not have a relationship with the owning organisation", category: :setup) + end + end + end + + def setup_question?(question) + log.form.setup_sections[0].subsections[0].questions.include?(question) + end + + def validate_nulls + field_mapping_for_errors.each do |error_key, fields| + question_id = error_key.to_s + question = questions.find { |q| q.id == question_id } + + next unless question + next if log.optional_fields.include?(question.id) + next if question.completed?(log) + + if setup_question?(question) + fields.each do |field| + unless errors.any? { |e| fields.include?(e.attribute) } + errors.add(field, I18n.t("validations.not_answered", question: question.error_display_label&.downcase), category: :setup) + end + end + else + fields.each do |field| + unless errors.any? { |e| fields.include?(e.attribute) } + errors.add(field, I18n.t("validations.not_answered", question: question.error_display_label&.downcase)) + end + end + end + end + end + + def validate_valid_radio_option + log.attributes.each do |question_id, _v| + question = log.form.get_question(question_id, log) + + next if question_id == "type" + + next unless question&.type == "radio" + next if log[question_id].blank? || question.answer_options.key?(log[question_id].to_s) || !question.page.routed_to?(log, nil) + + fields = field_mapping_for_errors[question_id.to_sym] || [] + + if setup_question?(question) + fields.each do |field| + if errors[field].none? + block_log_creation! + errors.add(field, I18n.t("validations.invalid_option", question: QUESTIONS[field]), category: :setup) + end + end + else + fields.each do |field| + unless errors.any? { |e| fields.include?(e.attribute) } + errors.add(field, I18n.t("validations.invalid_option", question: QUESTIONS[field])) + end + end + end + end + end + + def validate_relevant_collection_window + return if saledate.blank? || bulk_upload.form.blank? + return if errors.key?(:field_3) || errors.key?(:field_4) || errors.key?(:field_5) + + unless bulk_upload.form.valid_start_date_for_form?(saledate) + errors.add(:field_3, I18n.t("validations.date.outside_collection_window", year_combo: bulk_upload.year_combo, start_year: bulk_upload.year, end_year: bulk_upload.end_year), category: :setup) + errors.add(:field_4, I18n.t("validations.date.outside_collection_window", year_combo: bulk_upload.year_combo, start_year: bulk_upload.year, end_year: bulk_upload.end_year), category: :setup) + errors.add(:field_5, I18n.t("validations.date.outside_collection_window", year_combo: bulk_upload.year_combo, start_year: bulk_upload.year, end_year: bulk_upload.end_year), category: :setup) + end + end + + def validate_if_log_already_exists + if log_already_exists? + error_message = "This is a duplicate log" + + errors.add(:field_1, error_message) # Owning org + errors.add(:field_3, error_message) # Sale completion date + errors.add(:field_4, error_message) # Sale completion date + errors.add(:field_5, error_message) # Sale completion date + errors.add(:field_24, error_message) # Postcode + errors.add(:field_25, error_message) # Postcode + errors.add(:field_30, error_message) # Buyer 1 age + errors.add(:field_31, error_message) # Buyer 1 gender + errors.add(:field_35, error_message) # Buyer 1 working situation + errors.add(:field_6, error_message) # Purchaser code + end + end + + def validate_incomplete_soft_validations + routed_to_soft_validation_questions = log.form.questions.filter { |q| q.type == "interruption_screen" && q.page.routed_to?(log, nil) }.compact + routed_to_soft_validation_questions.each do |question| + next if question.completed?(log) + + question.page.interruption_screen_question_ids.each do |interruption_screen_question_id| + next if log.form.questions.none? { |q| q.id == interruption_screen_question_id && q.page.routed_to?(log, nil) } + + field_mapping_for_errors[interruption_screen_question_id.to_sym]&.each do |field| + if errors.none? { |e| e.options[:category] == :soft_validation && field_mapping_for_errors[interruption_screen_question_id.to_sym].include?(e.attribute) } + error_message = [display_title_text(question.page.title_text, log), display_informative_text(question.page.informative_text, log)].reject(&:empty?).join(". ") + errors.add(field, message: error_message, category: :soft_validation) + end + end + end + end + end + + def validate_buyer1_economic_status + if field_35 == 9 + errors.add(:field_35, "Buyer 1 cannot be a child under 16") + end + end +end diff --git a/spec/services/bulk_upload/sales/year2024/csv_parser_spec.rb b/spec/services/bulk_upload/sales/year2024/csv_parser_spec.rb new file mode 100644 index 000000000..22bc73a9b --- /dev/null +++ b/spec/services/bulk_upload/sales/year2024/csv_parser_spec.rb @@ -0,0 +1,166 @@ +require "rails_helper" + +RSpec.describe BulkUpload::Sales::Year2024::CsvParser do + subject(:service) { described_class.new(path:) } + + let(:file) { Tempfile.new } + let(:path) { file.path } + let(:log) { build(:sales_log, :completed, :with_uprn) } + + context "when parsing csv with headers" do + before do + file.write("Question\n") + file.write("Additional info\n") + file.write("Values\n") + file.write("Can be empty?\n") + file.write("Type of letting the question applies to\n") + file.write("Duplicate check field?\n") + file.write(BulkUpload::SalesLogToCsv.new(log:).default_2024_field_numbers_row) + file.write(BulkUpload::SalesLogToCsv.new(log:).to_2024_csv_row) + file.rewind + end + + it "returns correct offsets" do + expect(service.row_offset).to eq(7) + expect(service.col_offset).to eq(1) + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_19).to eql(log.uprn) + end + end + + context "when parsing csv with headers in arbitrary order" do + let(:seed) { rand } + + before do + file.write("Question\n") + file.write("Additional info\n") + file.write("Values\n") + file.write("Can be empty?\n") + file.write("Type of letting the question applies to\n") + file.write("Duplicate check field?\n") + file.write(BulkUpload::SalesLogToCsv.new(log:).default_2024_field_numbers_row(seed:)) + file.write(BulkUpload::SalesLogToCsv.new(log:).to_2024_csv_row(seed:)) + file.rewind + end + + it "returns correct offsets" do + expect(service.row_offset).to eq(7) + expect(service.col_offset).to eq(1) + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_19).to eql(log.uprn) + end + end + + context "when parsing csv without headers" do + let(:file) { Tempfile.new } + let(:path) { file.path } + let(:log) { build(:sales_log, :completed, :with_uprn) } + + before do + file.write(BulkUpload::SalesLogToCsv.new(log:, col_offset: 0).to_2024_csv_row) + file.rewind + end + + it "returns correct offsets" do + expect(service.row_offset).to eq(0) + expect(service.col_offset).to eq(0) + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_19).to eql(log.uprn) + end + end + + context "when parsing with BOM aka byte order mark" do + let(:file) { Tempfile.new } + let(:path) { file.path } + let(:log) { build(:sales_log, :completed, :with_uprn) } + let(:bom) { "\uFEFF" } + + before do + file.write(bom) + file.write(BulkUpload::SalesLogToCsv.new(log:, col_offset: 0).to_2024_csv_row) + file.close + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_19).to eql(log.uprn) + end + end + + context "when an invalid byte sequence" do + let(:file) { Tempfile.new } + let(:path) { file.path } + let(:log) { build(:sales_log, :completed, :with_uprn) } + let(:invalid_sequence) { "\x81" } + + before do + file.write(invalid_sequence) + file.write(BulkUpload::SalesLogToCsv.new(log:, col_offset: 0).to_2024_csv_row) + file.close + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_19).to eql(log.uprn) + end + end + + describe "#column_for_field", aggregate_failures: true do + context "when headers present" do + before do + file.write("Question\n") + file.write("Additional info\n") + file.write("Values\n") + file.write("Can be empty?\n") + file.write("Type of letting the question applies to\n") + file.write("Duplicate check field?\n") + file.write(BulkUpload::SalesLogToCsv.new(log:).default_2024_field_numbers_row) + file.write(BulkUpload::SalesLogToCsv.new(log:).to_2024_csv_row) + file.rewind + end + + it "returns correct column" do + expect(service.column_for_field("field_1")).to eql("CO") + expect(service.column_for_field("field_99")).to eql("EK") + end + end + + context "when no headers" do + let(:file) { Tempfile.new } + let(:path) { file.path } + let(:log) { build(:sales_log, :completed, :with_uprn) } + + before do + file.write(BulkUpload::SalesLogToCsv.new(log:, col_offset: 0).to_2024_csv_row) + file.rewind + end + + it "returns correct column" do + expect(service.column_for_field("field_1")).to eql("CN") + expect(service.column_for_field("field_99")).to eql("EJ") + end + end + end + + context "when parsing csv with carriage returns" do + before do + file.write("Question\r\n") + file.write("Additional info\r") + file.write("Values\r\n") + file.write("Can be empty?\r") + file.write("Type of letting the question applies to\r\n") + file.write("Duplicate check field?\r") + file.write(BulkUpload::SalesLogToCsv.new(log:).default_2024_field_numbers_row) + file.write(BulkUpload::SalesLogToCsv.new(log:).to_2024_csv_row) + file.rewind + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_19).to eql(log.uprn) + end + end +end diff --git a/spec/services/bulk_upload/sales/year2024/row_parser_spec.rb b/spec/services/bulk_upload/sales/year2024/row_parser_spec.rb new file mode 100644 index 000000000..ef92caa43 --- /dev/null +++ b/spec/services/bulk_upload/sales/year2024/row_parser_spec.rb @@ -0,0 +1,1250 @@ +require "rails_helper" + +RSpec.describe BulkUpload::Sales::Year2024::RowParser do + subject(:parser) { described_class.new(attributes) } + + let(:now) { Time.zone.parse("01/05/2024") } + + let(:attributes) { { bulk_upload: } } + let(:bulk_upload) { create(:bulk_upload, :sales, user:, year: 2024) } + let(:user) { create(:user, organisation: owning_org) } + let(:owning_org) { create(:organisation, :with_old_visible_id) } + let(:setup_section_params) do + { + bulk_upload:, + field_1: owning_org.old_visible_id, # organisation + field_2: user.email, # user + field_3: now.day.to_s, # sale day + field_4: now.month.to_s, # sale month + field_5: now.strftime("%g"), # sale year + field_6: "test id", # purchase id + field_7: "1", # owhershipsch + field_8: "2", # shared ownership sale type + field_13: "1", # will the buyers live in the property + field_14: "2", # joint purchase + } + end + let(:valid_attributes) do + { + bulk_upload:, + + field_1: owning_org.old_visible_id, + field_3: "22", + field_4: "2", + field_5: "24", + field_6: "test id", + field_7: "1", + field_8: "2", + field_13: "1", + field_14: "1", + field_15: "2", + field_16: "2", + field_17: "1", + field_18: "1", + field_19: "12", + field_24: "CR0", + field_25: "4BB", + field_26: "E09000008", + field_27: "3", + field_28: "1", + field_29: "1", + field_30: "32", + field_31: "M", + field_32: "12", + field_33: "18", + field_35: "1", + field_36: "1", + field_37: "R", + field_38: "32", + field_39: "F", + field_40: "17", + field_41: "13", + field_43: "2", + field_44: "1", + field_45: "0", + field_62: "1", + field_63: "1", + field_64: "A1", + field_65: "1AA", + field_66: "E09000008", + field_69: "1", + field_70: "1", + field_71: "3", + field_73: "3", + field_75: "5", + field_76: "3", + field_77: "3", + field_78: "30000", + field_79: "1", + field_80: "15000", + field_81: "1", + field_82: "4", + field_83: "20000", + field_84: "3", + field_86: "5", + field_87: "1", + field_88: "10", + field_89: "10", + field_90: "1", + field_92: "30", + field_93: "3", + field_94: "22", + field_95: "24", + field_96: "3", + field_97: "22", + field_98: "3", + field_99: "1", + field_100: "1", + field_101: "1", + field_102: "1", + field_103: "250000", + field_104: "25", + field_105: "1", + field_106: "42500", + field_107: "1", + field_109: "20", + field_110: "3", + field_111: "20000", + field_113: "800", + field_114: "200", + } + end + + around do |example| + Timecop.freeze(Time.zone.local(2025, 2, 22)) do + Singleton.__init__(FormHandler) + example.run + end + end + + describe "#blank_row?" do + context "when a new object" do + it "returns true" do + expect(parser).to be_blank_row + end + end + + context "when any field is populated" do + before do + parser.field_1 = "1" + end + + it "returns false" do + expect(parser).not_to be_blank_row + end + end + end + + describe "purchaser_code" do + before do + def purch_id_field + described_class::QUESTIONS.key("What is the purchaser code?").to_s + end + end + + let(:attributes) do + { + bulk_upload:, + purch_id_field => "some purchaser code", + } + end + + it "is linked to the correct field" do + expect(parser.purchaser_code).to eq("some purchaser code") + end + end + + describe "previous postcode known" do + context "when field_63 is 1" do + let(:attributes) do + { + bulk_upload:, + field_63: 1, + } + end + + it "sets previous postcode known to yes" do + expect(parser.log.ppcodenk).to eq(0) + end + end + + context "when field_63 is 2" do + let(:attributes) do + { + bulk_upload:, + field_63: 2, + } + end + + it "sets previous postcode known to no" do + expect(parser.log.ppcodenk).to eq(1) + end + end + end + + describe "validations" do + before do + stub_request(:get, /api.postcodes.io/) + .to_return(status: 200, body: "{\"status\":200,\"result\":{\"admin_district\":\"Manchester\", \"codes\":{\"admin_district\": \"E08000003\"}}}", headers: {}) + + parser.valid? + end + + describe "#valid?" do + context "when the row is blank" do + let(:attributes) { { bulk_upload: } } + + it "returns true" do + expect(parser).to be_valid + end + end + + context "when calling the method multiple times" do + let(:attributes) { { bulk_upload:, field_7: 2 } } + + it "does not add keep adding errors to the pile" do + expect { parser.valid? }.not_to change(parser.errors, :count) + end + end + + context "when valid row" do + let(:attributes) { valid_attributes } + + it "returns true" do + expect(parser).to be_valid + end + + it "instantiates a log with everything completed", aggregate_failures: true do + questions = parser.send(:questions).reject do |q| + parser.send(:log).optional_fields.include?(q.id) || q.completed?(parser.send(:log)) + end + + expect(questions.map(&:id).size).to eq(0) + expect(questions.map(&:id)).to eql([]) + end + end + end + + context "when setup section not complete and type is not given" do + let(:attributes) do + { + bulk_upload:, + field_6: "test id", + } + end + + it "has errors on correct setup fields" do + errors = parser.errors.select { |e| e.options[:category] == :setup }.map(&:attribute).sort + + expect(errors).to eql(%i[field_1 field_29 field_3 field_4 field_5 field_7]) + end + end + + context "when setup section not complete and type is shared ownership" do + let(:attributes) do + { + bulk_upload:, + field_6: "test id", + field_7: "1", + } + end + + it "has errors on correct setup fields" do + errors = parser.errors.select { |e| e.options[:category] == :setup }.map(&:attribute).sort + + expect(errors).to eql(%i[field_1 field_14 field_29 field_3 field_4 field_5 field_8]) + end + end + + context "when setup section not complete it's shared ownership joint purchase" do + let(:attributes) do + { + bulk_upload:, + field_6: "test id", + field_7: "1", + field_8: "2", + field_14: "1", + } + end + + it "has errors on correct setup fields" do + errors = parser.errors.select { |e| e.options[:category] == :setup }.map(&:attribute).sort + + expect(errors).to eql(%i[field_1 field_15 field_29 field_3 field_4 field_5]) + end + end + + context "when setup section not complete and type is discounted ownership" do + let(:attributes) do + { + bulk_upload:, + field_6: "test id", + field_7: "2", + } + end + + it "has errors on correct setup fields" do + errors = parser.errors.select { |e| e.options[:category] == :setup }.map(&:attribute).sort + + expect(errors).to eql(%i[field_1 field_14 field_29 field_3 field_4 field_5 field_9]) + end + end + + context "when setup section not complete it's discounted ownership joint purchase" do + let(:attributes) do + { + bulk_upload:, + field_28: "test id", + field_30: "2", + field_47: "8", + field_39: "1", + } + end + + it "has errors on correct setup fields" do + errors = parser.errors.select { |e| e.options[:category] == :setup }.map(&:attribute).sort + + expect(errors).to eql(%i[field_1 field_29 field_3 field_4 field_5 field_7]) + end + end + + context "when setup section not complete and type is outright sale" do + let(:attributes) do + { + bulk_upload:, + field_6: "test id", + field_7: "3", + } + end + + it "has errors on correct setup fields" do + errors = parser.errors.select { |e| e.options[:category] == :setup }.map(&:attribute).sort + + expect(errors).to eql(%i[field_1 field_10 field_12 field_13 field_29 field_3 field_4 field_5]) + end + end + + context "when setup section not complete outright sale buyer is not company" do + let(:attributes) do + { + bulk_upload:, + field_6: "test id", + field_7: "3", + field_10: "12", + field_12: "2", + } + end + + it "has errors on correct setup fields" do + errors = parser.errors.select { |e| e.options[:category] == :setup }.map(&:attribute).sort + + expect(errors).to eql(%i[field_1 field_11 field_13 field_14 field_29 field_3 field_4 field_5]) + end + end + + describe "#field_1" do # owning org + context "when no data given" do + let(:attributes) { setup_section_params.merge(field_1: nil) } + + it "is not permitted as setup error" do + expect(parser.errors.where(:field_1, category: :setup).map(&:message)).to eql(["You must answer owning organisation"]) + end + + it "blocks log creation" do + expect(parser).to be_block_log_creation + end + end + + context "when cannot find owning org" do + let(:attributes) { { bulk_upload:, field_1: "donotexist" } } + + it "is not permitted as a setup error" do + expect(parser.errors.where(:field_1, category: :setup).map(&:message)).to eql(["You must answer owning organisation"]) + end + + it "blocks log creation" do + expect(parser).to be_block_log_creation + end + end + + context "when not affiliated with owning org" do + let(:unaffiliated_org) { create(:organisation, :with_old_visible_id) } + + let(:attributes) { { bulk_upload:, field_1: unaffiliated_org.old_visible_id } } + + it "is not permitted as setup error" do + expect(parser.errors.where(:field_1, category: :setup).map(&:message)).to eql(["You do not have permission to add logs for this owning organisation"]) + end + + it "blocks log creation" do + expect(parser).to be_block_log_creation + end + end + + context "when user's org has absorbed owning organisation with stock owners" do + let(:merged_org) { create(:organisation, :with_old_visible_id, holds_own_stock: true) } + let(:merged_org_stock_owner) { create(:organisation, :with_old_visible_id, holds_own_stock: true) } + + let(:attributes) { { bulk_upload:, field_1: merged_org_stock_owner.old_visible_id } } + + before do + create(:organisation_relationship, parent_organisation: merged_org_stock_owner, child_organisation: merged_org) + merged_org.update!(absorbing_organisation: user.organisation, merge_date: Time.zone.today) + merged_org.reload + user.organisation.reload + end + + it "is permitted" do + parser.valid? + expect(parser.errors.where(:field_1)).not_to be_present + end + end + + context "when user's org has absorbed owning organisation" do + let(:merged_org) { create(:organisation, :with_old_visible_id, holds_own_stock: true) } + + let(:attributes) { { bulk_upload:, field_1: merged_org.old_visible_id, field_2: user.email } } + + before do + merged_org.update!(absorbing_organisation: user.organisation, merge_date: Time.zone.today) + merged_org.reload + user.organisation.reload + user.reload + end + + it "is permitted" do + parser = described_class.new(attributes) + + parser.valid? + expect(parser.errors.where(:field_1)).not_to be_present + expect(parser.errors.where(:field_2)).not_to be_present + end + end + + context "when user's org has absorbed owning organisation before the startdate" do + let(:merged_org) { create(:organisation, :with_old_visible_id, holds_own_stock: true) } + + let(:attributes) { setup_section_params.merge({ field_1: merged_org.old_visible_id, field_2: user.email }) } + + before do + merged_org.update!(absorbing_organisation: user.organisation, merge_date: Time.zone.today - 3.years) + merged_org.reload + user.organisation.reload + user.reload + end + + it "is not permitted" do + parser = described_class.new(attributes) + + parser.valid? + expect(parser.errors[:field_1]).to include(/The owning organisation must be active on the sale completion date/) + expect(parser.errors[:field_3]).to include(/Enter a date when the owning organisation was active/) + expect(parser.errors[:field_4]).to include(/Enter a date when the owning organisation was active/) + expect(parser.errors[:field_5]).to include(/Enter a date when the owning organisation was active/) + end + end + end + + describe "#field_2" do # username for created_by + context "when blank" do + let(:attributes) { setup_section_params.merge(bulk_upload:, field_2: nil) } + + it "is permitted" do + expect(parser.errors[:field_2]).to be_blank + end + end + + context "when user could not be found" do + let(:attributes) { { bulk_upload:, field_2: "idonotexist@example.com" } } + + it "is not permitted" do + expect(parser.errors[:field_2]).to be_present + end + end + + context "when an unaffiliated user" do + let(:other_user) { create(:user) } + + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: other_user.email } } + + it "is not permitted as a setup error" do + expect(parser.errors.where(:field_2, category: :setup)).to be_present + end + + it "blocks log creation" do + expect(parser).to be_block_log_creation + end + end + + context "when an user part of owning org" do + let(:other_user) { create(:user, organisation: owning_org) } + + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: other_user.email } } + + it "is permitted" do + expect(parser.errors[:field_2]).to be_blank + end + end + + context "when email matches other than casing" do + let(:other_user) { create(:user, organisation: owning_org) } + + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: other_user.email.upcase! } } + + it "is permitted" do + expect(parser.errors[:field_2]).to be_blank + end + end + end + + describe "fields 3, 4, 5 => saledate" do + context "when all of these fields are blank" do + let(:attributes) { setup_section_params.merge({ field_3: nil, field_4: nil, field_5: nil }) } + + it "returns them as setup errors" do + expect(parser.errors.where(:field_3, category: :setup)).to be_present + expect(parser.errors.where(:field_4, category: :setup)).to be_present + expect(parser.errors.where(:field_5, category: :setup)).to be_present + end + end + + context "when one of these fields is blank" do + let(:attributes) { setup_section_params.merge({ field_3: "1", field_4: "1", field_5: nil }) } + + it "returns an error only on blank field as setup error" do + expect(parser.errors[:field_3]).to be_blank + expect(parser.errors[:field_4]).to be_blank + expect(parser.errors.where(:field_5, category: :setup)).to be_present + end + end + + context "when field 5 is 4 digits instead of 2" do + let(:attributes) { setup_section_params.merge({ bulk_upload:, field_5: "2023" }) } + + it "returns a setup error" do + expect(parser.errors.where(:field_5, category: :setup).map(&:message)).to include("Sale completion year must be 2 digits") + end + end + + context "when invalid date given" do + let(:attributes) { setup_section_params.merge({ field_3: "a", field_4: "12", field_5: "2023" }) } + + it "does not raise an error" do + expect { parser.valid? }.not_to raise_error + end + end + + context "when inside of collection year" do + around do |example| + Timecop.freeze(Date.new(2024, 10, 1)) do + example.run + end + end + + let(:attributes) { setup_section_params.merge({ field_3: "1", field_4: "10", field_5: "23" }) } + + let(:bulk_upload) { create(:bulk_upload, :sales, user:, year: 2024) } + + it "does not return errors" do + expect(parser.errors[:field_3]).not_to be_present + expect(parser.errors[:field_4]).not_to be_present + expect(parser.errors[:field_5]).not_to be_present + end + end + + context "when outside of collection year" do + around do |example| + Timecop.freeze(Date.new(2023, 4, 2)) do + example.run + end + end + + let(:attributes) { setup_section_params.merge({ field_3: "1", field_4: "1", field_5: "22" }) } + + let(:bulk_upload) { create(:bulk_upload, :sales, user:, year: 2023) } + + it "returns setup errors" do + expect(parser.errors.where(:field_3, category: :setup)).to be_present + expect(parser.errors.where(:field_4, category: :setup)).to be_present + expect(parser.errors.where(:field_5, category: :setup)).to be_present + end + end + end + + context "when the log already exists in the db" do + let(:attributes) { valid_attributes } + + before do + parser.log.save! + parser.instance_variable_set(:@valid, nil) + end + + it "is not a valid row" do + expect(parser).not_to be_valid + end + + it "adds an error to all (and only) the fields used to determine duplicates" do + parser.valid? + + error_message = "This is a duplicate log" + + [ + :field_1, # Owning org + :field_3, # Sale completion date + :field_4, # Sale completion date + :field_5, # Sale completion date + :field_24, # Postcode + :field_25, # Postcode + :field_30, # Buyer 1 age + :field_31, # Buyer 1 gender + :field_35, # Buyer 1 working situation + :field_6, # Purchaser code + ].each do |field| + expect(parser.errors[field]).to include(error_message) + end + end + end + + context "when a hidden log already exists in db" do + before do + parser.log.status = "pending" + parser.log.skip_update_status = true + parser.log.save! + end + + it "is a valid row" do + expect(parser).to be_valid + end + + it "does not add duplicate errors" do + parser.valid? + + [ + :field_1, # Owning org + :field_3, # Sale completion date + :field_4, # Sale completion date + :field_5, # Sale completion date + :field_24, # Postcode + :field_25, # Postcode + :field_30, # Buyer 1 age + :field_31, # Buyer 1 gender + :field_35, # Buyer 1 working situation + :field_6, # Purchaser code + ].each do |field| + expect(parser.errors[field]).to be_blank + end + end + end + + describe "#field_7" do # ownership scheme + context "when an invalid option" do + let(:attributes) { setup_section_params.merge({ field_7: "100" }) } + + it "returns setup error" do + expect(parser.errors.where(:field_7, category: :setup)).to be_present + end + end + end + + describe "#field_8" do # type for shared ownership sale + context "when an invalid option" do + let(:attributes) { setup_section_params.merge({ field_8: "100" }) } + + it "returns setup error" do + expect(parser.errors.where(:field_8, category: :setup)).to be_present + end + end + end + + describe "#field_9" do # type for discounted sale + context "when an invalid option" do + let(:attributes) { setup_section_params.merge({ field_9: "100" }) } + + it "returns setup error" do + expect(parser.errors.where(:field_9, category: :setup)).to be_present + end + end + end + + describe "#field_10" do # type for outright sale + context "when an invalid option" do + let(:attributes) { setup_section_params.merge({ field_10: "100" }) } + + it "returns setup error" do + expect(parser.errors.where(:field_10, category: :setup)).to be_present + end + end + end + + describe "#field_11" do # type of other outright sale + context "when an invalid option" do + let(:attributes) { setup_section_params.merge({ field_10: "12", field_11: nil }) } + + it "returns setup error" do + expect(parser.errors.where(:field_11, category: :setup)).to be_present + end + end + end + + describe "#field_12" do # buyer a company? + context "when an invalid option" do + let(:attributes) { setup_section_params.merge({ field_7: "3", field_12: "100" }) } + + it "returns setup error" do + expect(parser.errors.where(:field_12).map(&:message)).to include("Enter a valid value for is the buyer a company?") + expect(parser.errors.where(:field_12, category: :setup)).to be_present + end + end + end + + describe "#field_13" do # will buyers live in the property? + context "when an invalid option" do + let(:attributes) { setup_section_params.merge({ field_7: "3", field_13: "100" }) } + + it "returns setup error" do + expect(parser.errors.where(:field_13).map(&:message)).to eql(["Enter a valid value for will the buyers live in the property?"]) + expect(parser.errors.where(:field_13, category: :setup)).to be_present + end + end + end + + describe "#field_14" do # joint purchase + context "when an invalid option" do + let(:attributes) { setup_section_params.merge({ field_14: "100" }) } + + it "returns a setup error" do + expect(parser.errors.where(:field_14, category: :setup)).to be_present + end + end + end + + describe "#field_15" do # more than 2 joint buyers? + context "when invalid option and must be answered" do + let(:attributes) { setup_section_params.merge({ field_14: "1", field_15: "100" }) } + + it "returns a setup error" do + expect(parser.errors.where(:field_15, category: :setup)).to be_present + end + end + end + + describe "#field_19" do # UPRN + context "when UPRN known and lookup found" do + let(:attributes) { setup_section_params.merge({ field_19: "12" }) } + + it "is valid" do + expect(parser.errors[:field_19]).to be_blank + end + + it "sets UPRN and UPRN known" do + expect(parser.log.uprn).to eq("12") + expect(parser.log.uprn_known).to eq(1) + expect(parser.log.uprn_confirmed).to eq(1) + end + end + + context "when UPRN not known but address known" do + let(:attributes) { setup_section_params.merge({ field_19: nil, field_20: "some street", field_22: "some town", field_24: "EC1N", field_25: "2TD" }) } + + it "is valid" do + expect(parser.errors[:field_19]).to be_blank + end + end + + context "when neither UPRN or address known" do + let(:attributes) { setup_section_params.merge({ field_19: nil, field_20: nil, field_22: nil, field_24: nil, field_25: nil }) } + + it "is not valid" do + expect(parser.errors[:field_19]).to be_present + end + end + + context "when UPRN entered but no lookup found" do + let(:attributes) { setup_section_params.merge({ field_19: "1234567890123" }) } + + it "is not valid" do + expect(parser.errors[:field_19]).to be_present + end + end + end + + [ + { field: :field_20, name: "address line 1" }, + { field: :field_22, name: "town or city" }, + ].each do |data| + describe "##{data[:field]} (#{data[:name]})" do + context "when UPRN present" do + context "when UPRN valid" do + let(:attributes) { setup_section_params.merge({ field_19: "12", data[:field] => nil }) } + + it "can be blank" do + expect(parser.errors[data[:field]]).to be_blank + end + end + + context "when UPRN invalid" do + let(:attributes) { setup_section_params.merge({ field_19: "1234567890123", data[:field] => nil }) } + + it "cannot be blank" do + expect(parser.errors[data[:field]]).to be_present + end + end + end + + context "when UPRN not present" do + let(:attributes) { setup_section_params.merge({ field_19: nil, data[:field] => nil }) } + + it "cannot be blank" do + expect(parser.errors[data[:field]]).to be_present + end + end + end + end + + describe "#field_29" do # data protection + let(:attributes) { setup_section_params.merge({ field_29: nil }) } + + context "when not answered" do + it "returns a setup error" do + expect(parser.errors.where(:field_29, category: :setup)).to be_present + end + end + end + + [ + %w[age1_known details_known_1 age1 field_30 field_37 field_39], + %w[age2_known details_known_2 age2 field_38 field_37 field_39], + %w[age3_known details_known_3 age3 field_47 field_46 field_48], + %w[age4_known details_known_4 age4 field_51 field_50 field_52], + %w[age5_known details_known_5 age5 field_55 field_54 field_56], + %w[age6_known details_known_6 age6 field_59 field_58 field_60], + ].each do |known, details_known, age, field, relationship, gender| + describe "##{known} and ##{age}" do + context "when #{field} is blank" do + context "and person details are blank" do + let(:attributes) { setup_section_params.merge({ field.to_s => nil, relationship.to_sym => nil, gender.to_sym => nil, field_29: "1", field_45: "5" }) } + + it "does not set ##{known}" do + unless known == "age1_known" + expect(parser.log.public_send(known)).to be_nil + end + end + + it "sets ##{details_known} to no" do + unless details_known == "details_known_1" + expect(parser.log.public_send(details_known)).to eq(2) + end + end + + it "sets ##{age} to nil" do + expect(parser.log.public_send(age)).to be_nil + end + end + + context "and person details are given" do + let(:attributes) { setup_section_params.merge({ field.to_sym => nil, relationship.to_sym => "C", gender.to_sym => "X", field_29: "1", field_45: "5" }) } + + it "does not set ##{age}" do + parser.valid? + expect(parser.errors[field.to_sym]).to include(/You must answer/) + end + end + end + + context "when #{field} is R" do + let(:attributes) { setup_section_params.merge({ field.to_s => "R", field_28: "1", field_45: "5", field_29: "1" }) } + + it "sets ##{known} 1" do + expect(parser.log.public_send(known)).to be(1) + end + + it "sets ##{age} to nil" do + expect(parser.log.public_send(age)).to be_nil + end + end + + context "when #{field} is a number" do + let(:attributes) { setup_section_params.merge({ field.to_s => "50", field_28: "1", field_45: "5", field_29: "1" }) } + + it "sets ##{known} to 0" do + expect(parser.log.public_send(known)).to be(0) + end + + it "sets ##{age} to given age" do + expect(parser.log.public_send(age)).to be(50) + end + end + + context "when #{field} is a non-sensical value" do + let(:attributes) { setup_section_params.merge({ field.to_s => "A", field_28: "1", field_45: "5", field_29: "1" }) } + + it "sets ##{known} to 0" do + expect(parser.log.public_send(known)).to be(0) + end + + it "sets ##{age} to nil" do + expect(parser.log.public_send(age)).to be_nil + end + end + end + end + + describe "field_35" do # ecstat1 + context "when buyer 1 is marked as a child" do + let(:attributes) { valid_attributes.merge({ field_35: "9" }) } + + it "a custom validation is applied" do + validation_message = "Buyer 1 cannot be a child under 16" + expect(parser.errors[:field_35]).to include validation_message + end + end + end + + describe "#field_36" do # will buyer1 live in property? + context "when not a possible value" do + let(:attributes) { valid_attributes.merge({ field_36: "3" }) } + + it "is not valid" do + expect(parser.errors).to include(:field_36) + end + end + end + + describe "#field_67 - 70" do # buyers organisations + context "when all nil" do + let(:attributes) { setup_section_params.merge(field_67: nil, field_68: nil, field_69: nil, field_70: nil) } + + it "returns correct errors" do + expect(parser.errors[:field_67]).to be_present + expect(parser.errors[:field_68]).to be_present + expect(parser.errors[:field_69]).to be_present + expect(parser.errors[:field_70]).to be_present + end + end + end + + describe "soft validations" do + context "when soft validation is triggered" do + let(:attributes) { valid_attributes.merge({ field_30: 22, field_35: 5 }) } + + it "adds an error to the relevant fields" do + expect(parser.errors.where(:field_30, category: :soft_validation)).to be_present + expect(parser.errors.where(:field_35, category: :soft_validation)).to be_present + end + + it "populates with correct error message" do + expect(parser.errors.where(:field_30, category: :soft_validation).first.message).to eql("You told us this person is aged 22 years and retired.") + expect(parser.errors.where(:field_30, category: :soft_validation).first.message).to eql("You told us this person is aged 22 years and retired.") + end + end + + context "when a soft validation is triggered that relates both to fields that are and are not routed to" do + let(:attributes) { valid_attributes.merge({ field_103: "300000" }) } + + it "adds errors to fields that are routed to" do + expect(parser.errors.where(:field_103, category: :soft_validation)).to be_present + end + + it "does not add errors to fields that are not routed to" do + expect(parser.errors.where(:field_112, category: :soft_validation)).not_to be_present + end + end + end + end + + describe "#log" do + describe "#uprn" do + let(:attributes) { setup_section_params.merge({ field_19: "12" }) } + + it "is correctly set" do + expect(parser.log.uprn).to eql("12") + end + end + + describe "#uprn_known" do + context "when uprn known" do + let(:attributes) { setup_section_params.merge({ field_19: "12" }) } + + it "is correctly set" do + expect(parser.log.uprn_known).to be(1) + end + end + + context "when uprn not known" do + let(:attributes) { setup_section_params.merge({ field_19: nil }) } + + it "is correctly set" do + expect(parser.log.uprn_known).to be(0) + end + end + end + + describe "#address_line1" do + let(:attributes) { setup_section_params.merge({ field_20: "some street" }) } + + it "is correctly set" do + expect(parser.log.address_line1).to eql("some street") + end + end + + describe "#address_line2" do + let(:attributes) { setup_section_params.merge({ field_21: "some other street" }) } + + it "is correctly set" do + expect(parser.log.address_line2).to eql("some other street") + end + end + + describe "#town_or_city" do + let(:attributes) { setup_section_params.merge({ field_22: "some town" }) } + + it "is correctly set" do + expect(parser.log.town_or_city).to eql("some town") + end + end + + describe "#county" do + let(:attributes) { setup_section_params.merge({ field_23: "some county" }) } + + it "is correctly set" do + expect(parser.log.county).to eql("some county") + end + end + + describe "#ethnic_group2" do + let(:attributes) { setup_section_params.merge({ field_40: "1" }) } + + it "is correctly set" do + expect(parser.log.ethnic_group2).to be(0) + end + end + + describe "#ethnicbuy2" do + let(:attributes) { setup_section_params.merge({ field_40: "1" }) } + + it "is correctly set" do + expect(parser.log.ethnicbuy2).to be(1) + end + end + + describe "#nationalbuy2" do + let(:attributes) { setup_section_params.merge({ field_41: "18" }) } + + it "is correctly set" do + expect(parser.log.nationalbuy2).to be(18) + end + end + + describe "#buy2living" do + let(:attributes) { setup_section_params.merge({ field_71: "1" }) } + + it "is correctly set" do + expect(parser.log.buy2living).to be(1) + end + end + + describe "#prevtenbuy2" do + let(:attributes) { setup_section_params.merge({ field_72: "R" }) } + + it "is correctly set" do + expect(parser.log.prevtenbuy2).to be(0) + end + end + + describe "#hhregres" do + let(:attributes) { setup_section_params.merge({ field_73: "1" }) } + + it "is correctly set" do + expect(parser.log.hhregres).to be(1) + end + end + + describe "#hhregresstill" do + let(:attributes) { setup_section_params.merge({ field_74: "4" }) } + + it "is correctly set" do + expect(parser.log.hhregresstill).to be(4) + end + end + + describe "#prevshared" do + let(:attributes) { setup_section_params.merge({ field_85: "3" }) } + + it "is correctly set" do + expect(parser.log.prevshared).to be(3) + end + end + + describe "#staircasesale" do + let(:attributes) { setup_section_params.merge({ field_90: "1" }) } + + it "is correctly set" do + expect(parser.log.staircasesale).to be(1) + end + end + + describe "#soctenant" do + let(:attributes) { setup_section_params.merge({ field_99: "1" }) } + + it "is correctly set" do + expect(parser.log.soctenant).to be(1) + end + end + + describe "with living before purchase years for shared ownership more than 0" do + let(:attributes) { setup_section_params.merge({ field_7: "1", field_86: "1" }) } + + it "is sets living before purchase asked to yes and sets the correct living before purchase years" do + expect(parser.log.proplen_asked).to be(0) + expect(parser.log.proplen).to be(1) + end + end + + describe "with living before purchase years for discounted ownership more than 0" do + let(:attributes) { setup_section_params.merge({ field_7: "2", field_115: "1" }) } + + it "is sets living before purchase asked to yes and sets the correct living before purchase years" do + expect(parser.log.proplen_asked).to be(0) + expect(parser.log.proplen).to be(1) + end + end + + describe "with living before purchase years for shared ownership set to 0" do + let(:attributes) { setup_section_params.merge({ field_7: "1", field_86: "0" }) } + + it "is sets living before purchase asked to no" do + expect(parser.log.proplen_asked).to be(1) + expect(parser.log.proplen).to be_nil + end + end + + describe "with living before purchase 0 years for discounted ownership set to 0" do + let(:attributes) { setup_section_params.merge({ field_7: "2", field_115: "0" }) } + + it "is sets living before purchase asked to no" do + expect(parser.log.proplen_asked).to be(1) + expect(parser.log.proplen).to be_nil + end + end + + context "when mscharge is given, but is set to 0 for shared ownership" do + let(:attributes) { valid_attributes.merge(field_114: "0") } + + it "does not override variables correctly" do + log = parser.log + expect(log["has_mscharge"]).to eq(0) # no + expect(log["mscharge"]).to be_nil + end + end + + context "when mscharge is given, but is set to 0 for discounted ownership" do + let(:attributes) { valid_attributes.merge(field_7: "2", field_126: "0") } + + it "does not override variables correctly" do + log = parser.log + expect(log["has_mscharge"]).to eq(0) # no + expect(log["mscharge"]).to be_nil + end + end + + context "when mscharge is given, but is set to 0 for outright sale" do + let(:attributes) { valid_attributes.merge(field_7: "3", field_135: "0") } + + it "does not override variables correctly" do + log = parser.log + expect(log["has_mscharge"]).to eq(0) # no + expect(log["mscharge"]).to be_nil + end + end + + describe "shared ownership sale type" do + context "when 32 is selected for shared ownership type" do + let(:attributes) { valid_attributes.merge(field_8: "32") } + + it "sets the value correctly" do + log = parser.log + expect(log.type).to eq(32) + end + end + end + + describe "#managing_organisation_id" do + let(:attributes) { setup_section_params } + + context "when user is part of the owning organisation" do + it "sets managing organisation to the users organisation" do + parser.valid? + expect(parser.log.owning_organisation_id).to be(owning_org.id) + expect(parser.log.managing_organisation_id).to be(owning_org.id) + end + end + + context "when user is part of an organisation affiliated with owning org" do + let(:managing_agent) { create(:organisation) } + let(:user) { create(:user, organisation: managing_agent) } + let(:attributes) { setup_section_params } + + before do + create(:organisation_relationship, child_organisation: managing_agent, parent_organisation: owning_org) + end + + it "is not permitted as setup error" do + parser.valid? + expect(parser.log.owning_organisation_id).to be(owning_org.id) + expect(parser.log.managing_organisation_id).to be(managing_agent.id) + end + end + + context "when user is part of an organisation not affiliated with owning org" do + let(:unaffiliated_org) { create(:organisation) } + let(:user) { create(:user, organisation: unaffiliated_org) } + let(:attributes) { setup_section_params } + + it "is not permitted as setup error" do + parser.valid? + setup_errors = parser.errors.select { |e| e.options[:category] == :setup } + + expect(setup_errors.find { |e| e.attribute == :field_2 }.message).to eql("This user belongs to an organisation that does not have a relationship with the owning organisation") + end + + it "blocks log creation" do + parser.valid? + expect(parser).to be_block_log_creation + end + end + end + end + + describe "#owning_organisation_id" do + let(:attributes) { setup_section_params } + + context "when owning organisation does not own stock" do + let(:owning_org) { create(:organisation, :with_old_visible_id, holds_own_stock: false) } + let(:attributes) { setup_section_params } + + it "is not permitted as setup error" do + parser.valid? + setup_errors = parser.errors.select { |e| e.options[:category] == :setup } + + expect(setup_errors.find { |e| e.attribute == :field_1 }.message).to eql("The owning organisation code provided is for an organisation that does not own stock") + end + + it "blocks log creation" do + parser.valid? + expect(parser).to be_block_log_creation + end + end + end + + describe "#spreadsheet_duplicate_hash" do + it "returns a hash" do + expect(parser.spreadsheet_duplicate_hash).to be_a(Hash) + end + end + + describe "#add_duplicate_found_in_spreadsheet_errors" do + it "adds errors" do + expect { parser.add_duplicate_found_in_spreadsheet_errors }.to change(parser.errors, :size) + end + end +end