ayadn 1.8.2 → 2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (81) hide show
  1. checksums.yaml +4 -4
  2. data/.gitignore +4 -0
  3. data/CHANGELOG.md +73 -52
  4. data/README.md +17 -3
  5. data/ayadn.gemspec +3 -4
  6. data/doc/01-index.md +6 -5
  7. data/doc/02-install.md +23 -1
  8. data/doc/03-first-steps.md +22 -28
  9. data/doc/04-options.md +1 -1
  10. data/doc/05-streams.md +29 -9
  11. data/doc/06-post.md +13 -5
  12. data/doc/07-actions.md +63 -1
  13. data/doc/08-listings.md +112 -4
  14. data/doc/09-accounts.md +17 -3
  15. data/doc/10-nicerank.md +5 -5
  16. data/doc/11-blacklist.md +8 -14
  17. data/doc/12-alias.md +1 -13
  18. data/doc/14-set.md +8 -110
  19. data/doc/15-nowplaying.md +16 -4
  20. data/doc/18-contact.md +14 -13
  21. data/doc/19-examples.md +2 -0
  22. data/lib/ayadn/action.rb +322 -183
  23. data/lib/ayadn/alias.rb +17 -45
  24. data/lib/ayadn/annotations.rb +1 -1
  25. data/lib/ayadn/api.rb +7 -8
  26. data/lib/ayadn/app.rb +99 -12
  27. data/lib/ayadn/authorize.rb +92 -57
  28. data/lib/ayadn/blacklist.rb +52 -62
  29. data/lib/ayadn/check.rb +81 -74
  30. data/lib/ayadn/cnx.rb +77 -26
  31. data/lib/ayadn/databases.rb +890 -105
  32. data/lib/ayadn/debug.rb +30 -89
  33. data/lib/ayadn/descriptions.rb +876 -329
  34. data/lib/ayadn/endpoints.rb +2 -2
  35. data/lib/ayadn/errors.rb +9 -9
  36. data/lib/ayadn/extend.rb +8 -1
  37. data/lib/ayadn/fileops.rb +10 -8
  38. data/lib/ayadn/mark.rb +79 -56
  39. data/lib/ayadn/migration.rb +427 -0
  40. data/lib/ayadn/nicerank.rb +74 -72
  41. data/lib/ayadn/nowplaying.rb +123 -60
  42. data/lib/ayadn/nowwatching.rb +26 -10
  43. data/lib/ayadn/pinboard.rb +12 -7
  44. data/lib/ayadn/post.rb +40 -37
  45. data/lib/ayadn/profile.rb +5 -2
  46. data/lib/ayadn/scroll.rb +20 -5
  47. data/lib/ayadn/search.rb +30 -22
  48. data/lib/ayadn/set.rb +146 -50
  49. data/lib/ayadn/settings.rb +66 -67
  50. data/lib/ayadn/status.rb +459 -234
  51. data/lib/ayadn/stream.rb +80 -46
  52. data/lib/ayadn/switch.rb +51 -47
  53. data/lib/ayadn/tvshow.rb +47 -15
  54. data/lib/ayadn/version.rb +1 -1
  55. data/lib/ayadn/view.rb +119 -60
  56. data/lib/ayadn/workers.rb +144 -92
  57. data/lib/ayadn.rb +7 -8
  58. data/spec/mock/ayadn/accounts.sqlite +0 -0
  59. data/spec/mock/ayadn.sqlite +0 -0
  60. data/spec/unit/annotations_spec.rb +12 -13
  61. data/spec/unit/api_spec.rb +3 -4
  62. data/spec/unit/blacklistworkers_spec.rb +18 -23
  63. data/spec/unit/databases_spec.rb +51 -36
  64. data/spec/unit/endpoints_spec.rb +5 -2
  65. data/spec/unit/extend_spec.rb +24 -0
  66. data/spec/unit/nicerank_spec.rb +13 -13
  67. data/spec/unit/post_spec.rb +47 -36
  68. data/spec/unit/set_spec.rb +67 -96
  69. data/spec/unit/view_spec.rb +12 -6
  70. data/spec/unit/workers_spec.rb +38 -12
  71. data/tags +1285 -0
  72. metadata +29 -39
  73. data/spec/mock/aliases.db +0 -0
  74. data/spec/mock/blacklist.db +0 -0
  75. data/spec/mock/bookmarks.db +0 -0
  76. data/spec/mock/channels.db +0 -0
  77. data/spec/mock/index.db +0 -0
  78. data/spec/mock/nicerank.db +0 -0
  79. data/spec/mock/pagination.db +0 -0
  80. data/spec/mock/users.db +0 -0
  81. data/spec/unit/status_spec.rb +0 -9
@@ -3,186 +3,971 @@ module Ayadn
3
3
 
4
4
  class Databases
5
5
 
6
- class << self
7
- attr_accessor :users, :index, :pagination, :aliases, :blacklist, :bookmarks, :nicerank, :channels
8
- end
9
-
10
6
  def self.open_databases
