b7cb0f15bc43d35bf00703d3c7ddb8881f29e0bc
[rails.git] / app / models / relation.rb
1 class Relation < ActiveRecord::Base
2   require 'xml/libxml'
3   
4   belongs_to :user
5
6   has_many :relation_members, :foreign_key => 'id'
7   has_many :relation_tags, :foreign_key => 'id'
8
9   has_many :old_relations, :foreign_key => 'id', :order => 'version'
10
11   set_table_name 'current_relations'
12
13   def self.from_xml(xml, create=false)
14     begin
15       p = XML::Parser.new
16       p.string = xml
17       doc = p.parse
18
19       doc.find('//osm/relation').each do |pt|
20         return Relation.from_xml_node(pt, create)
21       end
22     rescue
23       return nil
24     end
25   end
26
27   def self.from_xml_node(pt, create=false)
28     relation = Relation.new
29
30     if !create and pt['id'] != '0'
31       relation.id = pt['id'].to_i
32     end
33
34     relation.version = pt['version']
35
36     if create
37       relation.timestamp = Time.now
38       relation.visible = true
39     else
40       if pt['timestamp']
41         relation.timestamp = Time.parse(pt['timestamp'])
42       end
43     end
44
45     pt.find('tag').each do |tag|
46       relation.add_tag_keyval(tag['k'], tag['v'])
47     end
48
49     pt.find('member').each do |member|
50       relation.add_member(member['type'], member['ref'], member['role'])
51     end
52
53     return relation
54   end
55
56   def to_xml
57     doc = OSM::API.new.get_xml_doc
58     doc.root << to_xml_node()
59     return doc
60   end
61
62   def to_xml_node(user_display_name_cache = nil)
63     el1 = XML::Node.new 'relation'
64     el1['id'] = self.id.to_s
65     el1['visible'] = self.visible.to_s
66     el1['timestamp'] = self.timestamp.xmlschema
67     el1['version'] = self.version.to_s
68
69     user_display_name_cache = {} if user_display_name_cache.nil?
70     
71     if user_display_name_cache and user_display_name_cache.key?(self.user_id)
72       # use the cache if available
73     elsif self.user.data_public?
74       user_display_name_cache[self.user_id] = self.user.display_name
75     else
76       user_display_name_cache[self.user_id] = nil
77     end
78
79     el1['user'] = user_display_name_cache[self.user_id] unless user_display_name_cache[self.user_id].nil?
80
81     self.relation_members.each do |member|
82       p=0
83       #if visible_members
84       #  # if there is a list of visible members then use that to weed out deleted segments
85       #  if visible_members[member.member_type][member.member_id]
86       #    p=1
87       #  end
88       #else
89         # otherwise, manually go to the db to check things
90         if member.member.visible?
91           p=1
92         end
93       #end
94       if p
95         e = XML::Node.new 'member'
96         e['type'] = member.member_type
97         e['ref'] = member.member_id.to_s 
98         e['role'] = member.member_role
99         el1 << e
100        end
101     end
102
103     self.relation_tags.each do |tag|
104       e = XML::Node.new 'tag'
105       e['k'] = tag.k
106       e['v'] = tag.v
107       el1 << e
108     end
109     return el1
110   end 
111
112     
113   # collect relationships. currently done in one big block at the end;
114   # may need to move this upwards if people want automatic completion of
115   # relationships, i.e. deliver referenced objects like we do with ways... 
116   # FIXME: rip out the fucking SQL
117   def self.find_for_nodes_and_ways(node_ids, way_ids)
118     relations = []
119
120     if node_ids.length > 0
121       relations += Relation.find_by_sql("select e.* from current_relations e,current_relation_members em where " +
122             "e.visible=1 and " +
123             "em.id = e.id and em.member_type='node' and em.member_id in (#{node_ids.join(',')})")
124     end
125     if way_ids.length > 0
126       relations += Relation.find_by_sql("select e.* from current_relations e,current_relation_members em where " +
127             "e.visible=1 and " +
128             "em.id = e.id and em.member_type='way' and em.member_id in (#{way_ids.join(',')})")
129     end
130
131     relations # if you don't do this then it returns nil and not []
132   end
133
134
135   # FIXME is this really needed?
136   def members
137     unless @members
138       @members = Array.new
139       self.relation_members.each do |member|
140         @members += [[member.member_type,member.member_id,member.member_role]]
141       end
142     end
143     @members
144   end
145
146   def tags
147     unless @tags
148       @tags = Hash.new
149       self.relation_tags.each do |tag|
150         @tags[tag.k] = tag.v
151       end
152     end
153     @tags
154   end
155
156   def members=(m)
157     @members = m
158   end
159
160   def tags=(t)
161     @tags = t
162   end
163
164   def add_member(type,id,role)
165     @members = Array.new unless @members
166     @members += [[type,id,role]]
167   end
168
169   def add_tag_keyval(k, v)
170     @tags = Hash.new unless @tags
171     @tags[k] = v
172   end
173
174   def save_with_history!
175     Relation.transaction do
176       t = Time.now
177       self.version += 1
178       self.timestamp = t
179       self.save!
180
181       tags = self.tags
182       RelationTag.delete_all(['id = ?', self.id])
183       tags.each do |k,v|
184         tag = RelationTag.new
185         tag.k = k
186         tag.v = v
187         tag.id = self.id
188         tag.save!
189       end
190
191       members = self.members
192       RelationMember.delete_all(['id = ?', self.id])
193       members.each do |n|
194         mem = RelationMember.new
195         mem.id = self.id
196         mem.member_type = n[0];
197         mem.member_id = n[1];
198         mem.member_role = n[2];
199         mem.save!
200       end
201
202       old_relation = OldRelation.from_relation(self)
203       old_relation.timestamp = t
204       old_relation.save_with_dependencies!
205     end
206   end
207
208   def delete_with_history(user)
209     if self.visible
210       if RelationMember.find(:first, :joins => "INNER JOIN current_relations ON current_relations.id=current_relation_members.id", :conditions => [ "visible = 1 AND member_type='relation' and member_id=?", self.id ])
211         raise OSM::APIPreconditionFailedError.new
212       else
213         self.user_id = user.id
214         self.tags = []
215         self.members = []
216         self.visible = false
217         save_with_history!
218       end
219     else
220       raise OSM::APIAlreadyDeletedError.new
221     end
222   end
223
224   def update_from(new_relation, user)
225     if !new_relation.preconditions_ok?
226       raise OSM::APIPreconditionFailedError.new
227     else
228       self.user_id = user.id
229       self.tags = new_relation.tags
230       self.members = new_relation.members
231       self.visible = true
232       save_with_history!
233     end
234   end
235
236   def preconditions_ok?
237     self.members.each do |m|
238       if (m[0] == "node")
239         n = Node.find(:first, :conditions => ["id = ?", m[1]])
240         unless n and n.visible 
241           return false
242         end
243       elsif (m[0] == "way")
244         w = Way.find(:first, :conditions => ["id = ?", m[1]])
245         unless w and w.visible and w.preconditions_ok?
246           return false
247         end
248       elsif (m[0] == "relation")
249         e = Relation.find(:first, :conditions => ["id = ?", m[1]])
250         unless e and e.visible and e.preconditions_ok?
251           return false
252         end
253       else
254         return false
255       end
256     end
257     return true
258   rescue
259     return false
260   end
261
262 end