| Class | DataService |
| In: |
vendor/plugins/services/lib/data_service.rb
|
| Parent: | BaseService |
Returns true if the user specified (by UUID) can read the data item or data group specified (by UUID)
# File vendor/plugins/services/lib/data_service.rb, line 423
423: def self.canRead?(dataID, userID)
424: ditem = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
425: if ditem != nil
426: # the creator and owner always have permission to read/write.
427: if ditem.creator == userID
428: return true
429: elsif ditem.owner == userID
430: return true
431: else
432: return UserService.checkPermissions(YAML::load(ditem.read_permissions), userID)
433: end
434: else
435: # check data group
436: dgroup = DataGroup.find(:first, :conditions => ["groupingid = ?", dataID])
437: if dgroup != nil
438: if dgroup.creator == userID
439: return true
440: elsif dgroup.owner == userID
441: return true
442: else
443: return UserService.checkPermissions(YAML::load(dgroup.default_read_permissions), userID)
444: end
445: else
446: return false
447: end
448: end
449: end
Returns true if the user specified (by UUID) can write to the data item or data group specified (by UUID)
# File vendor/plugins/services/lib/data_service.rb, line 453
453: def self.canWrite?(dataID, userID)
454: ditem = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
455: if ditem != nil
456: # the creator and owner always have permission to read/write.
457: if ditem.creator == userID
458: return true
459: elsif ditem.owner == userID
460: return true
461: else
462: return UserService.checkPermissions(YAML::load(ditem.write_permissions), userID)
463: end
464: else
465: # check data group
466: dgroup = DataGroup.find(:first, :conditions => ["groupingid = ?", dataID])
467: if dgroup != nil
468: if dgroup.creator == userID
469: return true
470: elsif dgroup.owner == userID
471: return true
472: else
473: return UserService.checkPermissions(YAML::load(dgroup.default_write_permissions), userID)
474: end
475: else
476: return false
477: end
478: end
479: end
Creates a data item with the type and value specified. dataType is a UUID that indicates the type of data kept in this data item. For example, a blog entry is a type of data. valueType may be :string, :object, or :integer, and is the kind of data stored in dataValue. metadata is optional, but if used, should be a hash that looks like this (include only the metadata you want to set):
{
:creator => "UUID",
:creatorapp => "UUID", # the UUID of the service/widget/application that created the item
:description => "A bunch of photos from QuakeCon 2006",
:grouping => "UUID",
:owner => "UUID",
:tags => "personal, images",
:title => "QuakeCon 2006 Photos"
}
Keep in mind that permissions should get set via setPermissions if the defaults don’t suit you. If this item belongs to a pre-existing grouping, and that grouping has default permissions, those will be applied.
Returns the data item’s UUID if successful, raises an exception if not.
# File vendor/plugins/services/lib/data_service.rb, line 68
68: def self.createData(dataType, valueType, dataValue, metadata = nil)
69: dataObj = DataItem.new
70: if metadata != nil
71: creator = metadata[:creator]
72: creatorApp = metadata[:creatorapp]
73: description = metadata[:description]
74: grouping = metadata[:grouping]
75: owner = metadata[:owner]
76: tags = metadata[:tags]
77: title = metadata[:title]
78: else
79: creator = nil
80: creatorApp = nil
81: description = nil
82: grouping = nil
83: owner = nil
84: tags = nil
85: title = nil
86: end
87: if creator == nil
88: creator = NOBODY
89: end
90: if creatorApp == nil
91: creatorApp = @serviceUUID
92: end
93: if grouping == nil
94: grouping = UUIDService.generateUUID
95: end
96: if owner == nil
97: owner = NOBODY
98: end
99: # figure out permissions
100: dgroup = DataGroup.find(:first, :conditions => ["groupingid = ?", grouping])
101: if dgroup != nil
102: if dgroup.default_read_permissions != nil
103: read_perms = YAML::load(dgroup.default_read_permissions)
104: else
105: read_perms = DEFAULT_READ_PERMISSIONS
106: end
107: if dgroup.default_write_permissions != nil
108: write_perms = YAML::load(dgroup.default_write_permissions)
109: else
110: write_perms = DEFAULT_WRITE_PERMISSIONS
111: end
112: else
113: read_perms = DEFAULT_READ_PERMISSIONS
114: write_perms = DEFAULT_WRITE_PERMISSIONS
115: end
116: dataObj.datatype = dataType
117: dataObj.datacreator = creatorApp
118: dataObj.dataid = UUIDService.generateUUID
119: dataObj.grouping = grouping
120: dataObj.owner = owner
121: dataObj.creator = creator
122: dataObj.creation = Time.now.to_i
123: dataObj.tags = tags
124: dataObj.title = title
125: dataObj.description = description
126: case valueType
127: when :string, "string"
128: dataObj.stringdata = dataValue
129: when :integer, "integer"
130: dataObj.integerdata = dataValue
131: when :object, "object"
132: dataObj.integerdata = dataValue.to_yaml
133: else
134: raise ArgumentError
135: end
136: dataObj.read_permissions = read_perms.to_yaml
137: dataObj.write_permissions = write_perms.to_yaml
138: dataObj.save!
139:
140: return dataObj.dataid
141: end
Creates a new data grouping with the specified parameters. groupingID may be nil, if so, it will be generated in this function.
# File vendor/plugins/services/lib/data_service.rb, line 201
201: def self.createDataGroup(groupType, groupingID, title, description, tags, creator, owner, parent)
202: if groupingID == nil
203: groupingID = UUIDService.generateUUID
204: end
205: group = DataGroup.new
206: group.groupingtype = groupType
207: group.creator = creator
208: group.groupingid = groupingID
209: group.owner = owner
210: group.tags = tags
211: group.parent = parent
212: group.title = title
213: group.description = description
214: group.save!
215: return groupingID
216: end
Deletes a data group specified by its groupID
# File vendor/plugins/services/lib/data_service.rb, line 178
178: def self.deleteDataGroup(groupID)
179: dgroup = DataGroup.find(:first, :conditions => ["groupingid = ?", groupID])
180: if dgroup != nil
181: dgroup.destroy
182: return true
183: else
184: return false
185: end
186: end
Deletes a data item specified by its ID
# File vendor/plugins/services/lib/data_service.rb, line 167
167: def self.deleteDataItem(dataID)
168: dataObj = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
169: if dataObj != nil
170: dataObj.destroy
171: return true
172: else
173: return false
174: end
175: end
Returns true if a data item exists, false if not.
# File vendor/plugins/services/lib/data_service.rb, line 189
189: def self.doesDataItemExist?(dataID)
190: dataObj = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
191: if dataObj != nil
192: return true
193: else
194: return false
195: end
196: end
Finds a data grouping.
searchBy may be :type, :parent, :creator, or :owner, and query is the particular parent, creator, or owner you wish to look for. If you’re looking by type only, query should be nil. resultsToReturn is optional, and defaults to returning all results (:all). The other option is to return the first result (:first).
# File vendor/plugins/services/lib/data_service.rb, line 235
235: def self.findDataGrouping(type, searchBy, query, resultsToReturn = :all)
236: if resultsToReturn != :all && resultsToReturn != :first
237: resultsToReturn = :all
238: end
239: case searchBy
240: when :parent, "parent"
241: data = DataGroup.findGroupingsByParent(type, query, resultsToReturn)
242: return data
243: when :creator, "creator"
244: data = DataGroup.findGroupingsByCreator(type, query, resultsToReturn)
245: return data
246: when :owner, "owner"
247: data = DataGroup.findGroupingsByOwner(type, query, resultsToReturn)
248: return data
249: when :type, "type"
250: data = DataGroup.findGroupings(type, resultsToReturn)
251: return data
252: else
253: return nil
254: end
255: end
Gets the specified data, by type (:string, :integer, :object), of the data item specified
# File vendor/plugins/services/lib/data_service.rb, line 23
23: def self.getData(dataID, dataType)
24: ditem = DataItem.findDataItem(dataID)
25: h = Hash.new
26: if ditem != nil
27: case dataType
28: when :string, "string"
29: return ditem.stringdata
30: when :integer, "integer"
31: return ditem.integerdata
32: when :object, "object"
33: h = YAML.load(ditem.objectdata.to_s)
34: return h
35: else
36: return nil
37: end
38: else
39: return nil
40: end
41: end
Gets a group of data and returns an array containing all of the data. To only get a certain type of data in the group, you can specify type. You can also specify the order (by creation time) to return them. :desc is newest first, :asc is oldest first. Default is :desc.
# File vendor/plugins/services/lib/data_service.rb, line 223
223: def self.getDataGroupItems(groupingID, type = nil, order = :desc)
224: return DataItem.findDataByGrouping(groupingID, type, order)
225: end
Gets the metadata associated with a particular data grouping, in a hash. The data that is returned should look like this:
{ :type => "UUID", :creator => "UUID", :owner => "UUID", :tags => "geek, tech blog, programmer", :title => "Ziggy's Blog!", :description => "Bloggity Blog." }
Functions will be provided in the future to lookup UUIDs so types, creators, and owners can be converted into English.
# File vendor/plugins/services/lib/data_service.rb, line 266
266: def self.getDataGroupMetadata(groupingID)
267: dgroup = DataGroup.find(:first, :conditions => ["groupingid = ?", groupingID])
268: if dgroup != nil
269: h = { :type => dgroup.groupingtype, :creator => dgroup.creator, :owner => dgroup.owner, :tags => dgroup.tags, :title => dgroup.title, :description => dgroup.description }
270: return h
271: else
272: return nil
273: end
274: end
Gets the metadata associated with a particular data item, in a hash. The data that is returned should look like this:
{ :type => "UUID", :creator => "UUID", :owner => "UUID", :tags => "stupid, retarded, excellent", :title => "Ten Reasons Coke Sucks", :description => "Ten reasons why I hate Coke", :datacreator => "UUID", :creation => unix_timestamp }
Functions will be provided in the future to lookup UUIDs so that this kind of thing can be looked up.
# File vendor/plugins/services/lib/data_service.rb, line 313
313: def self.getDataItemMetadata(dataID)
314: ditem = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
315: if ditem != nil
316: h = { :type => ditem.datatype, :creator => ditem.creator, :owner => ditem.owner, :tags => ditem.tags, :creation => ditem.creation, :title => ditem.title, :description => ditem.description, :datacreator => ditem.datacreator }
317: return h
318: else
319: return nil
320: end
321: end
Returns an array containing the permissions requested of the data item specified.
# File vendor/plugins/services/lib/data_service.rb, line 381
381: def self.getPermissions(dataID, kind)
382: ditem = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
383: if ditem != nil
384: case kind
385: when :write, "write"
386: p = YAML::load(ditem.write_permissions)
387: return p
388: when :read, "read"
389: p = YAML::load(ditem.read_permissions)
390: return p
391: else
392: return nil
393: end
394: else
395: return nil
396: end
397: end
Modifies the metadata for the specified data group. Valid metadata names are: :type, :creator, :owner, :tags, :title, and :description
# File vendor/plugins/services/lib/data_service.rb, line 279
279: def self.modifyDataGroupMetadata(groupID, name, value)
280: dgroup = DataGroup.find(:first, :conditions => ["groupingid = ?", groupID])
281: if dgroup != nil
282: case name
283: when :type, "type"
284: dgroup.groupingtype = value
285: when :creator, "creator"
286: dgroup.creator = value
287: when :owner, "owner"
288: dgroup.owner = value
289: when :tags, "tags"
290: dgroup.tags = value
291: when :title, "title"
292: dgroup.title = value
293: when :description, "description"
294: dgroup.description = value
295: else
296: return false
297: end
298: dgroup.save!
299: return true
300: else
301: return false
302: end
303: end
Modifies a data item of the type and ID specified. Type can be :string, :integer, or :object
# File vendor/plugins/services/lib/data_service.rb, line 146
146: def self.modifyDataItem(dataID, dataType, data)
147: dataObj = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
148: if dataObj != nil
149: case dataType
150: when :string, "string"
151: dataObj.stringdata = data
152: when :integer, "integer"
153: dataObj.integerdata = data
154: when :object, "object"
155: dataObj.objectdata = data.to_yaml
156: else
157: return false
158: end
159: dataObj.save!
160: return true
161: else
162: return false
163: end
164: end
Modifies the data item metadata specified in name. Name may be :type, :creator, :owner, :tags, :title, :datacreator, or :description.
# File vendor/plugins/services/lib/data_service.rb, line 326
326: def self.modifyDataItemMetadata(dataID, name, value)
327: dataObj = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
328: if dataObj != nil
329: case name
330: when :type, "type"
331: dataObj.datatype = value
332: when :creator, "creator"
333: dataObj.creator = value
334: when :owner, "owner"
335: dataObj.owner = value
336: when :tags, "tags"
337: dataObj.tags = value
338: when :title, "title"
339: dataObj.title = value
340: when :datacreator, "datacreator"
341: dataObj.datacreator = value
342: when :description, "description"
343: dataObj.description = value
344: else
345: return false
346: end
347: dataObj.save!
348: return true
349: else
350: return false
351: end
352: end
Sets the default permissions on a data group. See setPermissions for more info.
# File vendor/plugins/services/lib/data_service.rb, line 401
401: def self.setDefaultPermissions(groupID, kind, value)
402: dgroup = DataGroup.find(:first, :conditions => ["groupingid = ?", groupID])
403: if dgroup != nil
404: case kind
405: when :write, "write"
406: dgroup.default_write_permissions = value.to_yaml
407: dgroup.save!
408: return true
409: when :read, "read"
410: dgroup.default_read_permissions = value.to_yaml
411: dgroup.save!
412: return true
413: else
414: return false
415: end
416: else
417: return false
418: end
419: end
Sets the permissions on a data item. kind is either :read or :write for read permissions and write permissions respectively. value is the permission array (see Services:UserService on the wiki)
# File vendor/plugins/services/lib/data_service.rb, line 359
359: def self.setPermissions(dataID, kind, value)
360: ditem = DataItem.find(:first, :conditions => ["dataid = ?", dataID])
361: if ditem != nil
362: case kind
363: when :write, "write"
364: ditem.write_permissions = value.to_yaml
365: ditem.save!
366: return true
367: when :read, "read"
368: ditem.read_permissions = value.to_yaml
369: ditem.save!
370: return true
371: else
372: return false
373: end
374: else
375: return false
376: end
377: end