11
- if Settings.options[:timeline][:show_debug] == true
12
- puts "\n-Opening databases-\n"
7
+ @sqlfile = "#{Settings.config[:paths][:db]}/ayadn.sqlite"
8
+ @sql = Amalgalite::Database.new(@sqlfile)
9
+ @accounts = Amalgalite::Database.new(Dir.home + "/ayadn/accounts.sqlite")
10
+ end
11
+
12
+ def self.create_tables(user)
13
+ # config is not loaded here, have to specify absolute path
14
+ begin
15
+ sql = Amalgalite::Database.new("#{user.user_path}/db/ayadn.sqlite")
16
+ sql.execute_batch <<-SQL
17
+ CREATE TABLE Bookmarks (
18
+ post_id INTEGER,
19
+ bookmark TEXT
20
+ );
21
+ SQL
22
+ sql.reload_schema!
23
+ sql.execute_batch <<-SQL
24
+ CREATE TABLE Aliases (
25
+ channel_id INTEGER,
26
+ alias VARCHAR(255)
27
+ );
28
+ SQL
29
+ sql.reload_schema!
30
+ sql.execute_batch <<-SQL
31
+ CREATE TABLE Blacklist (
32
+ type VARCHAR(255),
33
+ content TEXT
34
+ );
35
+ SQL
36
+ sql.reload_schema!
37
+ sql.execute_batch <<-SQL
38
+ CREATE TABLE Users (
39
+ user_id INTEGER,
40
+ username VARCHAR(20),
41
+ name TEXT
42
+ );
43
+ SQL
44
+ sql.reload_schema!
45
+ sql.execute_batch <<-SQL
46
+ CREATE TABLE Pagination (
47
+ name TEXT,
48
+ post_id INTEGER
49
+ );
50
+ SQL
51
+ sql.reload_schema!
52
+ sql.execute_batch <<-SQL
53
+ CREATE TABLE TLIndex (
54
+ count INTEGER,
55
+ post_id INTEGER,
56
+ content TEXT
57
+ );
58
+ SQL
59
+ sql.reload_schema!
60
+ rescue Amalgalite::SQLite3::Error => e
61
+ puts "ERROR in Databases"
62
+ puts caller
63
+ puts e
64
+ puts ['create_tables', user].inspect
65
+ exit
13
66
  end
14
- @users = self.init "#{Settings.config[:paths][:db]}/users.db"
15
- @index = self.init "#{Settings.config[:paths][:pagination]}/index.db"
16
- @pagination = self.init "#{Settings.config[:paths][:pagination]}/pagination.db"
17
- @aliases = self.init "#{Settings.config[:paths][:db]}/aliases.db"
18
- @blacklist = self.init "#{Settings.config[:paths][:db]}/blacklist.db"
19
- @bookmarks = self.init "#{Settings.config[:paths][:db]}/bookmarks.db"
20
- @nicerank = self.init "#{Settings.config[:paths][:db]}/nicerank.db"
21
- @channels = self.init "#{Settings.config[:paths][:db]}/channels.db"
22
- if Settings.options[:timeline][:show_debug] == true
23
- puts "\n-Done-\n"
67
+ end
68
+
69
+ def self.add_to_blacklist(type, target)
70
+ crashes = 0
71
+ begin
72
+ remove_from_blacklist(target)
73
+ @sql.transaction do |db_in_transaction|
74
+ target.each do |element|
75
+ insert_data = {}
76
+ insert_data[":type"] = type
77
+ insert_data[":content"] = element.downcase
78
+ db_in_transaction.prepare("INSERT INTO Blacklist(type, content) VALUES(:type, :content);") do |insert|
79
+ insert.execute(insert_data)
80
+ end
81
+ end
82
+ end
83
+ rescue Amalgalite::SQLite3::Error => e
84
+ if crashes < 2
85
+ crashes += 1
86
+ sleep(0.01)
87
+ retry
88
+ else
89
+ puts "ERROR in Databases"
90
+ puts caller
91
+ puts e
92
+ puts ['add_to_blacklist', type, target].inspect
93
+ exit
94
+ end
24
95
  end
25
96
  end
26
97
 
27
- def self.all_dbs
28
- [@users, @index, @pagination, @aliases, @blacklist, @bookmarks, @nicerank, @channels]
98
+ def self.is_in_blacklist?(type, target)
99
+ crashes = 0
100
+ begin
101
+ res = @sql.execute("SELECT * FROM Blacklist WHERE type=(?) AND content=(?)", [type, target.downcase]).flatten
102
+ if res.empty?
103
+ return false
104
+ else
105
+ return true
106
+ end
107
+ rescue Amalgalite::SQLite3::Error => e
108
+ if crashes < 2
109
+ crashes += 1
110
+ sleep(0.01)
111
+ retry
112
+ else
113
+ puts "ERROR in Databases"
114
+ puts caller
115
+ puts e
116
+ puts ['is_in_blacklist?', type, target].inspect
117
+ exit
118
+ end
119
+ end
29
120
  end
30
121
 
31
- def self.close_all
122
+ def self.remove_from_blacklist(target)
123
+ crashes = 0
124
+ begin
125
+ target.each do |el|
126
+ @sql.execute("DELETE FROM Blacklist WHERE content=(?)", [el.downcase])
127
+ end
128
+ rescue Amalgalite::SQLite3::Error => e
129
+ if crashes < 2
130
+ crashes += 1
131
+ sleep(0.01)
132
+ retry
133
+ else
134
+ puts "ERROR in Databases"
135
+ puts caller
136
+ puts e
137
+ puts ['remove_from_blacklist', target].inspect
138
+ exit
139
+ end
140
+ end
141
+ end
32
142
 
