Module: Twobook::Serialization

Defined in:
lib/twobook/serialization.rb

Class Method Summary collapse

Class Method Details

.deserialize_account(serialized) ⇒ Object 



59
60
61
62
63
64
65
66
67
 
# File 'lib/twobook/serialization.rb', line 59

def self.(serialized)
  serialized.deep_symbolize_keys!
  klass = Account.from_name(serialized[:name])
  immutable_data = deserialize_data(serialized[:data].slice(*klass.name_includes))
  mutable_data = deserialize_data(serialized[:data].slice(*klass.has))
   = klass.new(balance: serialized[:balance], **immutable_data)
  .update_mutable_data(mutable_data)
  
end

.deserialize_agreement(serialized) ⇒ Object 



30
31
32
33
34
 
# File 'lib/twobook/serialization.rb', line 30

def self.deserialize_agreement(serialized)
  serialized.deep_symbolize_keys!
  klass = Agreement.from_name(serialized[:name])
  klass.new(**deserialize_data(serialized[:data]))
end

.deserialize_data(data) ⇒ Object 



69
70
71
72
73
 
# File 'lib/twobook/serialization.rb', line 69

def self.deserialize_data(data)
  converted = data.deep_symbolize_keys
  converted.each { |k, v| converted[k] = try_parse_date(v) if k.to_s.end_with?("_at") }
  converted
end

.deserialize_event(serialized) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/twobook/serialization.rb', line 11

def self.deserialize_event(serialized)
  serialized.deep_symbolize_keys!

  klass = Event.from_name(serialized[:name])
  event = klass.new(
    **deserialize_data(serialized[:data]),
  )

  event.agreements = serialized[:agreements].map { |a| deserialize_agreement(a) }
  event
end

.serialize_account(account, before_event: nil, allow_empty: true) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/twobook/serialization.rb', line 36

def self.(, before_event: nil, allow_empty: true)
  balance, data = if before_event.nil?
                    [.balance, .data]
                  else
                    [
                      .balance_before_event(before_event),
                      .data_before_event(before_event),
                    ]
                  end

  # If we don't allow empty accounts...
  unless allow_empty
    only_has_name_data = data.keys.all? { |key| key.in?(.class.name_includes) }
    return nil if balance.zero? && only_has_name_data
  end

  {
    name: .name,
    balance: balance,
    data: data,
  }.as_json
end

.serialize_agreement(agreement) ⇒ Object 



23
24
25
26
27
28
 
# File 'lib/twobook/serialization.rb', line 23

def self.serialize_agreement(agreement)
  {
    name: agreement.class.agreement_name,
    data: agreement.data,
  }.as_json
end

.serialize_event(event) ⇒ Object 



3
4
5
6
7
8
9
 
# File 'lib/twobook/serialization.rb', line 3

def self.serialize_event(event)
  {
    name: event.class.event_name,
    data: event.data,
    agreements: event.agreements.map { |a| serialize_agreement(a) },
  }.as_json
end

.try_parse_date(string) ⇒ Object 



75
76
77
78
79
80
 
# File 'lib/twobook/serialization.rb', line 75

def self.try_parse_date(string)
  return string if string.is_a?(Time)
  Time.zone.parse(string)
rescue => _
  raise "Could not convert _at data on account #{inspect}"
end