Module: GoodData::Model::ToWire

Defined in:
lib/gooddata/models/blueprint/to_wire.rb

Class Method Summary collapse

Class Method Details

.anchor_to_wire(_project, dataset) ⇒ Hash

Converts anchor to wire format. There is difference between datsets that do not have anchor and those that do. Even if there is no acnhor you stil have to generate. If there is anchor it behaves exactly like am attribute

Parameters:

  • project (Hash) —

    Project blueprint hash represenation

  • dataset (Hash) —

    Dataset blueprint hash represenation

Returns:

  • (Hash) —

    Manifest for a particular reference



18
19
20
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 18

def self.anchor_to_wire(_project, dataset)
  attribute_to_wire(dataset, DatasetBlueprint.anchor(dataset))
end

.attribute_to_wire(dataset, attribute) ⇒ Hash

Converts atttribute to wire format.

Parameters:

  • dataset (Hash) —

    Dataset blueprint hash represenation

  • attribute (Hash) —

    Attribute

Returns:

  • (Hash) —

    Manifest for a particular reference



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 38

def self.attribute_to_wire(dataset, attribute)
  ls = DatasetBlueprint.labels_for_attribute(dataset, attribute)
  labels = ls.map do |l|
    {
      label: {
        identifier: l[:id],
        title: GoodData::Model.title(l),
        type: l[:gd_type] || Model::DEFAULT_TYPE,
        dataType: GoodData::Model.normalize_gd_data_type(l[:gd_data_type]) || Model::DEFAULT_ATTRIBUTE_DATATYPE
      }
    }
  end
  {}.tap do |a|
    a[:attribute] = {}
    a[:attribute][:identifier] = attribute[:id]
    a[:attribute][:title] = Model.title(attribute)
    a[:attribute][:folder] = attribute[:folder] || dataset[:folder] || GoodData::Model.title(dataset)
    a[:attribute][:labels] = labels unless labels.empty?
    a[:attribute][:description] = GoodData::Model.description(attribute) if GoodData::Model.description(attribute)

    if attribute[:order_by]
      label, direction = attribute[:order_by].split(' - ')
      a[:attribute][:sortOrder] = {
        attributeSortOrder: {
          label: label,
          direction: direction
        }
      }
    end

    if attribute[:grain]
      a[:attribute][:grain] = attribute[:grain].map do |g|
        case g.keys.first
        when :date
          { dateDimension: g.values.first }
        else
          g
        end
      end
    end

    if attribute[:relations]
      a[:attribute][:relations] = attribute[:relations]
    end

    default = ls.find { |l| l[:default_label] }
    a[:attribute][:defaultLabel] = (default && default[:id]) || ls.first[:id] unless ls.empty?
  end
end

.attributes_to_wire(_project, dataset) ⇒ Hash

Converts atttribute to wire format.

Parameters:

  • project (Hash) —

    Project blueprint hash represenation

  • dataset (Hash) —

    Dataset blueprint hash represenation

Returns:

  • (Hash) —

    Manifest for a particular reference



27
28
29
30
31
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 27

def self.attributes_to_wire(_project, dataset)
  DatasetBlueprint.attributes(dataset).map do |a|
    attribute_to_wire(dataset, a)
  end
end

.bridges_to_wire(_project, bridge) ⇒ Hash

Converts bridges to wire format.

Parameters:

  • _project (Hash) —

    Project blueprint hash represenation

Returns:

  • (Hash) —

    Manifest for a particular bridge



159
160
161
162
163
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 159

def self.bridges_to_wire(_project, bridge)
  DatasetBlueprint.bridges(bridge).map do |r|
    r[:dataset]
  end
end

.dataset_to_wire(project, dataset) ⇒ Hash

Converts dataset to wire format.

Parameters:

  • project (Hash) —

    Project blueprint hash represenation

  • dataset (Hash) —

    Dataset blueprint hash represenation

Returns:

  • (Hash) —

    Manifest for a particular reference



93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 93

def self.dataset_to_wire(project, dataset)
  {
    dataset: {
      identifier: dataset[:id],
      title: GoodData::Model.title(dataset),
      anchor: anchor_to_wire(project, dataset),
      attributes: attributes_to_wire(project, dataset),
      facts: DatasetBlueprint.facts(dataset).map { |f| fact_to_wire(dataset, f) },
      references: references_to_wire(project, dataset),
      bridges: bridges_to_wire(project, dataset)
    }
  }
end

.date_dimension_to_wire(project, dataset) ⇒ Hash

Converts date dimension to wire format.

Parameters:

  • project (Hash) —

    Project blueprint hash represenation

  • dataset (Hash) —

    Dataset blueprint hash represenation

Returns:

  • (Hash) —

    Manifest for a particular reference



112
113
114
115
116
117
118
119
120
121
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 112

def self.date_dimension_to_wire(project, dataset)
  payload = {}.tap do |dd|
    dd[:name] = dataset[:id]
    dd[:urn] = dataset[:urn] if dataset[:urn]
    dd[:title] = GoodData::Model.title(dataset)
    dd[:identifierPrefix] = dataset[:identifier_prefix] if dataset[:identifier_prefix]
    dd[:bridges] = bridges_to_wire(project, dataset)
  end
  { dateDimension: payload }
end

.fact_to_wire(dataset, fact) ⇒ Hash

Converts fact to wire format.

Parameters:

  • dataset (Hash) —

    Dataset blueprint hash represenation

  • fact (Hash) —

    Fact blueprint

Returns:

  • (Hash) —

    Manifest for a particular reference



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 128

def self.fact_to_wire(dataset, fact)
  payload = {
    fact: {
      identifier: fact[:id],
      title: GoodData::Model.title(fact),
      folder: fact[:folder] || dataset[:folder] || GoodData::Model.title(dataset),
      dataType: GoodData::Model.normalize_gd_data_type(fact[:gd_data_type]) || DEFAULT_FACT_DATATYPE,
      type: fact[:type]
    }
  }
  payload.tap do |p|
    p[:fact][:description] = GoodData::Model.description(fact) if GoodData::Model.description(fact)
    p[:fact][:restricted] = fact[:restricted] if fact[:restricted]
  end
end

.references_to_wire(_project, dataset) ⇒ Hash

Converts references to wire format.

Parameters:

  • fact (Hash) —

    Project blueprint hash represenation

  • dataset (Hash) —

    Dataset blueprint hash represenation

Returns:

  • (Hash) —

    Manifest for a particular reference



149
150
151
152
153
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 149

def self.references_to_wire(_project, dataset)
  DatasetBlueprint.references(dataset).map do |r|
    r[:dataset]
  end
end

.to_wire(what) ⇒ Hash

Entry method. Converts ProjectBlueprint representation into wire format which is understood by the API

Parameters:

  • fact (Hash) —

    Project blueprint represenation

  • dataset (Hash) —

    Dataset blueprint hash represenation

Returns:

  • (Hash) —

    Manifest for a particular reference



171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/gooddata/models/blueprint/to_wire.rb', line 171

def self.to_wire(what)
  {
    diffRequest: {
      targetModel: {
        projectModel: {
          modelMetadata: { containCA: what[:include_ca] },
          datasets: (what[:datasets] || []).map { |d| dataset_to_wire(what, d) },
          dateDimensions: (what[:date_dimensions] || []).map { |d| date_dimension_to_wire(what, d) }
        }
      }
    }
  }
end