33
- if @nicerank.size > 5000
34
- if Settings.options[:timeline][:show_debug] == true
35
- puts "\n-Purging NiceRank database-\n"
143
+ def self.all_blacklist
144
+ crashes = 0
145
+ begin
146
+ @sql.execute("SELECT * FROM Blacklist")
147
+ rescue Amalgalite::SQLite3::Error => e
148
+ if crashes < 2
149
+ crashes += 1
150
+ sleep(0.01)
151
+ retry
152
+ else
153
+ puts "ERROR in Databases"
154
+ puts caller
155
+ puts e
156
+ puts ['all_blacklist'].inspect
157
+ exit
36
158
  end
37
- limit = Time.now - (3600 * 48)
38
- @nicerank.each {|k,v| @nicerank.delete(k) if v[:cached] < limit}
39
159
  end
160
+ end
40
161
 
41
- Debug.db all_dbs
162
+ def self.remove_from_accounts(db, username)
163
+ crashes = 0
164
+ begin
165
+ db.execute("DELETE FROM Accounts WHERE username=(?)", [username.downcase])
166
+ rescue Amalgalite::SQLite3::Error => e
167
+ if crashes < 2
168
+ crashes += 1
169
+ sleep(0.01)
170
+ retry
171
+ else
172
+ puts "ERROR in Databases"
173
+ puts caller
174
+ puts e
175
+ puts ['remove_from_accounts', db, username].inspect
176
+ exit
177
+ end
178
+ end
179
+ end
42
180
 
43
- all_dbs.each do |db|
44
- if Settings.options[:timeline][:show_debug] == true
45
- puts "\n-Closing #{File.basename(db.file)}-"
181
+ # def self.import_blacklist(blacklist)
182
+ # new_list = self.init blacklist
183
+ # new_list.each {|name,type| @blacklist[name] = type}
184
+ # new_list.close
185
+ # end
186
+ # def self.convert_blacklist
187
+ # dummy = {}
188
+ # @blacklist.each {|v,k| dummy[v.downcase] = k}
189
+ # @blacklist.clear
190
+ # dummy.each {|v,k| @blacklist[v] = k}
191
+ # end
192
+
193
+
194
+
195
+ def self.active_account(acc)
196
+ crashes = 0
197
+ begin
198
+ acc.execute("SELECT * FROM Accounts WHERE active=1")[0]
199
+ rescue Amalgalite::SQLite3::Error => e
200
+ if crashes < 2
201
+ crashes += 1
202
+ sleep(0.01)
203
+ retry
204
+ else
205
+ puts "ERROR in Databases"
206
+ puts caller
207
+ puts e
208
+ puts ['active_account', acc].inspect
209
+ exit
46
210
  end
47
- db.flush
48
- db.compact
49
- db.close
50
211
  end
51
212
  end
52
213
 
53
- def self.init(path)
54
- Daybreak::DB.new "#{path}"
214
+ def self.all_accounts(acc)
215
+ crashes = 0
216
+ begin
217
+ acc.execute("SELECT * FROM Accounts")
218
+ rescue Amalgalite::SQLite3::Error => e
219
+ if crashes < 2
220
+ crashes += 1
221
+ sleep(0.01)
222
+ retry
223
+ else
224
+ puts "ERROR in Databases"
225
+ puts caller
226
+ puts e
227
+ puts ['all_accounts', acc].inspect
228
+ exit
229
+ end
230
+ end
55
231
  end
56
232
 
57
- def self.add_niceranks niceranks
58
- niceranks.each {|id,infos| @nicerank[id] = infos}
233
+ def self.set_active_account(acc_db, new_user)
234
+ crashes = 0
235
+ begin
236
+ acc_db.execute("UPDATE Accounts SET active=0")
237
+ acc_db.execute("UPDATE Accounts SET active=1 WHERE username=(?)", [new_user])
238
+ rescue Amalgalite::SQLite3::Error => e
239
+ if crashes < 2
240
+ crashes += 1
241
+ sleep(0.01)
242
+ retry
243
+ else
244
+ puts "ERROR in Databases"
245
+ puts caller
246
+ puts e
247
+ puts ['set_active_account', acc_db, new_user].inspect
248
+ exit
249
+ end
250
+ end
59
251
  end
60
252
 
61
- def self.get_niceranks user_ids
62
- ids = {}
63
- user_ids.each {|id| ids[id] = @nicerank[id]}
64
- ids
253
+ def self.create_account_table(acc_db)
254
+ begin
255
+ acc_db.execute_batch <<-SQL
256
+ CREATE TABLE Accounts (
257
+ username VARCHAR(20),
258
+ user_id INTEGER,
259
+ handle VARCHAR(21),
260
+ account_path TEXT,
261
+ active INTEGER,
262
+ token TEXT
263
+ );
264
+ SQL
265
+ acc_db.reload_schema!
266
+ rescue Amalgalite::SQLite3::Error => e
267
+ puts "ERROR in Databases"
268
+ puts caller
269
+ puts e
270
+ puts ['create_account_table', acc_db].inspect
271
+ exit
272
+ end
65
273
  end
