Class: Deliver::UploadMetadata

Inherits:
Object
  • Object
show all
Defined in:
lib/deliver/upload_metadata.rb

Overview

upload description, rating, etc.

Constant Summary collapse

LOCALISED_VERSION_VALUES =

All the localised values attached to the version

[:description, :keywords, :release_notes, :support_url, :marketing_url]
NON_LOCALISED_VERSION_VALUES =

Everything attached to the version but not being localised

[:copyright]
LOCALISED_APP_VALUES =

Localised app details values

[:name, :privacy_url]
NON_LOCALISED_APP_VALUES =

Non localized app details values

[:primary_category, :secondary_category,
:primary_first_sub_category, :primary_second_sub_category,
:secondary_first_sub_category, :secondary_second_sub_category]

Instance Method Summary collapse

Instance Method Details

#assign_defaults(options) ⇒ Object

If the user is using the ‘default’ language, then assign values where they are needed



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/deliver/upload_metadata.rb', line 64

def assign_defaults(options)
  # Build a complete list of the required languages
  enabled_languages = []

  # Get all languages used in existing settings
  (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
    current = options[key]
    next unless current && current.kind_of?(Hash)
    current.each do |language, value|
      enabled_languages << language unless enabled_languages.include?(language)
    end
  end

  # Check folder list (an empty folder signifies a language is required)
  Dir.glob(File.join(options[:metadata_path], "*")).each do |lng_folder|
    next unless File.directory?(lng_folder) # We don't want to read txt as they are non localised

    language = File.basename(lng_folder)
    enabled_languages << language unless enabled_languages.include?(language)
  end

  return unless enabled_languages.include?("default")
  UI.message("Detected languages: " + enabled_languages.to_s)

  (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
    current = options[key]
    next unless current && current.kind_of?(Hash)

    default = current["default"]
    next if default.nil?

    enabled_languages.each do |language|
      value = current[language]
      next unless value.nil?

      current[language] = default
    end
    current.delete("default")
  end
end

#load_from_filesystem(options) ⇒ Object

Loads the metadata files and stores them into the options object



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/deliver/upload_metadata.rb', line 135

def load_from_filesystem(options)
  return if options[:skip_metadata]

  # Load localised data
  Loader.language_folders(options[:metadata_path]).each do |lng_folder|
    language = File.basename(lng_folder)
    (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
      path = File.join(lng_folder, "#{key}.txt")
      next unless File.exist?(path)

      UI.message("Loading '#{path}'...")
      options[key] ||= {}
      options[key][language] ||= File.read(path)
    end
  end

  # Load non localised data
  (NON_LOCALISED_VERSION_VALUES + NON_LOCALISED_APP_VALUES).each do |key|
    path = File.join(options[:metadata_path], "#{key}.txt")
    next unless File.exist?(path)

    UI.message("Loading '#{path}'...")
    options[key] ||= File.read(path)
  end
end

#upload(options) ⇒ Object

Make sure to call ‘load_from_filesystem` before calling upload



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/deliver/upload_metadata.rb', line 19

def upload(options)
  return if options[:skip_metadata]
  verify_available_languages!(options)

  app = options[:app]

  details = app.details
  v = app.edit_version(platform: options[:platform])

  (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
    current = options[key]
    next unless current

    unless current.kind_of?(Hash)
      UI.error("Error with provided '#{key}'. Must be a hash, the key being the language.")
      next
    end

    current.each do |language, value|
      next unless value.to_s.length > 0
      strip_value = value.to_s.strip
      v.send(key)[language] = strip_value if LOCALISED_VERSION_VALUES.include?(key)
      details.send(key)[language] = strip_value if LOCALISED_APP_VALUES.include?(key)
    end
  end

  (NON_LOCALISED_VERSION_VALUES + NON_LOCALISED_APP_VALUES).each do |key|
    current = options[key].to_s.strip
    next unless current.to_s.length > 0
    v.send("#{key}=", current) if NON_LOCALISED_VERSION_VALUES.include?(key)
    details.send("#{key}=", current) if NON_LOCALISED_APP_VALUES.include?(key)
  end

  v.release_on_approval = options[:automatic_release]

  set_review_information(v, options)
  set_app_rating(v, options)

  UI.message("Uploading metadata to iTunes Connect")
  v.save!
  details.save!
  UI.success("Successfully uploaded initial set of metadata to iTunes Connect")
end

#verify_available_languages!(options) ⇒ Object

Makes sure all languages we need are actually created



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/deliver/upload_metadata.rb', line 106

def verify_available_languages!(options)
  return if options[:skip_metadata]

  # Collect all languages we need
  # We only care about languages from user provided values
  # as the other languages are on iTC already anyway
  v = options[:app].edit_version
  UI.user_error!("Could not find a version to edit for app '#{options[:app].name}', the app metadata is read-only currently") unless v

  enabled_languages = []
  LOCALISED_VERSION_VALUES.each do |key|
    current = options[key]
    next unless current && current.kind_of?(Hash)
    current.each do |language, value|
      enabled_languages << language unless enabled_languages.include?(language)
    end
  end

  if enabled_languages.count > 0
    v.create_languages(enabled_languages)
    lng_text = "language"
    lng_text += "s" if enabled_languages.count != 1
    UI.message("Activating #{lng_text} #{enabled_languages.join(', ')}...")
    v.save!
  end
  true
end