Python script, ASCII text executable
1
from app import app, db, bcrypt
2
import git
3
from datetime import datetime
4
from enum import Enum
5
from PIL import Image
6
from cairosvg import svg2png
7
import os
8
import config
9
import cairosvg
10
import random
11
__all__ = [
13
"RepoAccess",
14
"RepoFavourite",
15
"Repo",
16
"UserFollow",
17
"UserNotification",
18
"User",
19
"Notification",
20
"PostVote",
21
"Post",
22
"Commit",
23
"PullRequest",
24
]
25
with (app.app_context()):
27
class RepoAccess(db.Model):
28
id = db.Column(db.Integer, primary_key=True)
29
user_username = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
30
repo_route = db.Column(db.String(98), db.ForeignKey("repo.route"), nullable=False)
31
access_level = db.Column(db.SmallInteger(), nullable=False) # 0 read-only, 1 read-write, 2 admin
32
user = db.relationship("User", back_populates="repo_access")
34
repo = db.relationship("Repo", back_populates="repo_access")
35
__table_args__ = (db.UniqueConstraint("user_username", "repo_route", name="_user_repo_uc"),)
37
def __init__(self, user, repo, level):
39
self.user_username = user.username
40
self.repo_route = repo.route
41
self.access_level = level
42
class RepoFavourite(db.Model):
45
id = db.Column(db.Integer, primary_key=True)
46
user_username = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
47
repo_route = db.Column(db.String(98), db.ForeignKey("repo.route"), nullable=False)
48
notify_commit = db.Column(db.Boolean)
50
user = db.relationship("User", back_populates="favourites")
52
repo = db.relationship("Repo", back_populates="favourites")
53
__table_args__ = (db.UniqueConstraint("user_username", "repo_route", name="_user_repo_uc1"),)
55
def __init__(self, user, repo):
57
self.user_username = user.username
58
self.repo_route = repo.route
59
class PostVote(db.Model):
62
id = db.Column(db.Integer, primary_key=True)
63
user_username = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
64
post_identifier = db.Column(db.String(109), db.ForeignKey("post.identifier"), nullable=False)
65
vote_score = db.Column(db.SmallInteger(), nullable=False)
66
user = db.relationship("User", back_populates="votes")
68
post = db.relationship("Post", back_populates="votes")
69
__table_args__ = (db.UniqueConstraint("user_username", "post_identifier", name="_user_post_uc"),)
71
def __init__(self, user, post, score):
73
self.user_username = user.username
74
self.post_identifier = post.identifier
75
self.vote_score = score
76
class User(db.Model):
79
username = db.Column(db.String(32), unique=True, nullable=False, primary_key=True)
80
display_name = db.Column(db.Unicode(128), unique=False, nullable=True)
81
bio = db.Column(db.Unicode(16384), unique=False, nullable=True)
82
password_hashed = db.Column(db.String(60), nullable=False)
83
email = db.Column(db.String(254), nullable=True)
84
company = db.Column(db.Unicode(64), nullable=True)
85
company_url = db.Column(db.String(256), nullable=True)
86
url = db.Column(db.String(256), nullable=True)
87
show_mail = db.Column(db.Boolean, default=False, nullable=False)
88
location = db.Column(db.Unicode(64), nullable=True)
89
creation_date = db.Column(db.DateTime, default=datetime.utcnow)
90
repositories = db.relationship("Repo", back_populates="owner")
92
followers = db.relationship("UserFollow", back_populates="followed", foreign_keys="[UserFollow.followed_username]")
93
follows = db.relationship("UserFollow", back_populates="follower", foreign_keys="[UserFollow.follower_username]")
94
repo_access = db.relationship("RepoAccess", back_populates="user")
95
votes = db.relationship("PostVote", back_populates="user")
96
favourites = db.relationship("RepoFavourite", back_populates="user")
97
commits = db.relationship("Commit", back_populates="owner")
99
posts = db.relationship("Post", back_populates="owner")
100
prs = db.relationship("PullRequest", back_populates="owner")
101
notifications = db.relationship("UserNotification", back_populates="user")
102
def __init__(self, username, password, email=None, display_name=None):
104
self.username = username
105
self.password_hashed = bcrypt.generate_password_hash(password, config.HASHING_ROUNDS).decode("utf-8")
106
self.email = email
107
self.display_name = display_name
108
# Create the user's directory
110
if not os.path.exists(os.path.join(config.REPOS_PATH, username)):
111
os.makedirs(os.path.join(config.REPOS_PATH, username))
112
if not os.path.exists(os.path.join(config.USERDATA_PATH, username)):
113
os.makedirs(os.path.join(config.USERDATA_PATH, username))
114
avatar_name = random.choice(os.listdir(config.DEFAULT_AVATARS_PATH))
116
if os.path.join(config.DEFAULT_AVATARS_PATH, avatar_name).endswith(".svg"):
117
cairosvg.svg2png(url=os.path.join(config.DEFAULT_AVATARS_PATH, avatar_name),
118
write_to="/tmp/roundabout-avatar.png")
119
avatar = Image.open("/tmp/roundabout-avatar.png")
120
else:
121
avatar = Image.open(os.path.join(config.DEFAULT_AVATARS_PATH, avatar_name))
122
avatar.thumbnail(config.AVATAR_SIZE)
123
avatar.save(os.path.join(config.USERDATA_PATH, username, "avatar.png"))
124
class Repo(db.Model):
127
route = db.Column(db.String(98), unique=True, nullable=False, primary_key=True)
128
owner_name = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
129
name = db.Column(db.String(64), nullable=False)
130
owner = db.relationship("User", back_populates="repositories")
131
visibility = db.Column(db.SmallInteger(), nullable=False)
132
info = db.Column(db.Unicode(512), nullable=True)
133
url = db.Column(db.String(256), nullable=True)
134
creation_date = db.Column(db.DateTime, default=datetime.utcnow)
135
default_branch = db.Column(db.String(64), nullable=True, default="")
137
commits = db.relationship("Commit", back_populates="repo")
139
posts = db.relationship("Post", back_populates="repo")
140
repo_access = db.relationship("RepoAccess", back_populates="repo")
141
favourites = db.relationship("RepoFavourite", back_populates="repo")
142
heads = db.relationship("PullRequest", back_populates="head", foreign_keys="[PullRequest.head_route]")
143
bases = db.relationship("PullRequest", back_populates="base", foreign_keys="[PullRequest.base_route]")
144
last_post_id = db.Column(db.Integer, nullable=False, default=0)
146
def __init__(self, owner, name, visibility):
148
self.route = f"/{owner.username}/{name}"
149
self.name = name
150
self.owner_name = owner.username
151
self.owner = owner
152
self.visibility = visibility
153
# Add the owner as an admin
155
repo_access = RepoAccess(owner, self, 2)
156
db.session.add(repo_access)
157
class Commit(db.Model):
160
identifier = db.Column(db.String(227), unique=True, nullable=False, primary_key=True)
161
sha = db.Column(db.String(128), nullable=False)
162
repo_name = db.Column(db.String(98), db.ForeignKey("repo.route"), nullable=False)
163
owner_name = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
164
owner_identity = db.Column(db.String(321))
165
receive_date = db.Column(db.DateTime, default=datetime.now)
166
author_date = db.Column(db.DateTime)
167
message = db.Column(db.UnicodeText)
168
repo = db.relationship("Repo", back_populates="commits")
169
owner = db.relationship("User", back_populates="commits")
170
def __init__(self, sha, owner, repo, date, message, owner_identity):
172
self.identifier = f"{repo.route}/{sha}"
173
self.sha = sha
174
self.repo_name = repo.route
175
self.repo = repo
176
self.owner_name = owner.username
177
self.owner = owner
178
self.author_date = datetime.fromtimestamp(int(date))
179
self.message = message
180
self.owner_identity = owner_identity
181
class Post(db.Model):
184
identifier = db.Column(db.String(109), unique=True, nullable=False, primary_key=True)
185
number = db.Column(db.Integer, nullable=False)
186
repo_name = db.Column(db.String(98), db.ForeignKey("repo.route"), nullable=False)
187
owner_name = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
188
votes = db.relationship("PostVote", back_populates="post")
189
vote_sum = db.Column(db.Integer, nullable=False, default=0)
190
parent_id = db.Column(db.String(109), db.ForeignKey("post.identifier"), nullable=True)
192
root_id = db.Column(db.String(109), db.ForeignKey("post.identifier"), nullable=True)
193
state = db.Column(db.SmallInteger, nullable=True, default=1)
194
date = db.Column(db.DateTime, default=datetime.now)
196
last_updated = db.Column(db.DateTime, default=datetime.now)
197
subject = db.Column(db.Unicode(384))
198
message = db.Column(db.UnicodeText)
199
repo = db.relationship("Repo", back_populates="posts")
200
owner = db.relationship("User", back_populates="posts")
201
parent = db.relationship("Post", back_populates="children",
202
primaryjoin="Post.parent_id==Post.identifier",
203
foreign_keys="[Post.parent_id]", remote_side="Post.identifier")
204
root = db.relationship("Post",
205
primaryjoin="Post.root_id==Post.identifier",
206
foreign_keys="[Post.root_id]", remote_side="Post.identifier")
207
children = db.relationship("Post",
208
remote_side="Post.parent_id",
209
primaryjoin="Post.identifier==Post.parent_id",
210
foreign_keys="[Post.parent_id]")
211
def __init__(self, owner, repo, parent, subject, message):
213
self.identifier = f"{repo.route}/{repo.last_post_id}"
214
self.number = repo.last_post_id
215
self.repo_name = repo.route
216
self.repo = repo
217
self.owner_name = owner.username
218
self.owner = owner
219
self.subject = subject
220
self.message = message
221
self.parent = parent
222
self.root = parent.parent if parent.parent else parent
223
repo.last_post_id += 1
224
def update_date(self):
226
self.last_updated = datetime.now()
227
with db.session.no_autoflush:
228
if self.parent is not None:
229
self.parent.update_date()
230
class UserNotification(db.Model):
233
id = db.Column(db.Integer, primary_key=True)
234
user_username = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
235
notification_id = db.Column(db.BigInteger, db.ForeignKey("notification.id"))
236
attention_level = db.Column(db.SmallInteger, nullable=False) # 0 is read
237
read_time = db.Column(db.DateTime, nullable=True)
238
user = db.relationship("User", back_populates="notifications")
240
notification = db.relationship("Notification", back_populates="notifications")
241
__table_args__ = (db.UniqueConstraint("user_username", "notification_id", name="_user_notification_uc"),)
243
def __init__(self, user, notification, level):
245
self.user_username = user.username
246
self.notification_id = notification.id
247
self.attention_level = level
248
def read(self):
250
self.read_time = datetime.utcnow
251
self.attention_level = 0
252
class UserFollow(db.Model):
255
id = db.Column(db.Integer, primary_key=True)
256
follower_username = db.Column(db.String(32), db.ForeignKey("user.username", ondelete="CASCADE"), nullable=False)
257
followed_username = db.Column(db.String(32), db.ForeignKey("user.username", ondelete="CASCADE"), nullable=False)
258
follower = db.relationship("User", back_populates="followers", foreign_keys=[follower_username])
260
followed = db.relationship("User", back_populates="follows", foreign_keys=[followed_username])
261
def __init__(self, follower_username, followed_username):
263
self.follower_username = follower_username
264
self.followed_username = followed_username
265
class Notification(db.Model):
268
id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
269
data = db.Column(db.dialects.postgresql.JSONB, nullable=False, default={})
270
notifications = db.relationship("UserNotification", back_populates="notification")
271
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.now)
272
def __init__(self, json):
274
self.data = json
275
class PullRequest(db.Model):
278
id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
279
head_route = db.Column(db.String(98), db.ForeignKey("repo.route", ondelete="CASCADE"), nullable=False)
280
base_route = db.Column(db.String(98), db.ForeignKey("repo.route", ondelete="CASCADE"), nullable=False)
281
owner_name = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
282
state = db.Column(db.SmallInteger, nullable=False, default=0) # 0 pending, 1 merged, 2 rejected
283
head = db.relationship("Repo", back_populates="heads", foreign_keys=[head_route])
285
base = db.relationship("Repo", back_populates="bases", foreign_keys=[base_route])
286
head_branch = db.Column(db.String(64), nullable=False)
288
base_branch = db.Column(db.String(64), nullable=False)
289
owner = db.relationship("User", back_populates="prs")
291
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.now)
292
def __init__(self, head, head_branch, base, base_branch, owner):
294
self.head = head
295
self.base = base
296
self.head_branch = head_branch
297
self.base_branch = base_branch
298
self.owner = owner
299