66
274
 
67
- def self.add_user_to_blacklist(target)
68
- target.each {|username| @blacklist["-#{username.downcase}"] = :user}
275
+ def self.create_account(acc_db, user)
276
+ crashes = 0
277
+ begin
278
+ acc_db.execute("DELETE FROM Accounts WHERE username=(?)", [user.username])
279
+ acc_db.transaction do |db|
280
+ insert_data = {}
281
+ insert_data[":username"] = user.username
282
+ insert_data[":user_id"] = user.id
283
+ insert_data[":handle"] = user.handle
284
+ insert_data[":account_path"] = user.user_path
285
+ insert_data[":active"] = 0
286
+ insert_data[":token"] = user.token
287
+ db.prepare("INSERT INTO Accounts(username, user_id, handle, account_path, active, token) VALUES(:username, :user_id, :handle, :account_path, :active, :token);") do |insert|
288
+ insert.execute(insert_data)
289
+ end
290
+ end
291
+ set_active_account(acc_db, user.username)
292
+ rescue Amalgalite::SQLite3::Error => e
293
+ if crashes < 2
294
+ crashes += 1
295
+ sleep(0.01)
296
+ retry
297
+ else
298
+ puts "ERROR in Databases"
299
+ puts caller
300
+ puts e
301
+ puts ['create_account', acc_db, user].inspect
302
+ exit
303
+ end
304
+ end
69
305
  end
70
- def self.add_mention_to_blacklist(target)
71
- target.each {|username| @blacklist[username.downcase] = :mention}
306
+
307
+ def self.create_alias(channel_id, channel_alias)
308
+ crashes = 0
309
+ begin
310
+ delete_alias(channel_alias)
311
+ @sql.transaction do |db_in_transaction|
312
+ insert_data = {}
313
+ insert_data[":k"] = channel_id.to_i
314
+ insert_data[":v"] = channel_alias
315
+ db_in_transaction.prepare("INSERT INTO Aliases(channel_id, alias) VALUES(:k, :v);") do |insert|
316
+ insert.execute(insert_data)
317
+ end
318
+ end
319
+ rescue Amalgalite::SQLite3::Error => e
320
+ if crashes < 2
321
+ crashes += 1
322
+ sleep(0.01)
323
+ retry
324
+ else
325
+ puts "ERROR in Databases"
326
+ puts caller
327
+ puts e
328
+ puts ['create_alias', channel_id, channel_alias].inspect
329
+ exit
330
+ end
331
+ end
72
332
  end
73
- def self.add_client_to_blacklist(target)
74
- target.each {|source| @blacklist[source.downcase] = :client}
333
+
334
+ def self.delete_alias(channel_alias)
335
+ crashes = 0
336
+ begin
337
+ @sql.execute("DELETE FROM Aliases WHERE alias=(?)", [channel_alias])
338
+ rescue Amalgalite::SQLite3::Error => e
339
+ if crashes < 2
340
+ crashes += 1
341
+ sleep(0.01)
342
+ retry
343
+ else
344
+ puts "ERROR in Databases"
345
+ puts caller
346
+ puts e
347
+ puts ['delete_alias', channel_alias].inspect
348
+ exit
349
+ end
350
+ end
75
351
  end
76
- def self.add_hashtag_to_blacklist(target)
77
- target.each {|tag| @blacklist[tag.downcase] = :hashtag}
352
+
353
+ def self.clear_aliases
354
+ crashes = 0
355
+ begin
356
+ @sql.execute("DELETE FROM Aliases")
357
+ rescue Amalgalite::SQLite3::Error => e
358
+ if crashes < 2
359
+ crashes += 1
360
+ sleep(0.01)
361
+ retry
362
+ else
363
+ puts "ERROR in Databases"
364
+ puts caller
365
+ puts e
366
+ puts ['clear_aliases'].inspect
367
+ exit
368
+ end
369
+ end
78
370
  end
79
- def self.remove_from_blacklist(target)
80
- target.each {|el| @blacklist.delete(el.downcase)}
371
+
372
+ def self.get_alias_from_id(channel_id)
373
+ crashes = 0
374
+ begin
375
+ res = @sql.execute("SELECT alias FROM Aliases WHERE channel_id=#{channel_id.to_i}")
376
+ if res.empty?
377
+ return nil
378
+ else
379
+ return res[0][0]
380
+ end
381
+ rescue Amalgalite::SQLite3::Error => e
382
+ if crashes < 2
383
+ crashes += 1
384
+ sleep(0.01)
385
+ retry
386
+ else
387
+ puts "ERROR in Databases"
388
+ puts caller
389
+ puts e
390
+ puts ['get_alias_from_id', channel_id].inspect
391
+ exit
392
+ end
393
+ end
81
394
  end
