From 768230845100c48bd086a9a0a100f5a024bf77b3 Mon Sep 17 00:00:00 2001 From: Kat Date: Tue, 23 Jan 2024 10:46:26 +0000 Subject: [PATCH] Copy 23 BU files to 24 --- .../lettings/year2024/csv_parser.rb | 113 + .../lettings/year2024/row_parser.rb | 1577 ++++++++++ .../lettings/year2024/csv_parser_spec.rb | 226 ++ .../lettings/year2024/row_parser_spec.rb | 2660 +++++++++++++++++ 4 files changed, 4576 insertions(+) create mode 100644 app/services/bulk_upload/lettings/year2024/csv_parser.rb create mode 100644 app/services/bulk_upload/lettings/year2024/row_parser.rb create mode 100644 spec/services/bulk_upload/lettings/year2024/csv_parser_spec.rb create mode 100644 spec/services/bulk_upload/lettings/year2024/row_parser_spec.rb diff --git a/app/services/bulk_upload/lettings/year2024/csv_parser.rb b/app/services/bulk_upload/lettings/year2024/csv_parser.rb new file mode 100644 index 000000000..85bd6e699 --- /dev/null +++ b/app/services/bulk_upload/lettings/year2024/csv_parser.rb @@ -0,0 +1,113 @@ +require "csv" + +class BulkUpload::Lettings::Year2024::CsvParser + include CollectionTimeHelper + + FIELDS = 134 + 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".."EL").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::Lettings::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 correct_field_count? + valid_field_numbers_count = field_numbers.count { |f| f != "field_blank" } + + valid_field_numbers_count == FIELDS + end + + def too_many_columns? + return if with_headers? + + max_columns_count = body_rows.map(&:size).max - col_offset + + max_columns_count > MAX_COLUMNS + 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 + [5, nil, nil, 15, 16, nil, 13, 40, 41, 42, 43, 46, 52, 56, 60, 64, 68, 72, 76, 47, 53, 57, 61, 65, 69, 73, 77, 51, 55, 59, 63, 67, 71, 75, 50, 54, 58, 62, 66, 70, 74, 78, 48, 49, 79, 81, 82, 123, 124, 122, 120, 102, 103, nil, 83, 84, 85, 86, 87, 88, 104, 109, 107, 108, 106, 100, 101, 105, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 126, 128, 129, 130, 131, 132, 127, 125, 133, 134, 33, 34, 35, 36, 37, 38, nil, 7, 8, 9, 28, 14, 32, 29, 30, 31, 26, 27, 25, 23, 24, nil, 1, 3, 2, 80, nil, 121, 44, 89, 98, 92, 95, 90, 91, 93, 94, 97, 96, 99, 10, 11, 12, 45, 39, 6, 4, 17, 18, 19, 20, 21, 22].map { |h| h.present? && h.to_s.match?(/^[0-9]+$/) ? "field_#{h}" : "field_blank" } + end + + def field_numbers + @field_numbers ||= if with_headers? + rows[row_offset - 1][col_offset..].map { |h| h.present? && h.match?(/^[0-9]+$/) ? "field_#{h}" : "field_blank" } + else + default_field_numbers + end + 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_98.to_i + 2000, row_parsers.first.field_97.to_i, row_parsers.first.field_96.to_i) + else + Date.new(rows.first[97].to_i + 2000, rows.first[96].to_i, rows.first[95].to_i) + end + end +end diff --git a/app/services/bulk_upload/lettings/year2024/row_parser.rb b/app/services/bulk_upload/lettings/year2024/row_parser.rb new file mode 100644 index 000000000..bd1996adb --- /dev/null +++ b/app/services/bulk_upload/lettings/year2024/row_parser.rb @@ -0,0 +1,1577 @@ +class BulkUpload::Lettings::Year2024::RowParser + include ActiveModel::Model + include ActiveModel::Attributes + include InterruptionScreenHelper + + QUESTIONS = { + field_1: "Which organisation owns this property?", + field_2: "Which organisation manages this letting?", + field_3: "What is the CORE username of the account this letting log should be assigned to?", + field_4: "What is the needs type?", + field_5: "What is the letting type?", + field_6: "Is this letting a renewal?", + field_7: "What is the tenancy start date?", + field_8: "What is the tenancy start date?", + field_9: "What is the tenancy start date?", + field_10: "Is this a London Affordable Rent letting?", + field_11: "Which type of Intermediate Rent is this letting?", + field_12: "Which 'Other' type of Intermediate Rent is this letting?", + field_13: "What is the tenant code?", + field_14: "What is the property reference?", + field_15: "What management group does this letting belong to?", + field_16: "What scheme does this letting belong to?", + field_17: "Which location is this letting for?", + field_18: "If known, provide this property’s UPRN", + field_19: "Address line 1", + field_20: "Address line 2", + field_21: "Town or city", + field_22: "County", + field_23: "Part 1 of the property's postcode", + field_24: "Part 2 of the property's postcode", + field_25: "What is the property's local authority?", + field_26: "What type was the property most recently let as?", + field_27: "What is the reason for the property being vacant?", + field_28: "How many times was the property offered between becoming vacant and this letting?", + field_29: "What type of unit is the property?", + field_30: "Which type of building is the property?", + field_31: "Is the property built or adapted to wheelchair-user standards?", + field_32: "How many bedrooms does the property have?", + field_33: "What is the void date?", + field_34: "What is the void date?", + field_35: "What is the void date?", + field_36: "What date were any major repairs completed on?", + field_37: "What date were any major repairs completed on?", + field_38: "What date were any major repairs completed on?", + field_39: "Is this a joint tenancy?", + field_40: "Is this a starter tenancy?", + field_41: "What is the type of tenancy?", + field_42: "If 'Other', what is the type of tenancy?", + field_43: "What is the length of the fixed-term tenancy to the nearest year?", + field_44: "Is this letting sheltered accommodation?", + field_45: "Has tenant seen the DLUHC privacy notice?", + field_46: "What is the lead tenant's age?", + field_47: "Which of these best describes the lead tenant's gender identity?", + field_48: "Which of these best describes the lead tenant's ethnic background?", + field_49: "What is the lead tenant's nationality?", + field_50: "Which of these best describes the lead tenant's working situation?", + field_51: "What is person 2's relationship to the lead tenant?", + field_52: "What is person 2's age?", + field_53: "Which of these best describes person 2's gender identity?", + field_54: "Which of these best describes person 2's working situation?", + field_55: "What is person 3's relationship to the lead tenant?", + field_56: "What is person 3's age?", + field_57: "Which of these best describes person 3's gender identity?", + field_58: "Which of these best describes person 3's working situation?", + field_59: "What is person 4's relationship to the lead tenant?", + field_60: "What is person 4's age?", + field_61: "Which of these best describes person 4's gender identity?", + field_62: "Which of these best describes person 4's working situation?", + field_63: "What is person 5's relationship to the lead tenant?", + field_64: "What is person 5's age?", + field_65: "Which of these best describes person 5's gender identity?", + field_66: "Which of these best describes person 5's working situation?", + field_67: "What is person 6's relationship to the lead tenant?", + field_68: "What is person 6's age?", + field_69: "Which of these best describes person 6's gender identity?", + field_70: "Which of these best describes person 6's working situation?", + field_71: "What is person 7's relationship to the lead tenant?", + field_72: "What is person 7's age?", + field_73: "Which of these best describes person 7's gender identity?", + field_74: "Which of these best describes person 7's working situation?", + field_75: "What is person 8's relationship to the lead tenant?", + field_76: "What is person 8's age?", + field_77: "Which of these best describes person 8's gender identity?", + field_78: "Which of these best describes person 8's working situation?", + field_79: "Does anybody in the household have links to the UK armed forces?", + field_80: "Is this person still serving in the UK armed forces?", + field_81: "Was this person seriously injured or ill as a result of serving in the UK armed forces?", + field_82: "Is anybody in the household pregnant?", + field_83: "Does anybody in the household have any disabled access needs?", + field_84: "Does anybody in the household have any disabled access needs?", + field_85: "Does anybody in the household have any disabled access needs?", + field_86: "Does anybody in the household have any disabled access needs?", + field_87: "Does anybody in the household have any disabled access needs?", + field_88: "Does anybody in the household have any disabled access needs?", + field_89: "Does anybody in the household have a physical or mental health condition (or other illness) expected to last 12 months or more?", + field_90: "Does this person's condition affect their dexterity?", + field_91: "Does this person's condition affect their learning or understanding or concentrating?", + field_92: "Does this person's condition affect their hearing?", + field_93: "Does this person's condition affect their memory?", + field_94: "Does this person's condition affect their mental health?", + field_95: "Does this person's condition affect their mobility?", + field_96: "Does this person's condition affect them socially or behaviourally?", + field_97: "Does this person's condition affect their stamina or breathing or fatigue?", + field_98: "Does this person's condition affect their vision?", + field_99: "Does this person's condition affect them in another way?", + field_100: "How long has the household continuously lived in the local authority area of the new letting?", + field_101: "How long has the household been on the local authority waiting list for the new letting?", + field_102: "What is the tenant’s main reason for the household leaving their last settled home?", + field_103: "If 'Other', what was the main reason for leaving their last settled home?", + field_104: "Where was the household immediately before this letting?", + field_105: "Did the household experience homelessness immediately before this letting?", + field_106: "Do you know the postcode of the household's last settled home?", + field_107: "What is the postcode of the household's last settled home?", + field_108: "What is the postcode of the household's last settled home?", + field_109: "What is the local authority of the household's last settled home?", + field_110: "Was the household given 'reasonable preference' by the local authority?", + field_111: "Reasonable preference reason They were homeless or about to lose their home (within 56 days)", + field_112: "Reasonable preference reason They were living in insanitary, overcrowded or unsatisfactory housing", + field_113: "Reasonable preference reason They needed to move on medical and welfare reasons (including disability)", + field_114: "Reasonable preference reason They needed to move to avoid hardship to themselves or others", + field_115: "Reasonable preference reason Don't know", + field_116: "Was the letting made under the Choice-Based Lettings (CBL)?", + field_117: "Was the letting made under the Common Allocation Policy (CAP)?", + field_118: "Was the letting made under the Common Housing Register (CHR)?", + field_119: "What was the source of referral for this letting?", + field_120: "Do you know the household's combined total income after tax?", + field_121: "How often does the household receive income?", + field_122: "How much income does the household have in total?", + field_123: "Is the tenant likely to be receiving any of these housing-related benefits?", + field_124: "How much of the household's income is from Universal Credit, state pensions or benefits?", + field_125: "Does the household pay rent or other charges for the accommodation?", + field_126: "How often does the household pay rent and other charges?", + field_127: "If this is a care home, how much does the household pay every [time period]?", + field_128: "What is the basic rent?", + field_129: "What is the service charge?", + field_130: "What is the personal service charge?", + field_131: "What is the support charge?", + field_132: "Total charge", + field_133: "After the household has received any housing-related benefits, will they still need to pay for rent and charges?", + field_134: "What do you expect the outstanding amount to be?", + }.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, :string + attribute :field_4, :integer + attribute :field_5, :integer + attribute :field_6, :integer + attribute :field_7, :integer + attribute :field_8, :integer + attribute :field_9, :integer + attribute :field_10, :integer + attribute :field_11, :integer + attribute :field_12, :string + attribute :field_13, :string + attribute :field_14, :string + attribute :field_15, :string + attribute :field_16, :string + attribute :field_17, :string + attribute :field_18, :string + 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, :integer + attribute :field_27, :integer + attribute :field_28, :integer + attribute :field_29, :integer + attribute :field_30, :integer + attribute :field_31, :integer + attribute :field_32, :integer + attribute :field_33, :integer + attribute :field_34, :integer + attribute :field_35, :integer + attribute :field_36, :integer + attribute :field_37, :integer + attribute :field_38, :integer + attribute :field_39, :integer + 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, :integer + attribute :field_49, :integer + attribute :field_50, :integer + attribute :field_51, :string + attribute :field_52, :string + attribute :field_53, :string + attribute :field_54, :integer + attribute :field_55, :string + attribute :field_56, :string + attribute :field_57, :string + attribute :field_58, :integer + attribute :field_59, :string + attribute :field_60, :string + attribute :field_61, :string + attribute :field_62, :integer + attribute :field_63, :string + attribute :field_64, :string + attribute :field_65, :string + attribute :field_66, :integer + attribute :field_67, :string + attribute :field_68, :string + attribute :field_69, :string + attribute :field_70, :integer + attribute :field_71, :string + attribute :field_72, :string + attribute :field_73, :string + attribute :field_74, :integer + attribute :field_75, :string + attribute :field_76, :string + attribute :field_77, :string + 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, :string + attribute :field_104, :integer + attribute :field_105, :integer + attribute :field_106, :integer + attribute :field_107, :string + attribute :field_108, :string + attribute :field_109, :string + attribute :field_110, :integer + attribute :field_111, :integer + attribute :field_112, :integer + attribute :field_113, :integer + attribute :field_114, :integer + 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, :decimal + attribute :field_123, :integer + attribute :field_124, :integer + attribute :field_125, :integer + attribute :field_126, :integer + attribute :field_127, :decimal + attribute :field_128, :decimal + attribute :field_129, :decimal + attribute :field_130, :decimal + attribute :field_131, :decimal + attribute :field_132, :decimal + attribute :field_133, :integer + attribute :field_134, :decimal + + validate :validate_valid_radio_option, on: :before_log + + validates :field_5, + presence: { + message: I18n.t("validations.not_answered", question: "letting type"), + category: :setup, + }, + inclusion: { + in: (1..12).to_a, + message: I18n.t("validations.invalid_option", question: "letting type"), + unless: -> { field_5.blank? }, + category: :setup, + }, + on: :after_log + + validates :field_6, + presence: { + message: I18n.t("validations.not_answered", question: "property renewal"), + category: :setup, + }, + on: :after_log + + validates :field_7, + presence: { + message: I18n.t("validations.not_answered", question: "tenancy start date (day)"), + category: :setup, + }, + on: :after_log + + validates :field_8, + presence: { + message: I18n.t("validations.not_answered", question: "tenancy start date (month)"), + category: :setup, + }, + on: :after_log + + validates :field_9, + presence: { + message: I18n.t("validations.not_answered", question: "tenancy start date (year)"), + category: :setup, + }, + format: { + with: /\A\d{2}\z/, + message: I18n.t("validations.setup.startdate.year_not_two_digits"), + category: :setup, + unless: -> { field_9.blank? }, + }, + on: :after_log + + validates :field_16, + presence: { + if: proc { supported_housing? }, + message: I18n.t("validations.not_answered", question: "scheme code"), + category: :setup, + }, + on: :after_log + + validates :field_46, format: { with: /\A\d{1,3}\z|\AR\z/, message: "Age of person 1 must be a number or the letter R" }, on: :after_log + validates :field_52, format: { with: /\A\d{1,3}\z|\AR\z/, message: "Age of person 2 must be a number or the letter R" }, on: :after_log, if: proc { details_known?(2).zero? } + validates :field_56, format: { with: /\A\d{1,3}\z|\AR\z/, message: "Age of person 3 must be a number or the letter R" }, on: :after_log, if: proc { details_known?(3).zero? } + validates :field_60, format: { with: /\A\d{1,3}\z|\AR\z/, message: "Age of person 4 must be a number or the letter R" }, on: :after_log, if: proc { details_known?(4).zero? } + validates :field_64, format: { with: /\A\d{1,3}\z|\AR\z/, message: "Age of person 5 must be a number or the letter R" }, on: :after_log, if: proc { details_known?(5).zero? } + validates :field_68, format: { with: /\A\d{1,3}\z|\AR\z/, message: "Age of person 6 must be a number or the letter R" }, on: :after_log, if: proc { details_known?(6).zero? } + validates :field_72, format: { with: /\A\d{1,3}\z|\AR\z/, message: "Age of person 7 must be a number or the letter R" }, on: :after_log, if: proc { details_known?(7).zero? } + validates :field_76, format: { with: /\A\d{1,3}\z|\AR\z/, message: "Age of person 8 must be a number or the letter R" }, on: :after_log, if: proc { details_known?(8).zero? } + + validate :validate_needs_type_present, on: :after_log + validate :validate_data_types, on: :after_log + validate :validate_relevant_collection_window, on: :after_log + validate :validate_la_with_local_housing_referral, on: :after_log + validate :validate_cannot_be_la_referral_if_general_needs_and_la, on: :after_log + validate :validate_leaving_reason_for_renewal, on: :after_log + validate :validate_lettings_type_matches_bulk_upload, on: :after_log + validate :validate_only_one_housing_needs_type, on: :after_log + validate :validate_no_disabled_needs_conjunction, on: :after_log + validate :validate_dont_know_disabled_needs_conjunction, on: :after_log + validate :validate_no_and_dont_know_disabled_needs_conjunction, on: :after_log + validate :validate_no_housing_needs_questions_answered, on: :after_log + validate :validate_reasonable_preference_homeless, on: :after_log + validate :validate_condition_effects, on: :after_log + validate :validate_lettings_allocation, on: :after_log + validate :validate_if_log_already_exists, on: :after_log, if: -> { FeatureToggle.bulk_upload_duplicate_log_check_enabled? } + + 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 + validate :validate_owning_org_permitted, on: :after_log + + validate :validate_managing_org_data_given, on: :after_log + validate :validate_managing_org_exists, on: :after_log + validate :validate_managing_org_related, on: :after_log + + validate :validate_related_scheme_exists, on: :after_log + validate :validate_scheme_data_given, on: :after_log + + validate :validate_related_location_exists, on: :after_log + validate :validate_location_data_given, on: :after_log + + validate :validate_created_by_exists, on: :after_log + validate :validate_created_by_related, on: :after_log + + validate :validate_declaration_acceptance, on: :after_log + + validate :validate_nulls, on: :after_log + + validate :validate_uprn_exists_if_any_key_address_fields_are_blank, on: :after_log, unless: -> { supported_housing? } + + validate :validate_incomplete_soft_validations, on: :after_log + + validate :validate_correct_intermediate_rent_type, on: :after_log, if: proc { renttype == :intermediate } + validate :validate_correct_affordable_rent_type, on: :after_log, if: proc { renttype == :affordable } + + def self.question_for_field(field) + QUESTIONS[field] + end + + def valid? + return @valid if @valid + + errors.clear + + return @valid = 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 + + @valid = errors.blank? + end + + def blank_row? + attribute_set + .to_hash + .reject { |k, _| %w[bulk_upload block_log_creation field_blank].include?(k) } + .values + .reject(&:blank?) + .compact + .empty? + end + + def log + @log ||= LettingsLog.new(attributes_for_log) + end + + def block_log_creation! + self.block_log_creation = true + end + + def block_log_creation? + block_log_creation + end + + def tenant_code + field_13 + end + + def property_ref + field_14 + end + + def log_already_exists? + @log_already_exists ||= LettingsLog + .where(status: %w[not_started in_progress completed]) + .exists?(duplicate_check_fields.index_with { |field| log.public_send(field) }) + end + + def spreadsheet_duplicate_hash + attributes.slice( + "field_1", # owning org + "field_7", # startdate + "field_8", # startdate + "field_9", # startdate + "field_13", # tenancycode + !general_needs? ? location_field.to_s : nil, # location + !supported_housing? ? "field_23" : nil, # postcode + !supported_housing? ? "field_24" : nil, # postcode + "field_46", # age1 + "field_47", # sex1 + "field_50", # ecstat1 + "field_132", # tcharge + ) + 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_declaration_acceptance + unless field_45 == 1 + errors.add(:field_45, I18n.t("validations.declaration.missing"), category: :setup) + end + end + + def validate_valid_radio_option + log.attributes.each do |question_id, _v| + question = log.form.get_question(question_id, log) + + 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] || [] + + fields.each do |field| + if setup_question?(question) + errors.add(field, I18n.t("validations.invalid_option", question: QUESTIONS[field]), category: :setup) + else + errors.add(field, I18n.t("validations.invalid_option", question: QUESTIONS[field])) + end + end + end + end + + def validate_created_by_exists + return if field_3.blank? + + unless created_by + errors.add(:field_3, "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_3, "User must be related to owning organisation or managing organisation") + end + + def created_by + @created_by ||= User.where("lower(email) = ?", field_3&.downcase).first + end + + def validate_uprn_exists_if_any_key_address_fields_are_blank + if field_18.blank? && (field_19.blank? || field_21.blank?) + errors.add(:field_18, I18n.t("validations.not_answered", question: "UPRN")) + 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| 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 duplicate_check_fields + [ + "startdate", + "age1", + "sex1", + "ecstat1", + "owning_organisation", + "tcharge", + !supported_housing? ? "postcode_full" : nil, + !general_needs? ? "location" : nil, + "tenancycode", + log.chcharge.present? ? "chcharge" : nil, + ].compact + end + + def validate_needs_type_present + if field_4.blank? + errors.add(:field_4, I18n.t("validations.not_answered", question: "needs type"), category: :setup) + end + end + + def start_date + return if field_7.blank? || field_8.blank? || field_9.blank? + + Date.parse("20#{field_9.to_s.rjust(2, '0')}-#{field_8}-#{field_7}") + rescue StandardError + nil + end + + def validate_no_and_dont_know_disabled_needs_conjunction + if field_87 == 1 && field_88 == 1 + errors.add(:field_87, I18n.t("validations.household.housingneeds.no_and_dont_know_disabled_needs_conjunction")) + errors.add(:field_88, I18n.t("validations.household.housingneeds.no_and_dont_know_disabled_needs_conjunction")) + end + end + + def validate_dont_know_disabled_needs_conjunction + if field_88 == 1 && [field_83, field_84, field_85, field_86].count(1).positive? + %i[field_88 field_83 field_84 field_85 field_86].each do |field| + errors.add(field, I18n.t("validations.household.housingneeds.dont_know_disabled_needs_conjunction")) if send(field) == 1 + end + end + end + + def validate_no_disabled_needs_conjunction + if field_87 == 1 && [field_83, field_84, field_85, field_86].count(1).positive? + %i[field_87 field_83 field_84 field_85 field_86].each do |field| + errors.add(field, I18n.t("validations.household.housingneeds.no_disabled_needs_conjunction")) if send(field) == 1 + end + end + end + + def validate_only_one_housing_needs_type + if [field_83, field_84, field_85].count(1) > 1 + %i[field_83 field_84 field_85].each do |field| + errors.add(field, I18n.t("validations.household.housingneeds_type.only_one_option_permitted")) if send(field) == 1 + end + end + end + + def validate_no_housing_needs_questions_answered + if [field_83, field_84, field_85, field_86, field_87, field_88].all?(&:blank?) + errors.add(:field_87, I18n.t("validations.not_answered", question: "anybody with disabled access needs")) + errors.add(:field_86, I18n.t("validations.not_answered", question: "other access needs")) + %i[field_83 field_84 field_85].each do |field| + errors.add(field, I18n.t("validations.not_answered", question: "disabled access needs type")) + end + end + end + + def validate_reasonable_preference_homeless + reason_fields = %i[field_111 field_112 field_113 field_114 field_115] + if field_110 == 1 && reason_fields.all? { |field| attributes[field.to_s].blank? } + reason_fields.each do |field| + errors.add(field, I18n.t("validations.not_answered", question: "reason for reasonable preference")) + end + end + end + + def validate_condition_effects + illness_option_fields = %i[field_98 field_92 field_95 field_90 field_91 field_93 field_94 field_97 field_96 field_99] + if household_no_illness? + illness_option_fields.each do |field| + if attributes[field.to_s] == 1 + errors.add(field, I18n.t("validations.household.condition_effects.no_choices")) + end + end + elsif illness_option_fields.all? { |field| attributes[field.to_s].blank? } + illness_option_fields.each do |field| + errors.add(field, I18n.t("validations.not_answered", question: "how is person affected by condition or illness")) + end + end + end + + def validate_lettings_allocation + if cbl.blank? && cap.blank? && chr.blank? + errors.add(:field_116, I18n.t("validations.not_answered", question: "was the letting made under the Choice-Based Lettings (CBL)?")) + errors.add(:field_117, I18n.t("validations.not_answered", question: "was the letting made under the Common Allocation Policy (CAP)?")) + errors.add(:field_118, I18n.t("validations.not_answered", question: "was the letting made under the Common Housing Register (CHR)?")) + end + end + + def household_no_illness? + field_89 != 1 + end + + def validate_lettings_type_matches_bulk_upload + if [1, 3, 5, 7, 9, 11].include?(field_5) && !general_needs? + block_log_creation! + errors.add(:field_4, I18n.t("validations.setup.needstype.lettype_not_supported_housing"), category: :setup) + errors.add(:field_5, I18n.t("validations.setup.lettype.needstype_supported_housing"), category: :setup) + end + + if [2, 4, 6, 8, 10, 12].include?(field_5) && !supported_housing? + block_log_creation! + errors.add(:field_4, I18n.t("validations.setup.needstype.lettype_not_general_needs"), category: :setup) + errors.add(:field_5, I18n.t("validations.setup.lettype.needstype_general_needs"), category: :setup) + end + end + + def validate_leaving_reason_for_renewal + if field_6 == 1 && ![40, 42].include?(field_102) + errors.add(:field_102, I18n.t("validations.household.reason.renewal_reason_needed")) + end + end + + def general_needs? + field_4 == 1 + end + + def supported_housing? + field_4 == 2 + end + + def validate_cannot_be_la_referral_if_general_needs_and_la + if field_119 == 4 && general_needs? && owning_organisation && owning_organisation.la? + errors.add :field_119, I18n.t("validations.household.referral.la_general_needs.prp_referred_by_la") + end + end + + def validate_la_with_local_housing_referral + if field_119 == 3 && owning_organisation && owning_organisation.la? + errors.add(:field_119, I18n.t("validations.household.referral.nominated_by_local_ha_but_la")) + end + end + + def validate_relevant_collection_window + return if start_date.blank? || bulk_upload.form.blank? + + unless bulk_upload.form.valid_start_date_for_form?(start_date) + errors.add(:field_7, 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_8, 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_9, 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_data_types + unless attribute_set["field_5"].value_before_type_cast&.match?(/^\d+\.?0*$/) + errors.add(:field_5, I18n.t("validations.invalid_number", question: "letting type")) + end + 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| + if errors.select { |e| fields.include?(e.attribute) }.none? + question_text = question.error_display_label.presence || "this question" + errors.add(field, I18n.t("validations.not_answered", question: question_text.downcase), category: :setup) if field.present? + end + end + else + fields.each do |field| + unless errors.any? { |e| fields.include?(e.attribute) } + question_text = question.error_display_label.presence || "this question" + errors.add(field, I18n.t("validations.not_answered", question: question_text.downcase)) + end + end + end + end + end + + def validate_related_location_exists + if scheme && location_id.present? && location.nil? && location_field.present? + block_log_creation! + errors.add(location_field, "#{location_or_scheme.capitalize} code must relate to a #{location_or_scheme} that is owned by the owning organisation or managing organisation", category: :setup) + end + end + + def validate_location_data_given + if supported_housing? && location_id.blank? && location_field.present? + block_log_creation! + errors.add(location_field, I18n.t("validations.not_answered", question: "#{location_or_scheme} code"), category: :setup) + end + end + + def validate_related_scheme_exists + if scheme_id.present? && scheme_field.present? && owning_organisation.present? && managing_organisation.present? && scheme.nil? + block_log_creation! + errors.add(scheme_field, "This #{scheme_or_management_group} code does not belong to the owning organisation or managing organisation", category: :setup) + end + end + + def validate_scheme_data_given + if supported_housing? && scheme_field.present? && scheme_id.blank? + block_log_creation! + errors.add(scheme_field, I18n.t("validations.not_answered", question: "#{scheme_or_management_group} code"), category: :setup) + end + 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 managing organisation does not have a relationship with the owning organisation", category: :setup) + end + end + end + + def validate_managing_org_exists + if managing_organisation.nil? + block_log_creation! + + if errors[:field_2].blank? + errors.add(:field_2, "The managing organisation code is incorrect", category: :setup) + end + end + end + + def validate_managing_org_data_given + if field_2.blank? + block_log_creation! + errors.add(:field_2, "The managing organisation code is incorrect", category: :setup) + 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_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_data_given + if field_1.blank? + block_log_creation! + errors.add(:field_1, I18n.t("validations.not_answered", question: "owning organisation"), category: :setup) + 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_correct_intermediate_rent_type + if field_11.blank? || ![1, 2, 3].include?(field_11.to_i) + errors.add(:field_11, I18n.t("validations.not_answered", question: "intermediate rent type"), category: :setup) + end + end + + def validate_correct_affordable_rent_type + if field_10.blank? || ![1, 2, 3].include?(field_10.to_i) + errors.add(:field_10, I18n.t("validations.not_answered", question: "is this a London Affordable Rent letting"), category: :setup) + end + end + + def setup_question?(question) + log.form.setup_sections[0].subsections[0].questions.include?(question) + 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_organisation + errors.add(:field_7, error_message) # startdate + errors.add(:field_8, error_message) # startdate + errors.add(:field_9, error_message) # startdate + errors.add(:field_13, error_message) # tenancycode + errors.add(location_field, error_message) if !general_needs? && location_field.present? # location + errors.add(:field_16, error_message) if !general_needs? && location_field.blank? # add to Scheme field as unclear whether log uses New or Old CORE ids + errors.add(:field_23, error_message) unless supported_housing? # postcode_full + errors.add(:field_24, error_message) unless supported_housing? # postcode_full + errors.add(:field_25, error_message) unless supported_housing? # la + errors.add(:field_46, error_message) # age1 + errors.add(:field_47, error_message) # sex1 + errors.add(:field_50, error_message) # ecstat1 + errors.add(:field_132, error_message) # tcharge + errors.add(:field_127, error_message) if log.chcharge.present? # chcharge + errors.add(:field_125, error_message) unless general_needs? # household_charge + end + end + + def field_mapping_for_errors + { + lettype: [:field_5], + tenancycode: [:field_13], + postcode_known: %i[field_25 field_23 field_24], + postcode_full: %i[field_25 field_23 field_24], + la: %i[field_25], + owning_organisation: [:field_1], + managing_organisation: [:field_2], + owning_organisation_id: [:field_1], + managing_organisation_id: [:field_2], + renewal: [:field_6], + scheme_id: (scheme_field.present? ? [scheme_field] : nil), + scheme: (scheme_field.present? ? [scheme_field] : nil), + location_id: (location_field.present? ? [location_field] : nil), + location: (location_field.present? ? [location_field] : nil), + created_by: [:field_3], + needstype: [:field_4], + rent_type: %i[field_5 field_10 field_11], + startdate: %i[field_7 field_8 field_9], + unittype_gn: %i[field_29], + builtype: %i[field_30], + wchair: %i[field_31], + beds: %i[field_32], + joint: %i[field_39], + startertenancy: %i[field_40], + tenancy: %i[field_41], + tenancyother: %i[field_42], + tenancylength: %i[field_43], + declaration: %i[field_45], + + age1_known: %i[field_46], + age1: %i[field_46], + age2_known: %i[field_52], + age2: %i[field_52], + age3_known: %i[field_56], + age3: %i[field_56], + age4_known: %i[field_60], + age4: %i[field_60], + age5_known: %i[field_64], + age5: %i[field_64], + age6_known: %i[field_68], + age6: %i[field_68], + age7_known: %i[field_72], + age7: %i[field_72], + age8_known: %i[field_76], + age8: %i[field_76], + + sex1: %i[field_47], + sex2: %i[field_53], + sex3: %i[field_57], + sex4: %i[field_61], + sex5: %i[field_65], + sex6: %i[field_69], + sex7: %i[field_73], + sex8: %i[field_77], + + ethnic_group: %i[field_48], + ethnic: %i[field_48], + national: %i[field_49], + + relat2: %i[field_51], + relat3: %i[field_55], + relat4: %i[field_59], + relat5: %i[field_63], + relat6: %i[field_67], + relat7: %i[field_71], + relat8: %i[field_75], + + ecstat1: %i[field_50], + ecstat2: %i[field_54], + ecstat3: %i[field_58], + ecstat4: %i[field_62], + ecstat5: %i[field_66], + ecstat6: %i[field_70], + ecstat7: %i[field_74], + ecstat8: %i[field_78], + + armedforces: %i[field_79], + leftreg: %i[field_80], + reservist: %i[field_81], + preg_occ: %i[field_82], + housingneeds: %i[field_82], + + illness: %i[field_89], + + layear: %i[field_100], + waityear: %i[field_101], + reason: %i[field_102], + reasonother: %i[field_103], + prevten: %i[field_104], + homeless: %i[field_105], + + prevloc: %i[field_109], + previous_la_known: %i[field_109], + ppcodenk: %i[field_106], + ppostcode_full: %i[field_107 field_108], + + reasonpref: %i[field_110], + rp_homeless: %i[field_111], + rp_insan_unsat: %i[field_112], + rp_medwel: %i[field_113], + rp_hardship: %i[field_114], + rp_dontknow: %i[field_115], + + cbl: %i[field_116], + chr: %i[field_118], + cap: %i[field_117], + letting_allocation: %i[field_116 field_117 field_118], + + referral: %i[field_119], + + net_income_known: %i[field_120], + earnings: %i[field_122], + incfreq: %i[field_121], + hb: %i[field_123], + benefits: %i[field_124], + + period: %i[field_126], + brent: %i[field_128], + scharge: %i[field_129], + pscharge: %i[field_130], + supcharg: %i[field_131], + tcharge: %i[field_132], + chcharge: %i[field_127], + household_charge: %i[field_125], + hbrentshortfall: %i[field_133], + tshortfall: %i[field_134], + + unitletas: %i[field_26], + rsnvac: %i[field_27], + sheltered: %i[field_44], + + illness_type_1: %i[field_98], + illness_type_2: %i[field_92], + illness_type_3: %i[field_95], + illness_type_4: %i[field_90], + illness_type_5: %i[field_91], + illness_type_6: %i[field_93], + illness_type_7: %i[field_94], + illness_type_8: %i[field_97], + illness_type_9: %i[field_96], + illness_type_10: %i[field_99], + + irproduct_other: %i[field_12], + + offered: %i[field_28], + propcode: %i[field_14], + + majorrepairs: %i[field_36 field_37 field_38], + mrcdate: %i[field_36 field_37 field_38], + + voiddate: %i[field_33 field_34 field_35], + + uprn: [:field_18], + address_line1: [:field_19], + address_line2: [:field_20], + town_or_city: [:field_21], + county: [:field_22], + }.compact + end + + def attribute_set + @attribute_set ||= instance_variable_get(:@attributes) + end + + def questions + @questions ||= log.form.subsections.flat_map { |ss| ss.applicable_questions(log) } + end + + def attributes_for_log + attributes = {} + + attributes["lettype"] = field_5 + attributes["tenancycode"] = field_13 + attributes["la"] = field_25 + attributes["postcode_known"] = postcode_known + attributes["postcode_full"] = postcode_full + attributes["owning_organisation"] = owning_organisation + attributes["managing_organisation"] = managing_organisation + attributes["renewal"] = renewal + attributes["scheme"] = scheme + attributes["location"] = location + attributes["created_by"] = created_by || bulk_upload.user + attributes["needstype"] = field_4 + attributes["rent_type"] = rent_type + attributes["startdate"] = startdate + attributes["unittype_gn"] = field_29 + attributes["builtype"] = field_30 + attributes["wchair"] = field_31 + attributes["beds"] = field_32 + attributes["joint"] = field_39 + attributes["startertenancy"] = field_40 + attributes["tenancy"] = field_41 + attributes["tenancyother"] = field_42 + attributes["tenancylength"] = field_43 + attributes["declaration"] = field_45 + + attributes["age1_known"] = age1_known? + attributes["age1"] = field_46 if attributes["age1_known"]&.zero? && field_46&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age2_known"] = age2_known? + attributes["age2"] = field_52 if attributes["age2_known"]&.zero? && field_52&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age3_known"] = age3_known? + attributes["age3"] = field_56 if attributes["age3_known"]&.zero? && field_56&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age4_known"] = age4_known? + attributes["age4"] = field_60 if attributes["age4_known"]&.zero? && field_60&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age5_known"] = age5_known? + attributes["age5"] = field_64 if attributes["age5_known"]&.zero? && field_64&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age6_known"] = age6_known? + attributes["age6"] = field_68 if attributes["age6_known"]&.zero? && field_68&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age7_known"] = age7_known? + attributes["age7"] = field_72 if attributes["age7_known"]&.zero? && field_72&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["age8_known"] = age8_known? + attributes["age8"] = field_76 if attributes["age8_known"]&.zero? && field_76&.match(/\A\d{1,3}\z|\AR\z/) + + attributes["sex1"] = field_47 + attributes["sex2"] = field_53 + attributes["sex3"] = field_57 + attributes["sex4"] = field_61 + attributes["sex5"] = field_65 + attributes["sex6"] = field_69 + attributes["sex7"] = field_73 + attributes["sex8"] = field_77 + + attributes["ethnic_group"] = ethnic_group_from_ethnic + attributes["ethnic"] = field_48 + attributes["national"] = field_49 + + attributes["relat2"] = field_51 + attributes["relat3"] = field_55 + attributes["relat4"] = field_59 + attributes["relat5"] = field_63 + attributes["relat6"] = field_67 + attributes["relat7"] = field_71 + attributes["relat8"] = field_75 + + attributes["ecstat1"] = field_50 + attributes["ecstat2"] = field_54 + attributes["ecstat3"] = field_58 + attributes["ecstat4"] = field_62 + attributes["ecstat5"] = field_66 + attributes["ecstat6"] = field_70 + attributes["ecstat7"] = field_74 + attributes["ecstat8"] = field_78 + + 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["details_known_7"] = details_known?(7) + attributes["details_known_8"] = details_known?(8) + + attributes["armedforces"] = field_79 + attributes["leftreg"] = leftreg + attributes["reservist"] = field_81 + + attributes["preg_occ"] = field_82 + + attributes["housingneeds"] = housingneeds + attributes["housingneeds_type"] = housingneeds_type + attributes["housingneeds_other"] = housingneeds_other + + attributes["illness"] = field_89 + + attributes["layear"] = field_100 + attributes["waityear"] = field_101 + attributes["reason"] = field_102 + attributes["reasonother"] = field_103 + attributes["prevten"] = field_104 + attributes["homeless"] = field_105 + + attributes["prevloc"] = prevloc + attributes["previous_la_known"] = previous_la_known + attributes["ppcodenk"] = ppcodenk + attributes["ppostcode_full"] = ppostcode_full + + attributes["reasonpref"] = field_110 + attributes["rp_homeless"] = field_111 + attributes["rp_insan_unsat"] = field_112 + attributes["rp_medwel"] = field_113 + attributes["rp_hardship"] = field_114 + attributes["rp_dontknow"] = field_115 + + attributes["cbl"] = cbl + attributes["chr"] = chr + attributes["cap"] = cap + attributes["letting_allocation_unknown"] = letting_allocation_unknown + + attributes["referral"] = field_119 + + attributes["net_income_known"] = net_income_known + attributes["earnings"] = earnings + attributes["incfreq"] = field_121 + attributes["hb"] = field_123 + attributes["benefits"] = field_124 + + attributes["period"] = field_126 + attributes["brent"] = field_128 + attributes["scharge"] = field_129 + attributes["pscharge"] = field_130 + attributes["supcharg"] = field_131 + attributes["tcharge"] = field_132 + attributes["chcharge"] = field_127 + attributes["is_carehome"] = field_127.present? ? 1 : 0 + attributes["household_charge"] = supported_housing? ? field_125 : nil + attributes["hbrentshortfall"] = field_133 + attributes["tshortfall_known"] = tshortfall_known + attributes["tshortfall"] = field_134 + + attributes["hhmemb"] = hhmemb + + attributes["unitletas"] = field_26 + attributes["rsnvac"] = rsnvac + attributes["sheltered"] = field_44 + + attributes["illness_type_1"] = field_98 + attributes["illness_type_2"] = field_92 + attributes["illness_type_3"] = field_95 + attributes["illness_type_4"] = field_90 + attributes["illness_type_5"] = field_91 + attributes["illness_type_6"] = field_93 + attributes["illness_type_7"] = field_94 + attributes["illness_type_8"] = field_97 + attributes["illness_type_9"] = field_96 + attributes["illness_type_10"] = field_99 + + attributes["irproduct_other"] = field_12 + + attributes["offered"] = field_28 + + attributes["propcode"] = field_14 + + attributes["majorrepairs"] = majorrepairs + + attributes["mrcdate"] = mrcdate + + attributes["voiddate"] = voiddate + + attributes["first_time_property_let_as_social_housing"] = first_time_property_let_as_social_housing + + attributes["uprn_known"] = field_18.present? ? 1 : 0 + attributes["uprn_confirmed"] = 1 if field_18.present? + attributes["skip_update_uprn_confirmed"] = true + attributes["uprn"] = field_18 + attributes["address_line1"] = field_19 + attributes["address_line2"] = field_20 + attributes["town_or_city"] = field_21 + attributes["county"] = field_22 + + attributes + end + + def postcode_known + if postcode_full.present? + 1 + elsif field_25.present? + 0 + end + end + + def postcode_full + "#{field_23} #{field_24}" if field_23 && field_24 + end + + def owning_organisation + Organisation.find_by_id_on_multiple_fields(field_1) + end + + def managing_organisation + Organisation.find_by_id_on_multiple_fields(field_2) + end + + def renewal + case field_6 + when 1 + 1 + when 2 + 0 + else + field_6 + end + end + + def rsnvac + field_27 + end + + def scheme + return if scheme_id.nil? || owning_organisation.nil? || managing_organisation.nil? + + @scheme ||= Scheme.where(id: (owning_organisation.owned_schemes + managing_organisation.owned_schemes).map(&:id)).find_by_id_on_multiple_fields(scheme_id, location_id) + end + + def location + return if scheme.nil? + + @location ||= scheme.locations.find_by_id_on_multiple_fields(location_id) + end + + def log_uses_new_scheme_id? + field_16&.start_with?("S") + end + + def log_uses_old_scheme_id? + field_16.present? && !field_16.start_with?("S") + end + + def scheme_field + return :field_16 if log_uses_new_scheme_id? + return :field_15 if log_uses_old_scheme_id? + end + + def scheme_id + return field_16 if log_uses_new_scheme_id? + return field_15 if log_uses_old_scheme_id? + end + + def location_field + return :field_17 if log_uses_new_scheme_id? + return :field_16 if log_uses_old_scheme_id? + end + + def location_id + return field_17 if log_uses_new_scheme_id? + return field_16 if log_uses_old_scheme_id? + end + + def scheme_or_management_group + log_uses_new_scheme_id? ? "scheme" : "management group" + end + + def location_or_scheme + log_uses_new_scheme_id? ? "location" : "scheme" + end + + def renttype + case field_5 + when 1, 2, 3, 4 + :social + when 5, 6, 7, 8 + :affordable + when 9, 10, 11, 12 + :intermediate + end + end + + def rent_type + case renttype + when :social + LettingsLog::RENT_TYPE[:social_rent] + when :affordable + case field_10 + when 1 + LettingsLog::RENT_TYPE[:london_affordable_rent] + when 2, 3 + LettingsLog::RENT_TYPE[:affordable_rent] + end + when :intermediate + case field_11 + when 1 + LettingsLog::RENT_TYPE[:rent_to_buy] + when 2 + LettingsLog::RENT_TYPE[:london_living_rent] + when 3 + LettingsLog::RENT_TYPE[:other_intermediate_rent_product] + end + end + end + + def startdate + Date.new(field_9 + 2000, field_8, field_7) if field_9.present? && field_8.present? && field_7.present? + rescue Date::Error + Date.new + end + + def ethnic_group_from_ethnic + return nil if field_48.blank? + + case field_48 + 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 age1_known? + return 1 if field_46 == "R" + + 0 + end + + [ + { person: 2, field: :field_52 }, + { person: 3, field: :field_56 }, + { person: 4, field: :field_60 }, + { person: 5, field: :field_64 }, + { person: 6, field: :field_68 }, + { person: 7, field: :field_72 }, + { person: 8, field: :field_76 }, + ].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 details_known?(person_n) + send("person_#{person_n}_present?") ? 0 : 1 + end + + def person_2_present? + field_51.present? || field_52.present? || field_53.present? + end + + def person_3_present? + field_55.present? || field_56.present? || field_57.present? + end + + def person_4_present? + field_59.present? || field_60.present? || field_61.present? + end + + def person_5_present? + field_63.present? || field_64.present? || field_65.present? + end + + def person_6_present? + field_67.present? || field_68.present? || field_69.present? + end + + def person_7_present? + field_71.present? || field_72.present? || field_73.present? + end + + def person_8_present? + field_75.present? || field_76.present? || field_77.present? + end + + def leftreg + field_80 + end + + def housingneeds + if field_87 == 1 + 2 + elsif field_88 == 1 + 3 + elsif field_87.blank? || field_87&.zero? + 1 + end + end + + def housingneeds_type + if field_83 == 1 + 0 + elsif field_84 == 1 + 1 + elsif field_85 == 1 + 2 + else + 3 + end + end + + def housingneeds_other + return 1 if field_86 == 1 + return 0 if [field_83, field_84, field_85].include?(1) + end + + def prevloc + field_109 + end + + def previous_la_known + prevloc.present? ? 1 : 0 + end + + def ppcodenk + case field_106 + when 1 + 0 + when 2 + 1 + end + end + + def ppostcode_full + "#{field_107} #{field_108}".strip.gsub(/\s+/, " ") + end + + def cbl + case field_116 + when 2 + 0 + when 1 + 1 + end + end + + def chr + case field_118 + when 2 + 0 + when 1 + 1 + end + end + + def cap + case field_117 + when 2 + 0 + when 1 + 1 + end + end + + def letting_allocation_unknown + [cbl, chr, cap].all?(0) ? 1 : 0 + end + + def net_income_known + case field_120 + when 1 + 0 + when 2 + 1 + when 3 + 2 + end + end + + def earnings + field_122.round if field_122.present? + end + + def tshortfall_known + field_133 == 1 ? 0 : 1 + end + + def hhmemb + [ + person_2_present?, + person_3_present?, + person_4_present?, + person_5_present?, + person_6_present?, + person_7_present?, + person_8_present?, + ].count(true) + 1 + end + + def majorrepairs + mrcdate.present? ? 1 : 0 + end + + def mrcdate + Date.new(field_38 + 2000, field_37, field_36) if field_38.present? && field_37.present? && field_36.present? + rescue Date::Error + Date.new + end + + def voiddate + Date.new(field_35 + 2000, field_34, field_33) if field_35.present? && field_34.present? && field_33.present? + rescue Date::Error + Date.new + end + + def first_time_property_let_as_social_housing + case rsnvac + when 15, 16, 17 + 1 + else + 0 + end + end +end diff --git a/spec/services/bulk_upload/lettings/year2024/csv_parser_spec.rb b/spec/services/bulk_upload/lettings/year2024/csv_parser_spec.rb new file mode 100644 index 000000000..4e078333a --- /dev/null +++ b/spec/services/bulk_upload/lettings/year2024/csv_parser_spec.rb @@ -0,0 +1,226 @@ +require "rails_helper" + +RSpec.describe BulkUpload::Lettings::Year2024::CsvParser do + subject(:service) { described_class.new(path:) } + + let(:file) { Tempfile.new } + let(:path) { file.path } + let(:log) { build(:lettings_log, :completed) } + + 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::LettingsLogToCsv.new(log:).default_2024_field_numbers_row) + file.write(BulkUpload::LettingsLogToCsv.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_13).to eql(log.tenancycode) + end + end + + context "when parsing csv with headers with extra rows" do + before do + file.write("Section\n") + 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::LettingsLogToCsv.new(log:).default_2024_field_numbers_row) + file.write(BulkUpload::LettingsLogToCsv.new(log:).to_2024_csv_row) + file.rewind + end + + it "returns correct offsets" do + expect(service.row_offset).to eq(8) + expect(service.col_offset).to eq(1) + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_13).to eql(log.tenancycode) + 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::LettingsLogToCsv.new(log:).default_2024_field_numbers_row(seed:)) + file.write(BulkUpload::LettingsLogToCsv.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_13).to eql(log.tenancycode) + end + end + + context "when parsing csv with extra invalid headers" do + let(:seed) { rand } + let(:log_to_csv) { BulkUpload::LettingsLogToCsv.new(log:) } + let(:field_numbers) { log_to_csv.default_2024_field_numbers + %w[invalid_field_number] } + let(:field_values) { log_to_csv.to_2024_row + %w[value_for_invalid_field_number] } + + 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(log_to_csv.custom_field_numbers_row(seed:, field_numbers:)) + file.write(log_to_csv.to_custom_csv_row(seed:, field_values:)) + file.rewind + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_13).to eql(log.tenancycode) + end + + it "counts the number of valid field numbers correctly" do + expect(service).to be_correct_field_count + end + end + + context "when parsing csv without headers" do + before do + file.write(BulkUpload::LettingsLogToCsv.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_13).to eql(log.tenancycode) + end + end + + context "when parsing with BOM aka byte order mark" do + let(:bom) { "\uFEFF" } + + before do + file.write(bom) + file.write(BulkUpload::LettingsLogToCsv.new(log:, col_offset: 0).to_2024_csv_row) + file.rewind + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_13).to eql(log.tenancycode) + end + end + + context "when an invalid byte sequence" do + let(:invalid_sequence) { "\x81" } + + before do + file.write(invalid_sequence) + file.write(BulkUpload::LettingsLogToCsv.new(log:, col_offset: 0).to_2024_csv_row) + file.rewind + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_13).to eql(log.tenancycode) + 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::LettingsLogToCsv.new(log:).default_2024_field_numbers_row) + file.write(BulkUpload::LettingsLogToCsv.new(log:).to_2024_csv_row) + file.rewind + end + + it "parses csv correctly" do + expect(service.row_parsers[0].field_13).to eql(log.tenancycode) + end + end + + describe "#column_for_field", aggregate_failures: true do + context "when with headers using default ordering" 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::LettingsLogToCsv.new(log:).default_2024_field_numbers_row) + file.write(BulkUpload::LettingsLogToCsv.new(log:).to_2024_csv_row) + file.rewind + end + + it "returns correct column" do + expect(service.column_for_field("field_5")).to eql("B") + expect(service.column_for_field("field_22")).to eql("EL") + end + end + + context "when without headers using default ordering" do + before do + file.write(BulkUpload::LettingsLogToCsv.new(log:, col_offset: 0).to_2024_csv_row) + file.rewind + end + + it "returns correct column" do + expect(service.column_for_field("field_5")).to eql("A") + expect(service.column_for_field("field_22")).to eql("EK") + end + end + + context "when with headers using custom ordering" do + let(:seed) { 123 } + + 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::LettingsLogToCsv.new(log:).default_2024_field_numbers_row(seed:)) + file.write(BulkUpload::LettingsLogToCsv.new(log:).to_2024_csv_row(seed:)) + file.rewind + end + + it "returns correct column" do + expect(service.column_for_field("field_5")).to eql("N") + expect(service.column_for_field("field_22")).to eql("O") + expect(service.column_for_field("field_26")).to eql("B") + expect(service.column_for_field("field_25")).to eql("EF") + end + end + end +end diff --git a/spec/services/bulk_upload/lettings/year2024/row_parser_spec.rb b/spec/services/bulk_upload/lettings/year2024/row_parser_spec.rb new file mode 100644 index 000000000..d37295441 --- /dev/null +++ b/spec/services/bulk_upload/lettings/year2024/row_parser_spec.rb @@ -0,0 +1,2660 @@ +require "rails_helper" + +RSpec.describe BulkUpload::Lettings::Year2024::RowParser do + subject(:parser) { described_class.new(attributes) } + + let(:now) { Time.zone.local(2024, 4, 5) } + + let(:attributes) { { bulk_upload: } } + let(:bulk_upload) { create(:bulk_upload, :lettings, user:, needstype: nil, year: 2024) } + let(:user) { create(:user, organisation: owning_org) } + + let(:owning_org) { create(:organisation, :with_old_visible_id) } + let(:managing_org) { create(:organisation, :with_old_visible_id) } + let(:scheme) { create(:scheme, :with_old_visible_id, owning_organisation: owning_org) } + let(:location) { create(:location, :with_old_visible_id, scheme:) } + + let(:setup_section_params) do + { + bulk_upload:, + field_1: owning_org.old_visible_id, + field_2: managing_org.old_visible_id, + field_4: "1", + field_5: "1", + field_6: "2", + field_7: now.day.to_s, + field_8: now.month.to_s, + field_9: now.strftime("%g"), + field_45: "1", + } + end + + before do + allow(FormHandler.instance).to receive(:lettings_in_crossover_period?).and_return(true) + create(:organisation_relationship, parent_organisation: owning_org, child_organisation: managing_org) + + LaRentRange.create!( + ranges_rent_id: "1", + la: "E09000008", + beds: 1, + lettype: 3, + soft_min: 12.41, + soft_max: 118.85, + hard_min: 9.87, + hard_max: 200.99, + start_year: 2024, + ) + end + + around do |example| + Timecop.freeze(Date.new(2024, 10, 1)) do + FormHandler.instance.use_real_forms! + example.run + end + Timecop.return + 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 the only populated fields are whitespace" do + before do + parser.field_18 = " " + end + + it "returns true" do + expect(parser).to be_blank_row + end + end + + context "when any field is populated with something other than whitespace" do + before do + parser.field_1 = "1" + end + + it "returns false" do + expect(parser).not_to be_blank_row + 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_134: 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 testing valid/invalid attributes" do + let(:valid_attributes) do + { + bulk_upload:, + field_5: "1", + field_13: "123", + field_7: now.day.to_s, + field_8: now.month.to_s, + field_9: now.strftime("%g"), + field_23: "EC1N", + field_24: "2TD", + field_1: owning_org.old_visible_id, + field_2: managing_org.old_visible_id, + field_11: "1", + field_6: "2", + field_29: "2", + field_30: "1", + field_31: "1", + field_32: "1", + field_39: "2", + field_40: "1", + field_41: "2", + field_45: "1", + + field_46: "42", + field_52: "41", + field_56: "20", + field_60: "18", + field_64: "16", + field_68: "14", + field_72: "12", + field_76: "20", + + field_47: "F", + field_53: "M", + field_57: "F", + field_61: "M", + field_65: "F", + field_69: "M", + field_73: "F", + field_77: "M", + + field_48: "17", + field_49: "18", + + field_51: "P", + field_55: "C", + field_59: "X", + field_63: "R", + field_67: "C", + field_71: "C", + field_75: "X", + + field_50: "1", + field_54: "2", + field_58: "6", + field_62: "7", + field_66: "8", + field_70: "9", + field_74: "0", + field_78: "10", + + field_79: "1", + field_80: "4", + field_81: "1", + + field_82: "1", + + field_83: "1", + field_84: "0", + field_85: "0", + field_86: "1", + field_87: "0", + + field_89: "2", + + field_100: "5", + field_101: "2", + field_102: "31", + field_104: "3", + field_105: "11", + + field_106: "1", + field_107: "EC1N", + field_108: "2TD", + + field_110: "1", + field_111: "1", + field_112: "", + field_113: "1", + field_114: "", + field_115: "", + + field_116: "1", + field_117: "2", + field_118: "2", + + field_119: "2", + + field_120: "1", + field_122: "2000", + field_121: "2", + field_123: "1", + field_124: "1", + + field_126: "4", + field_128: "1234.56", + field_129: "43.32", + field_130: "13.14", + field_131: "101.11", + field_132: "1500.19", + field_133: "1", + field_134: "234.56", + + field_27: "15", + field_28: "0", + field_33: now.day.to_s, + field_34: now.month.to_s, + field_35: now.strftime("%g"), + + field_4: "1", + + field_18: "12", + } + end + + context "when valid row" do + before do + allow(FeatureToggle).to receive(:bulk_upload_duplicate_log_check_enabled?).and_return(true) + end + + let(:attributes) { valid_attributes } + + it "returns true" do + expect(parser).to be_valid + end + + xit "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 + + context "when a general needs log already exists in the db" do + let(:attributes) { { bulk_upload:, field_4: "1" } } + + 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_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_13, # tenancycode + :field_23, # postcode_full + :field_24, # postcode_full + :field_25, # postcode_full + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_132, # tcharge + ].each do |field| + expect(parser.errors[field]).to include(error_message) + end + + expect(parser.errors[:field_17]).not_to include(error_message) + end + end + + context "when a supported housing log already exists in the db" do + let(:attributes) { { bulk_upload:, field_4: "2" } } + + 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 the fields used to determine duplicates" do + parser.valid? + + error_message = "This is a duplicate log" + + [ + :field_1, # owning_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_13, # tenancycode + :field_16, # location + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_132, # tcharge + ].each do |field| + expect(parser.errors[field]).to include(error_message) + end + + expect(parser.errors[:field_23]).not_to include(error_message) + expect(parser.errors[:field_24]).not_to include(error_message) + expect(parser.errors[:field_25]).not_to include(error_message) + end + end + + context "with old core scheme and location ids" do + context "when a supported housing log already exists in the db" do + let(:attributes) { { bulk_upload:, field_4: "2", field_16: "123" } } + + 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 the fields used to determine duplicates" do + parser.valid? + + error_message = "This is a duplicate log" + + [ + :field_1, # owning_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_13, # tenancycode + :field_16, # location + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_132, # tcharge + ].each do |field| + expect(parser.errors[field]).to include(error_message) + end + + expect(parser.errors[:field_23]).not_to include(error_message) + expect(parser.errors[:field_24]).not_to include(error_message) + expect(parser.errors[:field_25]).not_to include(error_message) + end + end + + context "when a supported housing log with chcharges already exists in the db" do + let(:bulk_upload) { create(:bulk_upload, :lettings, user:, needstype: 2) } + let(:attributes) do + valid_attributes.merge({ field_15: scheme.old_visible_id, + field_4: "2", + field_5: "2", + field_16: location.old_visible_id, + field_1: owning_org.old_visible_id, + field_125: 0, + field_44: 4, + field_127: "88" }) + end + + 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 the fields used to determine duplicates" do + parser.valid? + + error_message = "This is a duplicate log" + + [ + :field_1, # owning_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_13, # tenancycode + :field_16, # location + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_127, # chcharge + :field_125, # household_charge + ].each do |field| + expect(parser.errors[field]).to include(error_message) + end + + expect(parser.errors[:field_23]).not_to include(error_message) + expect(parser.errors[:field_24]).not_to include(error_message) + expect(parser.errors[:field_25]).not_to include(error_message) + end + end + + context "when a supported housing log different chcharges already exists in the db" do + let(:bulk_upload) { create(:bulk_upload, :lettings, user:, needstype: 2) } + let(:attributes) do + valid_attributes.merge({ field_15: scheme.old_visible_id, + field_4: "2", + field_5: "2", + field_16: location.old_visible_id, + field_1: owning_org.old_visible_id, + field_125: 0, + field_44: 4, + field_127: "88" }) + end + let(:attributes_too) do + valid_attributes.merge({ field_15: scheme.old_visible_id, + field_4: "2", + field_5: "2", + field_16: location.old_visible_id, + field_1: owning_org.old_visible_id, + field_125: 0, + field_44: 4, + field_127: "98" }) + end + let(:parser_too) { described_class.new(attributes_too) } + + before do + parser.log.save! + parser.instance_variable_set(:@valid, nil) + end + + it "is a valid row" do + expect(parser_too).to be_valid + end + + it "does not add an error to all the fields used to determine duplicates" do + parser_too.valid? + + error_message = "This is a duplicate log" + + [ + :field_1, # owning_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_13, # tenancycode + :field_16, # location + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_132, # tcharge + ].each do |field| + expect(parser_too.errors[field]).not_to include(error_message) + end + end + end + end + + context "with new core scheme and location ids" do + context "when a supported housing log already exists in the db" do + let(:attributes) { { bulk_upload:, field_4: "2", field_16: "S123" } } + + 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 the fields used to determine duplicates" do + parser.valid? + + error_message = "This is a duplicate log" + + [ + :field_1, # owning_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_13, # tenancycode + :field_17, # location + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_132, # tcharge + ].each do |field| + expect(parser.errors[field]).to include(error_message) + end + + expect(parser.errors[:field_23]).not_to include(error_message) + expect(parser.errors[:field_24]).not_to include(error_message) + expect(parser.errors[:field_25]).not_to include(error_message) + end + end + + context "when a supported housing log with chcharges already exists in the db" do + let(:bulk_upload) { create(:bulk_upload, :lettings, user:, needstype: 2) } + let(:attributes) do + valid_attributes.merge({ field_16: "S#{scheme.id}", + field_4: "2", + field_5: "2", + field_17: location.id, + field_1: owning_org.old_visible_id, + field_125: 0, + field_44: 4, + field_127: "88" }) + end + + 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 the fields used to determine duplicates" do + parser.valid? + + error_message = "This is a duplicate log" + + [ + :field_1, # owning_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_13, # tenancycode + :field_17, # location + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_127, # chcharge + :field_125, # household_charge + ].each do |field| + expect(parser.errors[field]).to include(error_message) + end + + expect(parser.errors[:field_23]).not_to include(error_message) + expect(parser.errors[:field_24]).not_to include(error_message) + expect(parser.errors[:field_25]).not_to include(error_message) + end + end + + context "when a supported housing log different chcharges already exists in the db" do + let(:bulk_upload) { create(:bulk_upload, :lettings, user:, needstype: 2) } + let(:attributes) do + valid_attributes.merge({ field_16: "S#{scheme.id}", + field_4: "2", + field_5: "2", + field_17: location.id, + field_1: owning_org.old_visible_id, + field_125: 0, + field_44: 4, + field_127: "88" }) + end + let(:attributes_too) do + valid_attributes.merge({ field_16: "S#{scheme.id}", + field_4: "2", + field_5: "2", + field_17: location.id, + field_1: owning_org.old_visible_id, + field_125: 0, + field_44: 4, + field_127: "98" }) + end + let(:parser_too) { described_class.new(attributes_too) } + + before do + parser.log.save! + parser.instance_variable_set(:@valid, nil) + end + + it "is a valid row" do + expect(parser_too).to be_valid + end + + it "does not add an error to all the fields used to determine duplicates" do + parser_too.valid? + + error_message = "This is a duplicate log" + + [ + :field_1, # owning_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_13, # tenancycode + :field_17, # location + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_132, # tcharge + ].each do |field| + expect(parser_too.errors[field]).not_to include(error_message) + end + end + end + end + + context "when the rent range validation is triggered but the log has no scheme or location id" do + let(:attributes) do + setup_section_params.merge({ field_15: nil, + field_16: nil, + field_17: nil, + field_128: 300, + field_126: 1, + field_32: 1, + field_4: 1, + field_5: "3", + field_25: "E09000008" }) + end + + it "is not a valid row" do + expect(parser).not_to be_valid + 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_organisation + :field_7, # startdate + :field_8, # startdate + :field_9, # startdate + :field_17, # location + :field_23, # postcode_full + :field_24, # postcode_full + :field_25, # postcode_full + :field_46, # age1 + :field_47, # sex1 + :field_50, # ecstat1 + :field_132, # tcharge + ].each do |field| + expect(parser.errors[field]).to be_blank + end + end + end + end + + context "when valid row with valid decimal (integer) field_5" do + before do + allow(FeatureToggle).to receive(:bulk_upload_duplicate_log_check_enabled?).and_return(true) + end + + let(:attributes) { valid_attributes.merge(field_5: "1.00") } + + it "returns true" do + expect(parser).to be_valid + end + end + + context "when valid row with invalid decimal (non-integer) field_5" do + before do + allow(FeatureToggle).to receive(:bulk_upload_duplicate_log_check_enabled?).and_return(true) + end + + let(:attributes) { valid_attributes.merge(field_5: "1.56") } + + it "returns false" do + expect(parser).not_to be_valid + end + end + end + + describe "#validate_nulls" do + context "when non-setup questions are null" do + let(:attributes) { setup_section_params.merge({ field_18: "", field_19: "", field_21: "" }) } + + it "fetches the question's check_answer_label if it exists, otherwise it gets the question's header" do + parser.valid? + expect(parser.errors[:field_19]).to eql(["You must answer address line 1"]) + expect(parser.errors[:field_21]).to eql(["You must answer town or city"]) + end + end + end + end + + context "when setup section not complete" do + let(:attributes) { { bulk_upload:, field_13: "123" } } + + it "has errors on setup fields" do + errors = parser.errors.select { |e| e.options[:category] == :setup }.map(&:attribute).sort + + expect(errors).to eql(%i[field_1 field_2 field_4 field_45 field_5 field_6 field_7 field_8 field_9]) + end + end + + describe "#field_3" do # created_by + context "when blank" do + let(:attributes) { { bulk_upload:, field_3: "", field_4: 1 } } + + it "is permitted" do + expect(parser.errors[:field_3]).to be_blank + end + end + + context "when user could not be found" do + let(:attributes) { { bulk_upload:, field_3: "idonotexist@example.com" } } + + it "is not permitted" do + expect(parser.errors[:field_3]).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_3: other_user.email, field_2: managing_org.old_visible_id } } + + it "is not permitted" do + expect(parser.errors[:field_3]).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_3: other_user.email, field_2: managing_org.old_visible_id } } + + it "is permitted" do + expect(parser.errors[:field_3]).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_3: other_user.email.upcase!, field_2: managing_org.old_visible_id } } + + it "is permitted" do + expect(parser.errors[:field_3]).to be_blank + end + end + + context "when an user part of managing org" do + let(:other_user) { create(:user, organisation: managing_org) } + + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_3: other_user.email, field_2: managing_org.old_visible_id } } + + it "is permitted" do + expect(parser.errors[:field_3]).to be_blank + end + end + end + + describe "#field_5" do + context "when null" do + let(:attributes) { { bulk_upload:, field_5: nil, field_15: "1" } } + + it "returns an error" do + expect(parser.errors[:field_5]).to be_present + end + end + + context "when incorrect data type" do + let(:attributes) { { bulk_upload:, field_5: "foo" } } + + it "returns an error" do + expect(parser.errors[:field_5]).to be_present + end + end + + context "when unpermitted value" do + let(:attributes) { { bulk_upload:, field_5: "101" } } + + it "returns an error" do + expect(parser.errors[:field_5]).to be_present + end + end + + context "when valid" do + let(:attributes) { { bulk_upload:, field_5: "1", field_4: "1" } } + + it "does not return any errors" do + expect(parser.errors[:field_5]).to be_blank + end + end + + context "when intermediate rent and field_11 (Which type of Intermediate Rent) is not given" do + let(:attributes) { { bulk_upload:, field_5: "9", field_11: nil } } + + it "adds error on field_11" do + expect(parser.errors[:field_5]).to be_present + expect(parser.errors[:field_11]).to eq(["You must answer intermediate rent type"]) + end + end + + context "when intermediate rent and field_11 (Which type of Intermediate Rent) is invalid/gets cleared" do + let(:attributes) { { bulk_upload:, field_5: "9", field_11: "Intermediate rent" } } + + it "adds error on field_11" do + expect(parser.errors[:field_5]).to be_present + expect(parser.errors[:field_11]).to eq(["You must answer intermediate rent type"]) + end + end + + context "when affordable rent and field_10 (Is this a London Affordable Rent letting?) is not given" do + let(:attributes) { { bulk_upload:, field_5: "5", field_10: nil } } + + it "adds error on field_10" do + expect(parser.errors[:field_5]).to be_present + expect(parser.errors[:field_10]).to eq(["You must answer is this a London Affordable Rent letting"]) + end + end + + context "when affordable rent and field_10 (Is this a London Affordable Rent letting?) is invalid/gets cleared" do + let(:attributes) { { bulk_upload:, field_5: "5", field_10: "Intermediate rent" } } + + it "adds error on field_10" do + expect(parser.errors[:field_5]).to be_present + expect(parser.errors[:field_10]).to eq(["You must answer is this a London Affordable Rent letting"]) + end + end + + context "when intermediate rent other and field_12 is not given" do + let(:attributes) { { bulk_upload:, field_5: "9", field_11: "3", field_12: nil } } + + it "adds error on field_12" do + expect(parser.errors[:field_12]).to eq(["You must answer product name"]) + end + end + + context "when bulk upload is for general needs" do + context "when general needs option selected" do + let(:attributes) { { bulk_upload:, field_5: "1", field_4: "1" } } + + it "is permitted" do + expect(parser.errors[:field_4]).to be_blank + expect(parser.errors[:field_5]).to be_blank + end + end + + context "when supported housing option selected" do + let(:attributes) { { bulk_upload:, field_5: "2", field_4: "1" } } + + it "is not permitted" do + expect(parser.errors[:field_4]).to include("This letting type is supported housing, but the needs type is general needs. Change either the needs type or the letting type.") + expect(parser.errors[:field_5]).to include("This needs type is general needs, but the letting type is supported housing. Change either the needs type or the letting type.") + end + end + end + + context "when bulk upload is for supported housing" do + let(:bulk_upload) { create(:bulk_upload, :lettings, user:) } + + context "when general needs option selected" do + let(:attributes) { { bulk_upload:, field_5: "1", field_4: "2" } } + + it "is not permitted" do + expect(parser.errors[:field_4]).to include("This letting type is general needs, but the needs type is supported housing. Change either the needs type or the letting type.") + expect(parser.errors[:field_5]).to include("This needs type is supported housing, but the letting type is general needs. Change either the needs type or the letting type.") + end + end + + context "when supported housing option selected" do + let(:attributes) { { bulk_upload:, field_5: "2", field_4: "2" } } + + it "is permitted" do + expect(parser.errors[:field_4]).to be_blank + expect(parser.errors[:field_5]).to be_blank + end + end + end + end + + describe "#field_15, field_16, field_17" do # scheme and location fields + context "when nullable not permitted" do + let(:attributes) { { bulk_upload:, field_4: "2", field_5: "2", field_15: nil, field_16: nil, field_17: nil } } + + it "cannot be nulled" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to eq(["You must answer scheme code"]) + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when nullable permitted" do + let(:attributes) { { bulk_upload:, field_4: "1", field_5: "1", field_15: nil, field_16: nil, field_17: nil } } + + it "can be nulled" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when using New CORE ids" do + let(:scheme) { create(:scheme, :with_old_visible_id, owning_organisation: owning_org) } + let!(:location) { create(:location, :with_old_visible_id, scheme:) } + + before do + parser.valid? + end + + context "when matching scheme cannot be found" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_16: "S123", field_17: location.id } } + + it "returns a setup error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors.where(:field_16, category: :setup).map(&:message)).to eq(["This scheme code does not belong to the owning organisation or managing organisation"]) + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when missing location" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_16: "S#{scheme.id}", field_17: nil } } + + it "returns a setup error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors.where(:field_17, category: :setup).map(&:message)).to eq(["You must answer location code"]) + expect(parser.errors[:field_17].count).to eq(1) + end + end + + context "when missing management group code" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_16: scheme.old_visible_id.to_s, field_15: nil, field_17: nil } } + + it "returns a setup error" do + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + expect(parser.errors.where(:field_15, category: :setup).map(&:message)).to eq(["You must answer management group code"]) + expect(parser.errors[:field_15].count).to eq(1) + end + end + + context "when matching location cannot be found" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_16: "S#{scheme.id}", field_17: "123" } } + + it "returns a setup error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors.where(:field_17, category: :setup).map(&:message)).to eq(["Location code must relate to a location that is owned by the owning organisation or managing organisation"]) + end + end + + context "when matching location exists" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_16: "S#{scheme.id}", field_17: location.id } } + + it "does not return an error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when location exists but not related" do + let(:other_scheme) { create(:scheme, :with_old_visible_id) } + let(:other_location) { create(:location, :with_old_visible_id, scheme: other_scheme) } + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_16: "S#{scheme.id}", field_17: other_location.id } } + + it "returns a setup error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors.where(:field_17, category: :setup).map(&:message)).to eq(["Location code must relate to a location that is owned by the owning organisation or managing organisation"]) + end + end + + context "when scheme belongs to someone else" do + let(:other_scheme) { create(:scheme, :with_old_visible_id) } + let(:other_location) { create(:location, :with_old_visible_id, scheme: other_scheme) } + let(:attributes) { { bulk_upload:, field_4: "2", field_5: "2", field_16: "S#{other_scheme.id}", field_17: other_location.id, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "returns a setup error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors.where(:field_16, category: :setup).map(&:message)).to eq(["This scheme code does not belong to the owning organisation or managing organisation"]) + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when scheme belongs to owning org" do + let(:attributes) { { bulk_upload:, field_4: "2", field_5: "2", field_16: "S#{scheme.id}", field_17: location.id, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "does not return an error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when scheme belongs to managing org" do + let(:managing_org_scheme) { create(:scheme, :with_old_visible_id, owning_organisation: managing_org) } + let(:managing_org_location) { create(:location, :with_old_visible_id, scheme: managing_org_scheme) } + let(:attributes) { { bulk_upload:, field_4: "2", field_5: "2", field_16: "S#{managing_org_scheme.id}", field_17: managing_org_location.id, field_2: managing_org.old_visible_id } } + + it "clears the scheme answer" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to include("You must answer scheme name") + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when matching location exists but is incomplete" do + let(:incomplete_location) { create(:location, :with_old_visible_id, :incomplete, scheme:) } + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_16: "S#{scheme.id}", field_17: incomplete_location.id } } + + it "returns a setup error for scheme" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors.where(:field_16).map(&:message)).to eq(["This location is incomplete. Select another location or update this one"]) + expect(parser.errors.where(:field_17).map(&:message)).to eq(["This location is incomplete. Select another location or update this one"]) + end + end + end + + context "when using Old CORE ids" do + let(:scheme) { create(:scheme, :with_old_visible_id, owning_organisation: owning_org) } + let!(:location) { create(:location, :with_old_visible_id, scheme:) } + + before do + parser.valid? + end + + context "when matching scheme cannot be found" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_15: "123", field_16: location.old_visible_id } } + + it "returns a setup error" do + expect(parser.errors.where(:field_15, category: :setup).map(&:message)).to eq(["This management group code does not belong to the owning organisation or managing organisation"]) + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when missing location" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_15: scheme.old_visible_id, field_16: nil } } + + it "returns a setup error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors.where(:field_16, category: :setup).map(&:message)).to eq(["You must answer scheme code"]) + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when matching location cannot be found" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_15: scheme.old_visible_id, field_16: "123" } } + + it "returns a setup error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors.where(:field_16, category: :setup).map(&:message)).to eq(["Scheme code must relate to a scheme that is owned by the owning organisation or managing organisation"]) + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when matching location exists" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_15: scheme.old_visible_id, field_16: location.old_visible_id } } + + it "does not return an error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when location exists but not related" do + let(:other_scheme) { create(:scheme, :with_old_visible_id) } + let(:other_location) { create(:location, :with_old_visible_id, scheme: other_scheme) } + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "2", field_5: "2", field_15: scheme.old_visible_id, field_16: other_location.old_visible_id } } + + it "returns a setup error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors.where(:field_16, category: :setup).map(&:message)).to eq(["Scheme code must relate to a scheme that is owned by the owning organisation or managing organisation"]) + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when scheme belongs to someone else" do + let(:other_scheme) { create(:scheme, :with_old_visible_id) } + let(:other_location) { create(:location, :with_old_visible_id, scheme: other_scheme) } + let(:attributes) { { bulk_upload:, field_4: "2", field_5: "2", field_15: other_scheme.old_visible_id, field_16: other_location.old_visible_id, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "returns a setup error" do + expect(parser.errors.where(:field_15, category: :setup).map(&:message)).to eq(["This management group code does not belong to the owning organisation or managing organisation"]) + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when scheme belongs to owning org" do + let(:attributes) { { bulk_upload:, field_4: "2", field_5: "2", field_15: scheme.old_visible_id, field_16: location.old_visible_id, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "does not return an error" do + expect(parser.errors[:field_15]).to be_blank + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + end + end + + context "when scheme belongs to managing org" do + let(:managing_org_scheme) { create(:scheme, :with_old_visible_id, owning_organisation: managing_org) } + let(:managing_org_location) { create(:location, :with_old_visible_id, scheme: managing_org_scheme) } + let(:attributes) { { bulk_upload:, field_4: "2", field_5: "2", field_15: managing_org_scheme.old_visible_id, field_16: managing_org_location.old_visible_id, field_2: managing_org.old_visible_id } } + + it "clears the scheme answer" do + expect(parser.errors[:field_15]).to include("You must answer scheme name") + expect(parser.errors[:field_16]).to be_blank + expect(parser.errors[:field_17]).to be_blank + end + end + end + end + + describe "#field_102" do # leaving reason + context "when field_6 is 1 meaning it is a renewal" do + context "when field_102 is 40" do + let(:attributes) { { bulk_upload:, field_102: "40", field_6: "1" } } + + it "is permitted" do + expect(parser.errors[:field_102]).to be_blank + end + end + + context "when field_102 is 42" do + let(:attributes) { { bulk_upload:, field_102: "42", field_6: "1" } } + + it "is permitted" do + expect(parser.errors[:field_102]).to be_blank + end + end + + context "when field_102 is not 40 or 42" do + let(:attributes) { { bulk_upload:, field_102: "1", field_6: "1" } } + + it "is not permitted" do + expect(parser.errors[:field_102]).to be_present + end + end + end + + context "when no longer a valid option from previous year" do + let(:attributes) { setup_section_params.merge({ field_102: "7" }) } + + it "returns an error" do + expect(parser.errors[:field_102]).to include("Enter a valid value for What is the tenant’s main reason for the household leaving their last settled home?") + end + end + end + + describe "#field_83, #field_84, #field_85" do + context "when one item selected" do + let(:attributes) { { bulk_upload:, field_83: "1" } } + + it "is permitted" do + expect(parser.errors[:field_83]).to be_blank + expect(parser.errors[:field_84]).to be_blank + expect(parser.errors[:field_85]).to be_blank + end + end + + context "when more than one item selected" do + let(:attributes) { { bulk_upload:, field_83: "1", field_84: "1" } } + + it "is not permitted" do + expect(parser.errors[:field_83]).to be_present + expect(parser.errors[:field_84]).to be_present + end + end + end + + describe "#field_87" do + context "when 1 and another disability field selected" do + let(:attributes) { { bulk_upload:, field_87: "1", field_86: "1" } } + + it "is not permitted" do + expect(parser.errors[:field_87]).to be_present + end + end + end + + describe "#field_88" do + context "when 1 and another disability field selected" do + let(:attributes) { { bulk_upload:, field_88: "1", field_86: "1" } } + + it "is not permitted" do + expect(parser.errors[:field_88]).to be_present + end + end + end + + describe "#field_87, #field_88" do + context "when both 1" do + let(:attributes) { { bulk_upload:, field_87: "1", field_88: "1" } } + + it "is not permitted" do + expect(parser.errors[:field_87]).to be_present + expect(parser.errors[:field_88]).to be_present + end + end + end + + describe "#field_83 - #field_88" do + context "when all blank" do + let(:attributes) { setup_section_params.merge({ field_83: nil, field_84: nil, field_85: nil, field_86: nil, field_87: nil, field_88: nil }) } + + it "adds errors to correct fields" do + expect(parser.errors[:field_83]).to be_present + expect(parser.errors[:field_84]).to be_present + expect(parser.errors[:field_85]).to be_present + expect(parser.errors[:field_86]).to be_present + expect(parser.errors[:field_87]).to be_present + end + end + + context "when one item selected and field_86 is blank" do + let(:attributes) { setup_section_params.merge({ field_83: "1", field_86: nil }) } + + it "sets other disabled access needs as no" do + expect(parser.errors[:field_83]).to be_blank + expect(parser.errors[:field_86]).to be_blank + expect(parser.log.housingneeds_other).to eq(0) + end + end + end + + describe "#field_89, field_98 - 99" do + context "when no illness but illnesses answered" do + let(:attributes) { { bulk_upload:, field_89: "2", field_90: "1", field_91: "1", field_92: "1" } } + + it "errors added to correct fields" do + expect(parser.errors[:field_90]).to be_present + expect(parser.errors[:field_91]).to be_present + expect(parser.errors[:field_92]).to be_present + expect(parser.errors[:field_93]).not_to be_present + expect(parser.errors[:field_94]).not_to be_present + expect(parser.errors[:field_95]).not_to be_present + expect(parser.errors[:field_96]).not_to be_present + expect(parser.errors[:field_97]).not_to be_present + expect(parser.errors[:field_98]).not_to be_present + expect(parser.errors[:field_99]).not_to be_present + end + end + + context "when illness but no illnesses answered" do + let(:attributes) { { bulk_upload:, field_89: "1", field_90: nil, field_91: nil, field_92: nil, field_93: nil, field_94: nil, field_95: nil, field_96: nil, field_97: nil, field_98: nil, field_99: nil } } + + it "errors added to correct fields" do + expect(parser.errors[:field_90]).to be_present + expect(parser.errors[:field_91]).to be_present + expect(parser.errors[:field_92]).to be_present + expect(parser.errors[:field_93]).to be_present + expect(parser.errors[:field_94]).to be_present + expect(parser.errors[:field_95]).to be_present + expect(parser.errors[:field_96]).to be_present + expect(parser.errors[:field_97]).to be_present + expect(parser.errors[:field_98]).to be_present + expect(parser.errors[:field_99]).to be_present + end + end + end + + describe "#field_116, 117, 118" do + context "when none of field_116, 117, 118 are given" do + let(:attributes) { { bulk_upload:, field_116: "", field_117: "", field_118: "", field_89: "1" } } + + it "sets correct errors" do + expect(parser.errors[:field_116]).to include("You must answer was the letting made under the Choice-Based Lettings (CBL)?") + expect(parser.errors[:field_117]).to include("You must answer was the letting made under the Common Allocation Policy (CAP)?") + expect(parser.errors[:field_118]).to include("You must answer was the letting made under the Common Housing Register (CHR)?") + end + end + end + + describe "#field_105, field_110 - 15" do + context "when there is a reasonable preference but none is given" do + let(:attributes) { { bulk_upload:, field_110: "1", field_111: nil, field_112: nil, field_113: nil, field_114: nil, field_115: nil } } + + it "is not permitted" do + expect(parser.errors[:field_111]).to be_present + expect(parser.errors[:field_112]).to be_present + expect(parser.errors[:field_113]).to be_present + expect(parser.errors[:field_114]).to be_present + expect(parser.errors[:field_115]).to be_present + end + end + end + + describe "#field_119" do # referral + context "when 3 ie PRP nominated by LA and owning org is LA" do + let(:attributes) { { bulk_upload:, field_119: "3", field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "is not permitted" do + expect(parser.errors[:field_119]).to be_present + end + end + + context "when 4 ie referred by LA and is general needs and owning org is LA" do + let(:attributes) { { bulk_upload:, field_119: "4", field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_4: "1" } } + + it "is not permitted" do + expect(parser.errors[:field_119]).to be_present + end + end + + context "when 4 ie referred by LA and is general needs and owning org is PRP" do + let(:owning_org) { create(:organisation, :prp, :with_old_visible_id) } + + let(:attributes) { { bulk_upload:, field_119: "4", field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "is permitted" do + expect(parser.errors[:field_119]).to be_blank + end + end + + context "when 4 ie referred by LA and is not general needs" do + let(:bulk_upload) { create(:bulk_upload, :lettings, user:) } + let(:attributes) { { bulk_upload:, field_119: "4", field_4: "2" } } + + it "is permitted" do + expect(parser.errors[:field_119]).to be_blank + end + end + end + + describe "fields 7, 8, 9 => startdate" do + context "when any one of these fields is blank" do + let(:attributes) { { bulk_upload:, field_5: "1", field_7: nil, field_8: nil, field_9: nil } } + + it "returns an error" do + expect(parser.errors[:field_7]).to be_present + expect(parser.errors[:field_8]).to be_present + expect(parser.errors[:field_9]).to be_present + end + end + + context "when field_9 is 4 digits instead of 2" do + let(:attributes) { { bulk_upload:, field_9: "2022" } } + + it "returns an error" do + expect(parser.errors[:field_9]).to include("Tenancy start year must be 2 digits") + end + end + + context "when invalid date given" do + let(:attributes) { { bulk_upload:, field_5: "1", field_7: "a", field_8: "12", field_9: "22" } } + + it "does not raise an error" do + expect { parser.valid? }.not_to raise_error + end + end + + context "when inside of collection year" do + let(:attributes) { { bulk_upload:, field_7: "1", field_8: "10", field_9: "22" } } + + let(:bulk_upload) { create(:bulk_upload, :lettings, user:, year: 2022) } + + it "does not return errors" do + expect(parser.errors[:field_7]).not_to be_present + expect(parser.errors[:field_8]).not_to be_present + expect(parser.errors[:field_9]).not_to be_present + end + end + + context "when outside of collection year" do + around do |example| + Timecop.freeze(Date.new(2022, 4, 2)) do + example.run + end + end + + let(:attributes) { { bulk_upload:, field_7: "1", field_8: "1", field_9: "22" } } + + let(:bulk_upload) { create(:bulk_upload, :lettings, user:, year: 2022) } + + it "returns setup errors" do + expect(parser.errors.where(:field_7, category: :setup)).to be_present + expect(parser.errors.where(:field_8, category: :setup)).to be_present + expect(parser.errors.where(:field_9, category: :setup)).to be_present + end + end + end + + describe "#field_1" do # owning org + context "when blank" do + let(:attributes) { { bulk_upload:, field_1: "", field_4: 1 } } + + 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 setup error" do + 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 is incorrect") + end + + it "blocks log creation" do + expect(parser).to be_block_log_creation + end + end + + context "when org is not stock owning" do + let(:owning_org) { create(:organisation, :with_old_visible_id, :does_not_own_stock) } + + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "is not permitted as setup error" do + 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 + 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 + setup_errors = parser.errors.select { |e| e.options[:category] == :setup } + + expect(setup_errors.find { |e| e.attribute == :field_1 }.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" 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, field_2: merged_org.old_visible_id, field_3: user.email } } + + 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 = described_class.new(attributes) + + parser.valid? + expect(parser.errors.where(:field_1)).not_to be_present + expect(parser.errors.where(:field_3)).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: merged_org.old_visible_id, field_3: user.email }) } + + before do + merged_org.update!(absorbing_organisation: user.organisation, merge_date: Time.zone.today - 5.years) + merged_org.reload + user.organisation.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 tenancy start date/) + expect(parser.errors[:field_2]).to include(/The managing organisation must be active on the tenancy start date/) + expect(parser.errors[:field_7]).to include(/Enter a date when the owning and managing organisation was active/) + expect(parser.errors[:field_8]).to include(/Enter a date when the owning and managing organisation was active/) + expect(parser.errors[:field_9]).to include(/Enter a date when the owning and managing organisation was active/) + end + end + end + + describe "#field_2" do # managing org + context "when blank" do + let(:attributes) { { bulk_upload:, field_2: "", field_4: 1 } } + + it "is not permitted as setup error" do + setup_errors = parser.errors.select { |e| e.options[:category] == :setup } + + expect(setup_errors.find { |e| e.attribute == :field_2 }.message).to eql("The managing organisation code is incorrect") + end + + it "blocks log creation" do + expect(parser).to be_block_log_creation + end + end + + context "when cannot find managing org" do + let(:attributes) { { bulk_upload:, field_2: "donotexist" } } + + it "is not permitted as setup error" do + setup_errors = parser.errors.select { |e| e.options[:category] == :setup } + + expect(setup_errors.find { |e| e.attribute == :field_2 }.message).to eql("The managing organisation code is incorrect") + end + + it "blocks log creation" do + expect(parser).to be_block_log_creation + end + end + + context "when not affiliated with managing org" do + let(:unaffiliated_org) { create(:organisation, :with_old_visible_id) } + + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: unaffiliated_org.old_visible_id } } + + it "is not permitted as setup error" do + setup_errors = parser.errors.select { |e| e.options[:category] == :setup } + + expect(setup_errors.find { |e| e.attribute == :field_2 }.message).to eql("This managing organisation does not have a relationship with the owning organisation") + end + + it "blocks log creation" do + expect(parser).to be_block_log_creation + end + end + end + + describe "#field_4" do # needs type + context "when blank" do + let(:attributes) { { bulk_upload:, field_4: nil, field_13: "123" } } + + it "is reported as a setup error" do + expect(parser.errors.where(:field_4, category: :setup).map(&:message)).to eql(["You must answer needs type"]) + end + end + end + + describe "#field_6" do # renewal + context "when blank" do + let(:attributes) { { bulk_upload:, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id, field_6: "" } } + + it "has setup errors on the field" do + expect(parser.errors.where(:field_6, category: :setup).map(&:message)).to eql(["You must answer property renewal"]) + end + end + + context "when none possible option selected" do + let(:attributes) { setup_section_params.merge({ field_6: "101" }) } + + it "adds a setup error" do + expect(parser.errors.where(:field_6, category: :setup).map(&:message)).to include("Enter a valid value for Is this letting a renewal?") + end + end + end + + describe "#field_18" do # UPRN + context "when over 12 characters" do + let(:attributes) { setup_section_params.merge({ field_18: "1234567890123" }) } + + it "adds an appropriate error" do + expect(parser.errors[:field_18]).to eql(["UPRN is not recognised. Check the number, or enter the address"]) + end + end + + context "when neither UPRN nor address fields are given" do + let(:attributes) { setup_section_params } + + it "adds appropriate errors" do + expect(parser.errors[:field_18]).to eql(["You must answer UPRN"]) + expect(parser.errors[:field_19]).to eql(["You must answer address line 1"]) + expect(parser.errors[:field_21]).to eql(["You must answer town or city"]) + end + end + + context "when neither UPRN nor address fields are given for a supported housing record" do + let(:bulk_upload) { create(:bulk_upload, :lettings, user:, needstype: 2) } + let(:attributes) do + { bulk_upload:, + field_15: scheme.old_visible_id, + field_4: "2", + field_5: "2", + field_16: location.old_visible_id, + field_1: "1" } + end + + it "does not add UPRN errors" do + expect(parser.errors[:field_18]).to be_empty + expect(parser.errors[:field_19]).to be_empty + expect(parser.errors[:field_21]).to be_empty + end + end + + context "when UPRN is given but address fields are not" do + let(:attributes) do + { + bulk_upload:, + field_18: "123456789012", + } + end + + it "doesn't add an error" do + expect(parser.errors[:field_18]).to be_empty + end + end + + context "when address is given but UPRN is not" do + let(:attributes) do + { + bulk_upload:, + field_19: "1 Example Rd", + field_21: "Example Town/City", + } + end + + it "doesn't add an error" do + expect(parser.errors[:field_18]).to be_empty + end + end + end + + describe "#field_26" do # unitletas + context "when no longer a valid option from previous year" do + let(:attributes) { setup_section_params.merge({ field_26: "4" }) } + + it "returns an error" do + expect(parser.errors[:field_26]).to be_present + end + end + end + + describe "#field_30" do + context "when null" do + let(:attributes) { setup_section_params.merge({ field_30: nil }) } + + it "returns an error" do + expect(parser.errors[:field_30]).to be_present + end + + it "populates with correct error message" do + expect(parser.errors[:field_30]).to eql(["You must answer type of building"]) + end + end + end + + describe "#field_52" do # age2 + context "when null but gender given" do + let(:attributes) { setup_section_params.merge({ field_52: "", field_53: "F" }) } + + it "returns an error" do + expect(parser.errors[:field_52]).to be_present + end + end + end + + describe "soft validations" do + context "when soft validation is triggered" do + let(:attributes) { setup_section_params.merge({ field_46: 22, field_50: 5 }) } + + it "adds an error to the relevant fields" do + expect(parser.errors.where(:field_46, category: :soft_validation)).to be_present + expect(parser.errors.where(:field_50, category: :soft_validation)).to be_present + end + + it "populates with correct error message" do + expect(parser.errors.where(:field_46, category: :soft_validation).first.message).to eql("You told us this person is aged 22 years and retired.") + expect(parser.errors.where(:field_50, 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) { setup_section_params.merge({ field_82: "1", field_47: "M", field_53: "M", field_57: "M" }) } + + it "adds errors to fields that are routed to" do + expect(parser.errors.where(:field_53, category: :soft_validation)).to be_present + expect(parser.errors.where(:field_57, 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_61, category: :soft_validation)).not_to be_present + expect(parser.errors.where(:field_65, category: :soft_validation)).not_to be_present + end + end + + context "when soft validation is triggered and not required" do + let(:attributes) { setup_section_params.merge({ field_128: 120, field_126: 1, field_32: 1, field_4: 1, field_5: "3", field_25: "E09000008" }) } + + it "adds an error to the relevant fields" do + expect(parser.errors.where(:field_128, category: :soft_validation)).to be_present + end + + it "populates with correct error message" do + expect(parser.errors.where(:field_128, category: :soft_validation).count).to be(1) + expect(parser.errors.where(:field_128, category: :soft_validation).first.message).to eql("You told us the rent is £120.00 every week. This is higher than we would expect.") + end + end + end + end + + describe "#log" do + describe "#created_by" do + context "when blank" do + let(:attributes) { setup_section_params } + + it "takes the user that is uploading" do + expect(parser.log.created_by).to eql(bulk_upload.user) + end + end + + context "when email specified" do + let(:other_user) { create(:user, organisation: owning_org) } + + let(:attributes) { setup_section_params.merge(field_3: other_user.email) } + + it "sets to user with specified email" do + expect(parser.log.created_by).to eql(other_user) + end + end + end + + describe "#uprn" do + let(:attributes) { { bulk_upload:, field_18: "12" } } + + it "sets to given value" do + expect(parser.log.uprn).to eql("12") + end + end + + describe "#uprn_known" do + context "when uprn specified" do + let(:attributes) { { bulk_upload:, field_18: "12" } } + + it "sets to 1" do + expect(parser.log.uprn_known).to be(1) + expect(parser.log.uprn_confirmed).to be(1) + end + end + + context "when uprn blank" do + let(:attributes) { { bulk_upload:, field_18: "", field_4: 1 } } + + it "sets to 0" do + expect(parser.log.uprn_known).to be(0) + end + end + end + + describe "#address_line1" do + let(:attributes) { { bulk_upload:, field_19: "123 Sesame Street" } } + + it "sets to given value" do + expect(parser.log.address_line1).to eql("123 Sesame Street") + end + end + + describe "#address_line2" do + let(:attributes) { { bulk_upload:, field_20: "Cookie Town" } } + + it "sets to given value" do + expect(parser.log.address_line2).to eql("Cookie Town") + end + end + + describe "#town_or_city" do + let(:attributes) { { bulk_upload:, field_21: "London" } } + + it "sets to given value" do + expect(parser.log.town_or_city).to eql("London") + end + end + + describe "#county" do + let(:attributes) { { bulk_upload:, field_22: "Greater London" } } + + it "sets to given value" do + expect(parser.log.county).to eql("Greater London") + end + end + + [ + %w[age1_known details_known_1 age1 field_46 field_51 field_53], + %w[age2_known details_known_2 age2 field_52 field_51 field_53], + %w[age3_known details_known_3 age3 field_56 field_55 field_57], + %w[age4_known details_known_4 age4 field_60 field_59 field_61], + %w[age5_known details_known_5 age5 field_64 field_63 field_65], + %w[age6_known details_known_6 age6 field_68 field_67 field_69], + %w[age7_known details_known_7 age7 field_72 field_71 field_73], + %w[age8_known details_known_8 age8 field_76 field_75 field_77], + ].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 not given" do + let(:attributes) { { bulk_upload:, field.to_sym => nil, field_4: 1, relationship.to_sym => nil, gender.to_sym => nil } } + + 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(1) + 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) { { bulk_upload:, field.to_sym => nil, field_4: 1, relationship.to_sym => "C", gender.to_sym => "X" } } + + it "does not set ##{age}" do + parser.valid? + expect(parser.errors[field.to_sym]).to include(/must be a number or the letter R/) + end + end + end + + context "when #{field} is R" do + let(:attributes) { { bulk_upload:, field.to_s => "R" } } + + 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) { { bulk_upload:, field.to_s => "50" } } + + 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 + end + end + + describe "#location" do + context "when lookup is via new core id" do + let(:attributes) { { bulk_upload:, field_16: "S#{scheme.id}", field_17: location.id, field_1: "ORG#{owning_org.id}", field_2: "ORG#{owning_org.id}" } } + + it "assigns the correct location" do + expect(parser.log.location).to eql(location) + end + end + + context "when lookup is via old core id" do + let(:attributes) { { bulk_upload:, field_15: scheme.old_visible_id, field_16: location.old_visible_id, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "assigns the correct location" do + expect(parser.log.location).to eql(location) + end + + context "when location had leading zeroes in its id in Old CORE" do + let(:attributes) { { bulk_upload:, field_15: scheme.old_visible_id, field_16: "123", field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + before do + location.old_visible_id = "00123" + location.save! + end + + it "assigns the correct location" do + expect(parser.log.location).to eql(location) + end + end + + context "when the user provides an id with leading zeroes" do + let(:attributes) { { bulk_upload:, field_15: scheme.old_visible_id, field_16: "00123", field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + before do + location.old_visible_id = "123" + location.save! + end + + it "assigns the correct location" do + expect(parser.log.location).to eql(location) + end + end + end + end + + describe "#scheme" do + context "when lookup is via new core id" do + let(:attributes) { { bulk_upload:, field_16: "S#{scheme.id}", field_1: "ORG#{owning_org.id}", field_2: "ORG#{owning_org.id}" } } + + it "assigns the correct scheme" do + expect(parser.log.scheme).to eql(scheme) + end + end + + context "when lookup is via old core id" do + let(:attributes) { { bulk_upload:, field_15: scheme.old_visible_id, field_16: location.old_visible_id, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + it "assigns the correct scheme" do + expect(parser.log.scheme).to eql(scheme) + end + + context "when scheme had leading zeroes in its id in Old CORE" do + let(:attributes) { { bulk_upload:, field_15: "10", field_16: location.old_visible_id, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + before do + scheme.old_visible_id = "010" + scheme.save! + end + + it "assigns the correct scheme" do + expect(parser.log.scheme).to eql(scheme) + end + end + + context "when the user provides an id with leading zeroes" do + let(:attributes) { { bulk_upload:, field_15: "010", field_16: location.old_visible_id, field_1: owning_org.old_visible_id, field_2: owning_org.old_visible_id } } + + before do + scheme.old_visible_id = "10" + scheme.save! + end + + it "assigns the correct scheme" do + expect(parser.log.scheme).to eql(scheme) + end + end + end + end + + describe "#owning_organisation" do + context "when lookup is via id prefixed with ORG" do + let(:attributes) { { bulk_upload:, field_1: "ORG#{owning_org.id}" } } + + it "assigns the correct org" do + expect(parser.log.owning_organisation).to eql(owning_org) + end + end + end + + describe "#managing_organisation" do + context "when lookup is via id prefixed with ORG" do + let(:attributes) { { bulk_upload:, field_2: "ORG#{managing_org.id}" } } + + it "assigns the correct org" do + expect(parser.log.managing_organisation).to eql(managing_org) + end + end + end + + describe "#cbl" do + context "when field_116 is yes ie 1" do + let(:attributes) { { bulk_upload:, field_116: 1 } } + + it "sets value to 1" do + expect(parser.log.cbl).to be(1) + end + end + + context "when field_116 is no ie 2" do + let(:attributes) { { bulk_upload:, field_116: 2 } } + + it "sets value to 0" do + expect(parser.log.cbl).to be(0) + end + end + end + + describe "#chr" do + context "when field_118 is yes ie 1" do + let(:attributes) { { bulk_upload:, field_118: 1 } } + + it "sets value to 1" do + expect(parser.log.chr).to be(1) + end + end + + context "when field_118 is no ie 2" do + let(:attributes) { { bulk_upload:, field_118: 2 } } + + it "sets value to 0" do + expect(parser.log.chr).to be(0) + end + end + end + + describe "#cap" do + context "when field_117 is yes ie 1" do + let(:attributes) { { bulk_upload:, field_117: 1 } } + + it "sets value to 1" do + expect(parser.log.cap).to be(1) + end + end + + context "when field_117 is no ie 2" do + let(:attributes) { { bulk_upload:, field_117: 2 } } + + it "sets value to 0" do + expect(parser.log.cap).to be(0) + end + end + end + + describe "#letting_allocation_unknown" do + context "when field_116, 117, 118 are no ie 2" do + let(:attributes) { { bulk_upload:, field_116: 2, field_117: 2, field_118: 2 } } + + it "sets value to 1" do + expect(parser.log.letting_allocation_unknown).to be(1) + end + end + + context "when any one of field_116, 117, 118 is yes ie 1" do + let(:attributes) { { bulk_upload:, field_116: 1 } } + + it "sets value to 0" do + expect(parser.log.letting_allocation_unknown).to be(0) + end + end + end + + describe "#renewal" do + context "when field_6 is no ie 2" do + let(:attributes) { { bulk_upload:, field_6: 2 } } + + it "sets value to 0" do + expect(parser.log.renewal).to eq(0) + end + end + end + + describe "#sexN fields" do + let(:attributes) do + { + bulk_upload:, + field_47: "F", + field_53: "M", + field_57: "X", + field_61: "R", + field_65: "F", + field_69: "M", + field_73: "X", + field_77: "R", + } + end + + it "sets value from correct mapping" do + expect(parser.log.sex1).to eql("F") + expect(parser.log.sex2).to eql("M") + expect(parser.log.sex3).to eql("X") + expect(parser.log.sex4).to eql("R") + expect(parser.log.sex5).to eql("F") + expect(parser.log.sex6).to eql("M") + expect(parser.log.sex7).to eql("X") + expect(parser.log.sex8).to eql("R") + end + end + + describe "#ecstatN fields" do + let(:attributes) do + { + bulk_upload:, + field_50: "1", + field_54: "2", + field_58: "6", + field_62: "7", + field_66: "8", + field_70: "9", + field_74: "0", + field_78: "10", + } + end + + it "sets value from correct mapping", aggregate_failures: true do + expect(parser.log.ecstat1).to eq(1) + expect(parser.log.ecstat2).to eq(2) + expect(parser.log.ecstat3).to eq(6) + expect(parser.log.ecstat4).to eq(7) + expect(parser.log.ecstat5).to eq(8) + expect(parser.log.ecstat6).to eq(9) + expect(parser.log.ecstat7).to eq(0) + expect(parser.log.ecstat8).to eq(10) + end + end + + describe "#relatN fields" do + let(:attributes) do + { + bulk_upload:, + field_51: "P", + field_55: "C", + field_59: "X", + field_63: "R", + field_67: "P", + field_71: "C", + field_75: "X", + } + end + + it "sets value from correct mapping", aggregate_failures: true do + expect(parser.log.relat2).to eq("P") + expect(parser.log.relat3).to eq("C") + expect(parser.log.relat4).to eq("X") + expect(parser.log.relat5).to eq("R") + expect(parser.log.relat6).to eq("P") + expect(parser.log.relat7).to eq("C") + expect(parser.log.relat8).to eq("X") + end + end + + describe "#net_income_known" do + context "when 1" do + let(:attributes) { { bulk_upload:, field_120: "1" } } + + it "sets value from correct mapping" do + expect(parser.log.net_income_known).to eq(0) + end + end + + context "when 2" do + let(:attributes) { { bulk_upload:, field_120: "2" } } + + it "sets value from correct mapping" do + expect(parser.log.net_income_known).to eq(1) + end + end + + context "when 3" do + let(:attributes) { { bulk_upload:, field_120: "3" } } + + it "sets value from correct mapping" do + expect(parser.log.net_income_known).to eq(2) + end + end + end + + describe "#unitletas" do + let(:attributes) { { bulk_upload:, field_26: "1" } } + + it "sets value from correct mapping" do + expect(parser.log.unitletas).to eq(1) + end + end + + describe "#rsnvac" do + let(:attributes) { { bulk_upload:, field_27: "5" } } + + it "sets value from correct mapping" do + expect(parser.log.rsnvac).to eq(5) + end + end + + describe "#sheltered" do + let(:attributes) { { bulk_upload:, field_44: "1" } } + + it "sets value from correct mapping" do + expect(parser.log.sheltered).to eq(1) + end + end + + describe "illness fields" do + mapping = [ + { attribute: :illness_type_1, field: :field_98 }, + { attribute: :illness_type_2, field: :field_92 }, + { attribute: :illness_type_3, field: :field_95 }, + { attribute: :illness_type_4, field: :field_90 }, + { attribute: :illness_type_5, field: :field_91 }, + { attribute: :illness_type_6, field: :field_93 }, + { attribute: :illness_type_7, field: :field_94 }, + { attribute: :illness_type_8, field: :field_97 }, + { attribute: :illness_type_9, field: :field_96 }, + { attribute: :illness_type_10, field: :field_99 }, + ] + + mapping.each do |hash| + describe "##{hash[:attribute]}" do + context "when yes" do + let(:attributes) { { bulk_upload:, hash[:field] => "1" } } + + it "sets value from correct mapping" do + expect(parser.log.public_send(hash[:attribute])).to eq(1) + end + end + + context "when no" do + let(:attributes) { { bulk_upload:, hash[:field] => "", field_4: 1 } } + + it "sets value from correct mapping" do + expect(parser.log.public_send(hash[:attribute])).to be_nil + end + end + end + end + end + + describe "#irproduct_other" do + let(:attributes) { { bulk_upload:, field_12: "some other product" } } + + it "sets value to given free text string" do + expect(parser.log.irproduct_other).to eql("some other product") + end + end + + describe "#tenancyother" do + let(:attributes) { { bulk_upload:, field_42: "some other tenancy" } } + + it "sets value to given free text string" do + expect(parser.log.tenancyother).to eql("some other tenancy") + end + end + + describe "#tenancylength" do + let(:attributes) { { bulk_upload:, field_43: "2" } } + + it "sets value to given free text string" do + expect(parser.log.tenancylength).to eq(2) + end + end + + describe "#earnings" do + let(:attributes) { { bulk_upload:, field_122: "104.50" } } + + it "rounds to the nearest whole pound" do + expect(parser.log.earnings).to eq(105) + end + end + + describe "#reasonother" do + let(:attributes) { { bulk_upload:, field_103: "some other reason" } } + + it "sets value to given free text string" do + expect(parser.log.reasonother).to eql("some other reason") + end + end + + describe "#ppcodenk" do + let(:attributes) { { bulk_upload:, field_106: "2" } } + + it "sets correct value from mapping" do + expect(parser.log.ppcodenk).to eq(1) + end + end + + describe "#household_charge" do + context "when log is general needs" do + let(:attributes) { { bulk_upload:, field_4: 1, field_125: "1" } } + + it "sets correct value from mapping" do + expect(parser.log.household_charge).to eq(nil) + end + end + + context "when log is supported housing" do + let(:attributes) { { bulk_upload:, field_4: 2, field_125: "1" } } + + it "sets correct value from mapping" do + expect(parser.log.household_charge).to eq(1) + end + end + end + + describe "#chcharge" do + let(:attributes) { { bulk_upload:, field_127: "123.45" } } + + it "sets value given" do + expect(parser.log.chcharge).to eq(123.45) + end + end + + describe "#tcharge" do + let(:attributes) { { bulk_upload:, field_132: "123.45" } } + + it "sets value given" do + expect(parser.log.tcharge).to eq(123.45) + end + end + + describe "#supcharg" do + let(:attributes) { { bulk_upload:, field_131: "123.45" } } + + it "sets value given" do + expect(parser.log.supcharg).to eq(123.45) + end + end + + describe "#pscharge" do + let(:attributes) { { bulk_upload:, field_130: "123.45" } } + + it "sets value given" do + expect(parser.log.pscharge).to eq(123.45) + end + end + + describe "#scharge" do + let(:attributes) { { bulk_upload:, field_129: "123.45" } } + + it "sets value given" do + expect(parser.log.scharge).to eq(123.45) + end + end + + describe "#offered" do + let(:attributes) { { bulk_upload:, field_28: "3" } } + + it "sets value given" do + expect(parser.log.offered).to eq(3) + end + end + + describe "#propcode" do + let(:attributes) { { bulk_upload:, field_14: "abc123" } } + + it "sets value given" do + expect(parser.log.propcode).to eq("abc123") + end + end + + describe "#mrcdate" do + context "when valid" do + let(:attributes) { { bulk_upload:, field_36: "13", field_37: "12", field_38: "22" } } + + it "sets value given" do + expect(parser.log.mrcdate).to eq(Date.new(2022, 12, 13)) + end + end + + context "when invalid" do + let(:attributes) { { bulk_upload:, field_36: "13", field_37: "13", field_38: "22" } } + + it "does not raise an error" do + expect { parser.log.mrcdate }.not_to raise_error + end + end + end + + describe "#majorrepairs" do + context "when mrcdate given" do + let(:attributes) { { bulk_upload:, field_36: "13", field_37: "12", field_38: "22" } } + + it "sets #majorrepairs to 1" do + expect(parser.log.majorrepairs).to eq(1) + end + end + + context "when mrcdate not given" do + let(:attributes) { { bulk_upload:, field_36: "", field_37: "", field_38: "", field_4: 1 } } + + it "sets #majorrepairs to 0" do + expect(parser.log.majorrepairs).to eq(0) + end + end + end + + describe "#voiddate" do + context "when valid" do + let(:attributes) { { bulk_upload:, field_33: "13", field_34: "12", field_35: "22" } } + + it "sets value given" do + expect(parser.log.voiddate).to eq(Date.new(2022, 12, 13)) + end + end + + context "when invalid" do + let(:attributes) { { bulk_upload:, field_33: "13", field_34: "13", field_35: "22" } } + + it "does not raise an error" do + expect { parser.log.voiddate }.not_to raise_error + end + end + end + + describe "#startdate" do + let(:attributes) { { bulk_upload:, field_7: now.day.to_s, field_8: now.month.to_s, field_9: now.strftime("%g") } } + + it "sets value given" do + expect(parser.log.startdate).to eq(now) + end + end + + describe "#postcode_full" do + let(:attributes) { { bulk_upload:, field_23: " EC1N ", field_24: " 2TD " } } + + it "strips whitespace" do + expect(parser.log.postcode_full).to eql("EC1N 2TD") + end + end + + describe "#la" do + let(:attributes) { { bulk_upload:, field_25: "E07000223" } } + + it "sets to given value" do + expect(parser.log.la).to eql("E07000223") + end + end + + describe "#prevloc" do + let(:attributes) { { bulk_upload:, field_109: "E07000223" } } + + it "sets to given value" do + expect(parser.log.prevloc).to eql("E07000223") + end + end + + describe "#previous_la_known" do + context "when known" do + let(:attributes) { { bulk_upload:, field_109: "E07000223" } } + + it "sets to 1" do + expect(parser.log.previous_la_known).to eq(1) + end + end + + context "when not known" do + let(:attributes) { { bulk_upload:, field_109: "", field_4: 1 } } + + it "sets to 0" do + expect(parser.log.previous_la_known).to eq(0) + end + end + end + + describe "#first_time_property_let_as_social_housing" do + context "when field_27 is 15, 16, or 17" do + let(:attributes) { { bulk_upload:, field_27: %w[15 16 17].sample } } + + it "sets to 1" do + expect(parser.log.first_time_property_let_as_social_housing).to eq(1) + end + end + + context "when field_27 is not 15, 16, or 17" do + let(:attributes) { { bulk_upload:, field_27: "1" } } + + it "sets to 0" do + expect(parser.log.first_time_property_let_as_social_housing).to eq(0) + end + end + end + + describe "#housingneeds" do + context "when no disabled needs" do + let(:attributes) { { bulk_upload:, field_87: "1" } } + + it "sets to 2" do + expect(parser.log.housingneeds).to eq(2) + end + end + + context "when dont know about disabled needs" do + let(:attributes) { { bulk_upload:, field_88: "1" } } + + it "sets to 3" do + expect(parser.log.housingneeds).to eq(3) + end + end + + context "when housingneeds are given" do + let(:attributes) { { bulk_upload:, field_87: "0", field_85: "1", field_86: "1" } } + + it "sets correct housingneeds" do + expect(parser.log.housingneeds).to eq(1) + expect(parser.log.housingneeds_type).to eq(2) + expect(parser.log.housingneeds_other).to eq(1) + end + end + + context "when housingneeds are given and field_86 is nil" do + let(:attributes) { { bulk_upload:, field_87: nil, field_85: "1", field_86: "1" } } + + it "sets correct housingneeds" do + expect(parser.log.housingneeds).to eq(1) + expect(parser.log.housingneeds_type).to eq(2) + expect(parser.log.housingneeds_other).to eq(1) + end + end + + context "when housingneeds are not given" do + let(:attributes) { { bulk_upload:, field_83: nil, field_84: nil, field_85: nil, field_87: nil } } + + it "sets correct housingneeds" do + expect(parser.log.housingneeds).to eq(1) + expect(parser.log.housingneeds_type).to eq(3) + end + end + + context "when housingneeds a and b are selected" do + let(:attributes) { { bulk_upload:, field_83: "1", field_84: "1" } } + + it "sets error on housingneeds a and b" do + parser.valid? + expect(parser.errors[:field_83]).to include("Only one disabled access need: fully wheelchair-accessible housing, wheelchair access to essential rooms or level access housing, can be selected") + expect(parser.errors[:field_84]).to include("Only one disabled access need: fully wheelchair-accessible housing, wheelchair access to essential rooms or level access housing, can be selected") + expect(parser.errors[:field_85]).to be_blank + end + end + + context "when housingneeds a and c are selected" do + let(:attributes) { { bulk_upload:, field_83: "1", field_85: "1" } } + + it "sets error on housingneeds a and c" do + parser.valid? + expect(parser.errors[:field_83]).to include("Only one disabled access need: fully wheelchair-accessible housing, wheelchair access to essential rooms or level access housing, can be selected") + expect(parser.errors[:field_85]).to include("Only one disabled access need: fully wheelchair-accessible housing, wheelchair access to essential rooms or level access housing, can be selected") + expect(parser.errors[:field_84]).to be_blank + end + end + + context "when housingneeds b and c are selected" do + let(:attributes) { { bulk_upload:, field_84: "1", field_85: "1" } } + + it "sets error on housingneeds b and c" do + parser.valid? + expect(parser.errors[:field_84]).to include("Only one disabled access need: fully wheelchair-accessible housing, wheelchair access to essential rooms or level access housing, can be selected") + expect(parser.errors[:field_85]).to include("Only one disabled access need: fully wheelchair-accessible housing, wheelchair access to essential rooms or level access housing, can be selected") + expect(parser.errors[:field_83]).to be_blank + end + end + + context "when housingneeds a and g are selected" do + let(:attributes) { { bulk_upload:, field_83: "1", field_87: "1" } } + + it "sets error on housingneeds a and g" do + parser.valid? + expect(parser.errors[:field_87]).to include("No disabled access needs can’t be selected if you have selected fully wheelchair-accessible housing, wheelchair access to essential rooms, level access housing or other disabled access needs") + expect(parser.errors[:field_83]).to include("No disabled access needs can’t be selected if you have selected fully wheelchair-accessible housing, wheelchair access to essential rooms, level access housing or other disabled access needs") + expect(parser.errors[:field_84]).to be_blank + expect(parser.errors[:field_85]).to be_blank + end + end + + context "when only housingneeds g is selected" do + let(:attributes) { { bulk_upload:, field_83: "0", field_87: "1" } } + + it "does not add any housingneeds errors" do + parser.valid? + expect(parser.errors[:field_59]).to be_blank + expect(parser.errors[:field_83]).to be_blank + expect(parser.errors[:field_84]).to be_blank + expect(parser.errors[:field_85]).to be_blank + end + end + + context "when housingneeds a and h are selected" do + let(:attributes) { { bulk_upload:, field_83: "1", field_88: "1" } } + + it "sets error on housingneeds a and h" do + parser.valid? + expect(parser.errors[:field_88]).to include("Don’t know disabled access needs can’t be selected if you have selected fully wheelchair-accessible housing, wheelchair access to essential rooms, level access housing or other disabled access needs") + expect(parser.errors[:field_83]).to include("Don’t know disabled access needs can’t be selected if you have selected fully wheelchair-accessible housing, wheelchair access to essential rooms, level access housing or other disabled access needs") + expect(parser.errors[:field_84]).to be_blank + expect(parser.errors[:field_85]).to be_blank + end + end + + context "when only housingneeds h is selected" do + let(:attributes) { { bulk_upload:, field_83: "0", field_88: "1" } } + + it "does not add any housingneeds errors" do + parser.valid? + expect(parser.errors[:field_88]).to be_blank + expect(parser.errors[:field_83]).to be_blank + expect(parser.errors[:field_84]).to be_blank + expect(parser.errors[:field_85]).to be_blank + end + end + end + + describe "#housingneeds_type" do + context "when field_83 is 1" do + let(:attributes) { { bulk_upload:, field_83: "1" } } + + it "set to 0" do + expect(parser.log.housingneeds_type).to eq(0) + end + end + + context "when field_84 is 1" do + let(:attributes) { { bulk_upload:, field_84: "1" } } + + it "set to 1" do + expect(parser.log.housingneeds_type).to eq(1) + end + end + + context "when field_85 is 1" do + let(:attributes) { { bulk_upload:, field_85: "1" } } + + it "set to 2" do + expect(parser.log.housingneeds_type).to eq(2) + end + end + end + + describe "#housingneeds_other" do + context "when field_58 is 1" do + let(:attributes) { { bulk_upload:, field_86: "1" } } + + it "sets to 1" do + expect(parser.log.housingneeds_other).to eq(1) + end + end + end + end + + describe "#start_date" do + context "when year of 9 is passed to represent 2009" do + let(:attributes) { { bulk_upload:, field_7: "1", field_8: "1", field_9: "9" } } + + it "uses the year 2009" do + expect(parser.send(:start_date)).to eql(Date.new(2009, 1, 1)) + 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