1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
#!/usr/bin/python3
import markdown
from flask import (
Flask,
render_template,
Markup,
request,
g,
send_from_directory,
redirect
)
import sqlite3
class dbProxy(object):
def __init__(self, db):
self.conn = sqlite3.connect(db)
self.conn.row_factory = self.dict_factory
self.c = self.conn.cursor()
def create_v0(self):
self.c.execute("CREATE TABLE IF NOT EXISTS jokes(id INTEGER PRIMARY KEY NOT NULL, text TEXT, upvotes INTEGER, downvotes INTEGER, reports INTEGER)")
self.c.execute("CREATE TABLE IF NOT EXISTS votes(id INTEGER PRIMARY KEY NOT NULL, ip TEXT, jokeid INTEGER, type INTEGER)")
def create_v1(self):
self.c.execute("CREATE TABLE IF NOT EXISTS v1_jokes(id INTEGER PRIMARY KEY NOT NULL, text TEXT, format TEXT)")
self.c.execute("CREATE TABLE IF NOT EXISTS v1_users(id INTEGER PRIMARY KEY NOT NULL, identifier TEXT)")
self.c.execute("CREATE TABLE IF NOT EXISTS v1_votes(id INTEGER PRIMARY KEY NOT NULL, joke INTEGER, user INTEGER, type TEXT)")
def migrate_v0to1(self):
self.create_v1()
# create new jokes
j = self.c.execute("SELECT * FROM jokes").fetchall()
j = [(int(n['id']), n['text']) for n in j]
self.c.executemany("INSERT INTO v1_jokes(id, text, format) VALUES(?, ?, 'html')", j)
votes = self.c.execute("SELECT * FROM votes").fetchall()
# create new users
ips = set([v['ip'] for v in votes]) # uniquify
ips = [(ip,) for ip in ips]
self.c.executemany("INSERT INTO v1_users(identifier) VALUES(?)", ips)
# create votes
for vote in votes:
user = int(self.c.execute("SELECT id FROM v1_users WHERE identifier=?", (vote['ip'],)).fetchone()['id'])
if vote['type'] == -1:
vtype = 'down'
if vote['type'] == 0:
vtype = 'report'
if vote['type'] == 1:
vtype = 'up'
self.c.execute("INSERT INTO v1_votes(joke, user, type) VALUES(?, ?, ?)", (vote['jokeid'], user, vtype))
# create pre-v0 votes
self.c.execute("INSERT INTO v1_users(identifier) VALUES ('anonymous')")
anonymous = self.c.lastrowid
jokes = self.c.execute("SELECT id FROM v1_jokes").fetchall()
jokes = [int(j['id']) for j in jokes]
for joke in jokes:
types = (
("up", "upvotes"),
("down", "downvotes"),
("report", "reports")
)
for newtype, oldtype in types:
legal_votes = int(self.c.execute("SELECT COUNT(*) FROM v1_votes WHERE id=? AND type=?", (joke, newtype)).fetchone()['COUNT(*)'])
real_votes = int(self.c.execute("SELECT * FROM jokes WHERE id=?", (joke,)).fetchone()[oldtype])
diff = real_votes - legal_votes
if diff:
self.c.executemany("INSERT INTO v1_votes(joke, user, type) VALUES(?, ?, ?)", [(joke, anonymous, newtype)]*diff)
# drop old tables
self.c.execute("DROP TABLE jokes")
self.c.execute("DROP TABLE IF EXISTS votes")
# write
self.conn.commit()
def database_v(self):
versions = {
'jokes': 0,
'v1_jokes': 1
}
for ver in versions:
if self.c.execute("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?", (ver,)).fetchone()['COUNT(*)'] == 1:
return versions[ver]
return -1
def create(self):
if self.database_v() == 0:
print("migrating v0 to v1")
self.migrate_v0to1()
if self.database_v() == -1:
print("creating new v1 db")
self.create_v1()
def close(self):
self.conn.close()
def dict_factory(self, cursor, row):
d = {}
for idx, col in enumerate(cursor.description):
d[col[0]] = row[idx]
return d
def sort(self, joke):
#interactions = joke["reports"]*5 + joke["upvotes"] + joke["downvotes"] + 1
#score = 1/interactions * (joke["upvotes"]+1)/interactions
score = joke["upvotes"] - joke["downvotes"] - joke["reports"]*5
return score
def getPages(self, perpage):
l = self.c.execute("SELECT COUNT(*) FROM v1_jokes").fetchone()['COUNT(*)']
return int(l/perpage)+1
def getJokes(self, perpage, page):
ret_jokes = []
jokes = self.c.execute("SELECT * FROM v1_jokes").fetchall()
for joke in jokes:
if joke['format'] == 'markdown':
html = Markup(markdown.markdown(joke['text'], extensions=['markdown.extensions.nl2br'], output_format="html5", safe_mode="remove")) # TODO safe_mode deprecated
if joke['format'] == 'html':
html = joke['text']
ret_joke = {
'id': joke['id'],
'text': html
}
typemap = (
("up", "upvotes"),
("down", "downvotes"),
("report", "reports")
)
for key, tag in typemap:
ret_joke[tag] = self.c.execute("SELECT COUNT(*) FROM v1_votes WHERE joke=? AND type=?", (joke['id'], key)).fetchone()['COUNT(*)']
ret_jokes.append(ret_joke)
ret_jokes = sorted(ret_jokes, key=self.sort, reverse=True)
return ret_jokes[page*perpage:(page+1)*perpage]
def addJoke(self, text):
self.c.execute("INSERT INTO v1_jokes(text, format) VALUES(?, 'markdown')", (text,))
self.conn.commit()
def userByIp(self, ip):
user = self.c.execute("SELECT * FROM v1_users WHERE identifier=?", (ip,)).fetchone()
if user:
return user['id']
else:
self.c.execute("INSERT INTO v1_users(identifier) VALUES(?)", (ip,))
self.conn.commit()
return self.c.lastrowid
def voteJoke(self, objectId, down, ip):
user = self.userByIp(ip)
self.c.execute("INSERT INTO v1_votes(joke, user, type) VALUES(?, ?, ?)", (objectId, user, 'down' if down else 'up'))
self.conn.commit()
def reportJoke(self, objectId, ip):
user = self.userByIp(ip)
self.c.execute("INSERT INTO v1_votes(joke, user, type) VALUES(?, ?, 'report')", (objectId, user))
self.conn.commit()
def getUserVotes(self, ip):
user = self.userByIp(ip)
votes = self.c.execute("SELECT joke FROM v1_votes WHERE user=?", (user,)).fetchall()
votes = [v['joke'] for v in votes]
return votes
def db():
db = getattr(g, "_database", None)
if db is None:
db = g._database = dbProxy("votes.db")
db.create()
return db
app = Flask(__name__)
PERPAGE = 10
@app.teardown_appcontext
def close_db(exception):
db = getattr(g, "_database", None)
if db is not None:
db.close()
@app.route('/')
def root():
return page(0)
@app.route('/page/<int:num>')
def page(num):
numpages = db().getPages(PERPAGE)
jokes = db().getJokes(PERPAGE, num)
ip = request.remote_addr
votes = db().getUserVotes(ip)
for joke in jokes:
if joke['id'] in votes:
joke['locked'] = True
return render_template('index.html', currentpage=num, pages=[[]]*numpages, jokes=jokes)
@app.route('/submit', methods=['POST'])
def submit():
text = request.form['text']
page = request.form['redirpage']
db().addJoke(text)
return redirect('/page/' + page)
@app.route('/vote', methods=['POST'])
def vote():
objectId = int(request.form['id'])
page = request.form['redirpage']
ip = request.remote_addr
if objectId not in db().getUserVotes(ip):
db().voteJoke(objectId, request.form['vote'] == 'downvote', ip)
return redirect('/page/' + page)
@app.route('/report', methods=['POST'])
def report():
objectId = int(request.form['id'])
page = request.form['redirpage']
ip = request.remote_addr
if objectId not in db().getUserVotes(ip):
db().reportJoke(objectId, ip)
return redirect('/page/' + page)
@app.route('/static/<path:path>')
def get_static(path):
return send_from_directory('static', path)
app.debug = True
if __name__ == '__main__':
app.run(host="0.0.0.0")
|