82
- def self.import_blacklist(blacklist)
83
- new_list = self.init blacklist
84
- new_list.each {|name,type| @blacklist[name] = type}
85
- new_list.close
395
+
396
+ def self.get_channel_id(channel_alias)
397
+ crashes = 0
398
+ begin
399
+ res = @sql.execute("SELECT channel_id FROM Aliases WHERE alias=(?)", [channel_alias])
400
+ if res.empty?
401
+ return nil
402
+ else
403
+ return res[0][0]
404
+ end
405
+ rescue Amalgalite::SQLite3::Error => e
406
+ if crashes < 2
407
+ crashes += 1
408
+ sleep(0.01)
409
+ retry
410
+ else
411
+ puts "ERROR in Databases"
412
+ puts caller
413
+ puts e
414
+ puts ['get_channel_id', channel_alias].inspect
415
+ exit
416
+ end
417
+ end
86
418
  end
87
- def self.convert_blacklist
88
- dummy = {}
89
- @blacklist.each {|v,k| dummy[v.downcase] = k}
90
- @blacklist.clear
91
- dummy.each {|v,k| @blacklist[v] = k}
419
+
420
+ def self.all_aliases
421
+ crashes = 0
422
+ begin
423
+ @sql.execute("SELECT * FROM Aliases")
424
+ rescue Amalgalite::SQLite3::Error => e
425
+ if crashes < 2
426
+ crashes += 1
427
+ sleep(0.01)
428
+ retry
429
+ else
430
+ puts "ERROR in Databases"
431
+ puts caller
432
+ puts e
433
+ puts ['all_aliases'].inspect
434
+ exit
435
+ end
436
+ end
92
437
  end
93
438
 
94
- def self.save_max_id(stream, name = 'unknown')
95
- if stream['meta']['marker'].nil?
96
- key = name
97
- else
98
- key = stream['meta']['marker']['name']
439
+ def self.clear_bookmarks
440
+ crashes = 0
441
+ begin
442
+ @sql.execute("DELETE FROM Bookmarks")
443
+ rescue Amalgalite::SQLite3::Error => e
444
+ if crashes < 2
445
+ crashes += 1
446
+ sleep(0.01)
447
+ retry
448
+ else
449
+ puts "ERROR in Databases"
450
+ puts caller
451
+ puts e
452
+ puts ['clear_bookmarks'].inspect
453
+ exit
454
+ end
99
455
  end
100
- @pagination[key] = stream['meta']['max_id']
101
456
  end
102
457
 
103
- def self.create_alias(channel_id, channel_alias)
104
- @aliases[channel_alias] = channel_id
458
+ def self.clear_pagination
459
+ crashes = 0
460
+ begin
461
+ @sql.execute("DELETE FROM Pagination")
462
+ rescue Amalgalite::SQLite3::Error => e
463
+ if crashes < 2
464
+ crashes += 1
465
+ sleep(0.01)
466
+ retry
467
+ else
468
+ puts "ERROR in Databases"
469
+ puts caller
470
+ puts e
471
+ puts ['clear_pagination'].inspect
472
+ exit
473
+ end
474
+ end
105
475
  end
106
476
 
107
- def self.delete_alias(channel_alias)
108
- @aliases.delete(channel_alias)
477
+ def self.clear_index
478
+ crashes = 0
479
+ begin
480
+ @sql.execute("DELETE FROM TLIndex")
481
+ rescue Amalgalite::SQLite3::Error => e
482
+ if crashes < 2
483
+ crashes += 1
484
+ sleep(0.01)
485
+ retry
486
+ else
487
+ puts "ERROR in Databases"
488
+ puts caller
489
+ puts e
490
+ puts ['clear_index'].inspect
491
+ exit
492
+ end
493
+ end
109
494
  end
110
495
 
111
- def self.clear_aliases
112
- @aliases.clear
496
+ def self.clear_users
497
+ crashes = 0
498
+ begin
499
+ @sql.execute("DELETE FROM Users")
500
+ rescue Amalgalite::SQLite3::Error => e
501
+ if crashes < 2
502
+ crashes += 1
503
+ sleep(0.01)
504
+ retry
505
+ else
506
+ puts "ERROR in Databases"
507
+ puts caller
508
+ puts e
509
+ puts ['clear_users'].inspect
510
+ exit
511
+ end
512
+ end
113
513
  end
114
514
 
115
515
  def self.clear_blacklist
116
- @blacklist.clear
516
+ crashes = 0
517
+ begin
518
+ @sql.execute("DELETE FROM Blacklist")
519
+ rescue Amalgalite::SQLite3::Error => e
520
+ if crashes < 2
521
+ crashes += 1
522
+ sleep(0.01)
523
+ retry
524
+ else
525
+ puts "ERROR in Databases"
526
+ puts caller
527
+ puts e
528
+ puts ['clear_blacklist'].inspect
529
+ exit
530
+ end
531
+ end
117
532
  end
118
533
 
119
- def self.clear_bookmarks
120
- @bookmarks.clear
534
+ def self.add_bookmark bookmark
535
+ crashes = 0
536
+ begin
537
+ delete_bookmark(bookmark['id'])
538
+ @sql.transaction do |db_in_transaction|
539
+ insert_data = {}
540
+ insert_data[":k"] = bookmark['id'].to_i
541
+ insert_data[":v"] = bookmark.to_json.to_s
542
+ db_in_transaction.prepare("INSERT INTO Bookmarks(post_id, bookmark) VALUES(:k, :v);") do |insert|
543
+ insert.execute(insert_data)
544
+ end
545
+ end
546
+ rescue Amalgalite::SQLite3::Error => e
547
+ if crashes < 2
548
+ crashes += 1
549
+ sleep(0.01)
550
+ retry
551
+ else
552
+ puts "ERROR in Databases"
553
+ puts caller
554
+ puts e
555
+ puts ['add_bookmark', bookmark].inspect
556
+ exit
557
+ end
558
+ end
121
559
  end
122
560
 
123
- def self.get_channel_id(channel_alias)
124
- @aliases[channel_alias]
561
+ def self.delete_bookmark post_id
562
+ crashes = 0
563
+ begin
564
+ @sql.execute("DELETE FROM Bookmarks WHERE post_id=#{post_id.to_i}")
565
+ rescue Amalgalite::SQLite3::Error => e
566
+ if crashes < 2
567
+ crashes += 1
568
+ sleep(0.01)
569
+ retry
570
+ else
571
+ puts "ERROR in Databases"
572
+ puts caller
573
+ puts e
574
+ puts ['delete_bookmark', post_id].inspect
575
+ exit
576
+ end
577
+ end
125
578
  end
126
579
 
127
- def self.import_aliases(aliases)
128
- new_aliases = self.init aliases
129
- new_aliases.each {|al,id| @aliases[al] = id}
130
- new_aliases.close
580
+ def self.all_bookmarks
581
+ crashes = 0
582
+ begin
583
+ @sql.execute("SELECT * FROM Bookmarks")
584
+ rescue Amalgalite::SQLite3::Error => e
585
+ if crashes < 2
586
+ crashes += 1
587
+ sleep(0.01)
588
+ retry
589
+ else
590
+ puts "ERROR in Databases"
591
+ puts caller
592
+ puts e
593
+ puts ['all_bookmarks'].inspect
594
+ exit
595
+ end
596
+ end
131
597
  end
132
598
 
133
- def self.get_alias_from_id(channel_id)
134
- @aliases.each {|al, id| return al if id == channel_id}
135
- nil
599
+ def self.rename_bookmark post_id, new_title
600
+ crashes = 0
601
+ begin
602
+ req = @sql.execute("SELECT bookmark FROM Bookmarks WHERE post_id=#{post_id.to_i}")
603
+ if req.empty?
604
+ Errors.global_error({error: "Post doesn't exist", caller: caller, data: [post_id, new_title]})
605
+ else
606
+ bm = JSON.parse(req[0][0])
607
+ bm['title'] = new_title
608
+ @sql.execute("UPDATE Bookmarks SET bookmark=(?) WHERE post_id=#{post_id.to_i}", bm.to_json)
609
+ end
610
+ rescue Amalgalite::SQLite3::Error => e
611
+ if crashes < 2
612
+ crashes += 1
613
+ sleep(0.01)
614
+ retry
615
+ else
616
+ puts "ERROR in Databases"
617
+ puts caller
618
+ puts e
619
+ puts ['rename_bookmark', post_id, new_title].inspect
620
+ exit
621
+ end
622
+ end
136
623
  end
137
624
 
138
625
  def self.save_indexed_posts(posts)
139
- @index.clear
140
- posts.each {|id, hash| @index[id] = hash}
626
+ crashes = 0
627
+ begin
628
+ @sql.execute("DELETE FROM TLIndex")
629
+ @sql.transaction do |db_in_transaction|
630
+ posts.each do |k, v|
631
+ insert_data = {}
632
+ insert_data[":post_id"] = v[:id]
633
+ insert_data[":count"] = v[:count]
634
+ insert_data[":content"] = v.to_json.to_s
635
+ db_in_transaction.prepare("INSERT INTO TLIndex(count, post_id, content) VALUES(:count, :post_id, :content);") do |insert|
636
+ insert.execute(insert_data)
637
+ end
638
+ end
639
+ end
640
+ rescue Amalgalite::SQLite3::Error => e
641
+ if crashes < 2
642
+ crashes += 1
643
+ sleep(0.01)
644
+ retry
645
+ else
646
+ puts "ERROR in Databases"
647
+ puts caller
648
+ puts e
649
+ puts ['save_indexed_posts', posts].inspect
650
+ exit
651
+ end
652
+ end
141
653
  end
142
654
 
143
655
  def self.get_index_length
144
- @index.length
656
+ crashes = 0
657
+ begin
658
+ @sql.execute("SELECT Count(*) FROM TLIndex").flatten[0]
659
+ rescue Amalgalite::SQLite3::Error => e
660
+ if crashes < 2
661
+ crashes += 1
662
+ sleep(0.01)
663
+ retry
664
+ else
665
+ puts "ERROR in Databases"
666
+ puts caller
667
+ puts e
668
+ puts ['get_index_length'].inspect
669
+ exit
670
+ end
671
+ end
145
672
  end
146
673
 
147
- def self.get_post_from_index(number)
148
- unless number > @index.length || number <= 0
149
- @index.each {|id, values| return values if values[:count] == number}
150
- else
151
- puts Status.must_be_in_index
152
- Errors.global_error({error: "Out of range", caller: caller, data: [number]})
674
+ def self.get_post_from_index(arg)
675
+ crashes = 0
676
+ begin
677
+ number = arg.to_i
678
+ unless number > 200
679
+ res = @sql.execute("SELECT content FROM TLIndex WHERE count=#{number}").flatten[0]
680
+ JSON.parse(res)
681
+ else
682
+ {'id' => number}
683
+ # Status.new.must_be_in_index
684
+ # Errors.global_error({error: "Out of range", caller: caller, data: [number]})
685
+ end
686
+ rescue Amalgalite::SQLite3::Error => e
687
+ if crashes < 2
688
+ crashes += 1
689
+ sleep(0.01)
690
+ retry
691
+ else
692
+ puts "ERROR in Databases"
693
+ puts caller
694
+ puts e
695
+ puts ['get_post_from_index', arg].inspect
696
+ exit
697
+ end
153
698
  end
154
699
  end
155
700
 
156
701
  def self.add_to_users_db_from_list(list)
157
- list.each { |id, content_array| @users[id] = {content_array[0] => content_array[1]} }
702
+ crashes = 0
703
+ begin
704
+ delete_users_from_list(list)
705
+ @sql.transaction do |db_in_transaction|
706
+ list.each do |id, content_array|
707
+ insert_data = {}
708
+ insert_data[":id"] = id.to_i
709
+ insert_data[":username"] = content_array[0]
710
+ insert_data[":name"] = content_array[1]
711
+ db_in_transaction.prepare("INSERT INTO Users(user_id, username, name) VALUES(:id, :username, :name);") do |insert|
712
+ insert.execute(insert_data)
713
+ end
714
+ end
715
+ end
716
+ rescue Amalgalite::SQLite3::Error => e
717
+ if crashes < 2
718
+ crashes += 1
719
+ sleep(0.01)
720
+ retry
721
+ else
722
+ puts "ERROR in Databases"
723
+ puts caller
724
+ puts e
725
+ puts ['add_to_users_db_from_list', list].inspect
726
+ exit
727
+ end
728
+ end
729
+ end
730
+
731
+ def self.delete_users_from_list(list)
732
+ crashes = 0
733
+ begin
734
+ list.each {|id, _| @sql.execute("DELETE FROM Users WHERE user_id=#{id.to_i}")}
735
+ rescue Amalgalite::SQLite3::Error => e
736
+ if crashes < 2
737
+ crashes += 1
738
+ sleep(0.01)
739
+ retry
740
+ else
741
+ puts "ERROR in Databases"
742
+ puts caller
743
+ puts e
744
+ puts ['delete_users_from_list', list].inspect
745
+ exit
746
+ end
747
+ end
158
748
  end
159
749
 
160
750
  def self.add_to_users_db(id, username, name)
161
- @users[id] = {username => name}
751
+ crashes = 0
752
+ begin
753
+ @sql.execute("DELETE FROM Users WHERE user_id=#{id.to_i}")
754
+ @sql.execute("INSERT INTO Users VALUES(?, ?, ?)", [id.to_i, username, name])
755
+ rescue Amalgalite::SQLite3::Error => e
756
+ if crashes < 2
757
+ crashes += 1
758
+ sleep(0.01)
759
+ retry
760
+ else
761
+ puts "ERROR in Databases"
762
+ puts caller
763
+ puts e
764
+ puts ['add_to_users_db', id, username, name].inspect
765
+ exit
766
+ end
767
+ end
162
768
  end
163
769
 
164
- def self.has_new?(stream, title)
165
- stream['meta']['max_id'].to_i > @pagination[title].to_i
770
+ def self.find_user_by_id(user_id)
771
+ crashes = 0
772
+ begin
773
+ res = @sql.execute("SELECT username FROM Users WHERE user_id=#{user_id}").flatten
774
+ if res.empty?
775
+ return nil
776
+ else
777
+ return res[0]
778
+ end
779
+ rescue Amalgalite::SQLite3::Error => e
780
+ if crashes < 2
781
+ crashes += 1
782
+ sleep(0.01)
783
+ retry
784
+ else
785
+ puts "ERROR in Databases"
786
+ puts caller
787
+ puts e
788
+ puts ['find_user_by_id', user_id].inspect
789
+ exit
790
+ end
791
+ end
166
792
  end
167
793
 
168
- def self.add_bookmark bookmark
169
- @bookmarks[bookmark[:id]] = bookmark
794
+ def self.find_user_object_by_id(user_id)
795
+ crashes = 0
796
+ begin
797
+ @sql.execute("SELECT * FROM Users WHERE user_id=#{user_id}").flatten
798
+ rescue Amalgalite::SQLite3::Error => e
799
+ if crashes < 2
800
+ crashes += 1
801
+ sleep(0.01)
802
+ retry
803
+ else
804
+ puts "ERROR in Databases"
805
+ puts caller
806
+ puts e
807
+ puts ['find_user_object_by_id', user_id].inspect
808
+ exit
809
+ end
810
+ end
170
811
  end
171
812
 
172
- def self.delete_bookmark post_id
173
- @bookmarks.delete post_id
813
+ def self.all_users
814
+ crashes = 0
815
+ begin
816
+ @sql.execute("SELECT * FROM Users").flatten
817
+ rescue Amalgalite::SQLite3::Error => e
818
+ if crashes < 2
819
+ crashes += 1
820
+ sleep(0.01)
821
+ retry
822
+ else
823
+ puts "ERROR in Databases"
824
+ puts caller
825
+ puts e
826
+ puts ['all_users'].inspect
827
+ exit
828
+ end
829
+ end
174
830
  end
175
831
 
176
- def self.rename_bookmark post_id, new_title
177
- @bookmarks[post_id][:title] = new_title
832
+ def self.all_users_ids
833
+ crashes = 0
834
+ begin
835
+ @sql.execute("SELECT user_id FROM Users").flatten
836
+ rescue Amalgalite::SQLite3::Error => e
837
+ if crashes < 2
838
+ crashes += 1
839
+ sleep(0.01)
840
+ retry
841
+ else
842
+ puts "ERROR in Databases"
843
+ puts caller
844
+ puts e
845
+ puts ['all_users_ids'].inspect
846
+ exit
847
+ end
848
+ end
849
+ end
850
+
851
+ def self.all_pagination
852
+ crashes = 0
853
+ begin
854
+ @sql.execute("SELECT * FROM Pagination").flatten
855
+ rescue Amalgalite::SQLite3::Error => e
856
+ if crashes < 2
857
+ crashes += 1
858
+ sleep(0.01)
859
+ retry
860
+ else
861
+ puts "ERROR in Databases"
862
+ puts caller
863
+ puts e
864
+ puts ['all_pagination'].inspect
865
+ exit
866
+ end
867
+ end
178
868
  end
179
869
 
180
- def self.add_channel_object channel
181
- @channels[channel['id']] = channel
870
+ def self.has_new?(stream, title)
871
+ crashes = 0
872
+ begin
873
+ res = @sql.execute("SELECT post_id FROM Pagination WHERE name=(?)", [title]).flatten[0]
874
+ stream['meta']['max_id'].to_i > res.to_i
875
+ rescue Amalgalite::SQLite3::Error => e
876
+ if crashes < 2
877
+ crashes += 1
878
+ sleep(0.01)
879
+ retry
880
+ else
881
+ puts "ERROR in Databases"
882
+ puts caller
883
+ puts e
884
+ puts ['has_new?', stream, title].inspect
885
+ exit
886
+ end
887
+ end
182
888
  end
183
889
 
184
- def self.remove_channel channel_id
185
- @channels.delete channel_id
890
+ def self.save_max_id(stream, name = 'unknown')
891
+ crashes = 0
892
+ begin
893
+ if stream['meta']['marker'].nil?
894
+ key = name
895
+ else
896
+ key = stream['meta']['marker']['name']
897
+ end
898
+ @sql.execute("DELETE FROM Pagination WHERE name=(?)", [key])
899
+ @sql.execute("INSERT INTO Pagination(name, post_id) VALUES(?, ?);", [key, stream['meta']['max_id'].to_i])
900
+ rescue Amalgalite::SQLite3::Error => e
901
+ if crashes < 2
902
+ crashes += 1
903
+ sleep(0.01)
904
+ retry
905
+ else
906
+ puts "ERROR in Databases"
907
+ puts caller
908
+ puts e
909
+ puts ['save_max_id', stream, name].inspect
910
+ exit
911
+ end
912
+ end
913
+ end
914
+
915
+ def self.find_last_id_from(name)
916
+ crashes = 0
917
+ begin
918
+ @sql.execute("SELECT post_id FROM Pagination WHERE name=(?)", [name]).flatten[0]
919
+ rescue Amalgalite::SQLite3::Error => e
920
+ if crashes < 2
921
+ crashes += 1
922
+ sleep(0.01)
923
+ retry
924
+ else
925
+ puts "ERROR in Databases"
926
+ puts caller
927
+ puts e
928
+ puts ['find_last_id_from', name].inspect
929
+ exit
930
+ end
931
+ end
932
+ end
933
+
934
+ def self.pagination_delete(name)
935
+ crashes = 0
936
+ begin
937
+ @sql.execute("DELETE FROM Pagination WHERE name=(?)", [name])
938
+ rescue Amalgalite::SQLite3::Error => e
939
+ if crashes < 2
940
+ crashes += 1
941
+ sleep(0.01)
942
+ retry
943
+ else
944
+ puts "ERROR in Databases"
945
+ puts caller
946
+ puts e
947
+ puts ['pagination_delete', name].inspect
948
+ exit
949
+ end
950
+ end
951
+ end
952
+
953
+ def self.pagination_insert(name, val)
954
+ crashes = 0
955
+ begin
956
+ @sql.execute("DELETE FROM Pagination WHERE name=(?)", [name])
957
+ @sql.execute("INSERT INTO Pagination(name, post_id) VALUES(?, ?);", [name, val.to_i])
958
+ rescue Amalgalite::SQLite3::Error => e
959
+ if crashes < 2
960
+ crashes += 1
961
+ sleep(0.01)
962
+ retry
963
+ else
964
+ puts "ERROR in Databases"
965
+ puts caller
966
+ puts e
967
+ puts ['pagination_insert', name, val].inspect
968
+ exit
969
+ end
970
+ end
186
971
  end
187
972
 
188
973
  end