def settings(self, request):
template = self.view.get_template("settings.html")
try:
with open(self.app.project_dir / "welcome_message.md", "r") as f:
welcome_message = f.read()
except Exception:
welcome_message = """
# Mitamaへようこそ
このページに社内システムの使い方を記述しておきましょう！
"""
if request.method == "POST":
try:
form = SettingsForm(request.post())
welcome_message_ = form["welcome_message"]
if form["role_screen_name"] is not None:
role = Role()
role.name = form['role_name']
role.create()
for screen_name, roles in form['permission'].items():
permission = Permission.retrieve(screen_name=screen_name)
permission.roles = [
Role.retrieve(screen_name=role) for role in roles
]
permission.update()
if form["inner_role_screen_name"] is not None:
inner_role = InnerRole()
inner_role.name = form['inner_role_name']
inner_role.create()
for screen_name, roles in form['inner_permission'].items():
inner_permission = InnerPermission.retrieve(
screen_name=screen_name)
inner_permission.roles = [
InnerRole.retrieve(role) for role in roles
]
inner_permission.update()
with open(self.app.project_dir / "welcome_message.md",
"w") as f:
f.write(welcome_message_)
error = "変更を保存しました"
except ValidationError as err:
error = str(err)
welcome_message = welcome_message_
return Response.render(
template, {
"welcome_message": welcome_message,
'roles': Role.list(),
'permissions': Permission.list(),
'inner_roles': InnerRole.list(),
'inner_permissions': InnerPermission.list(),
"error": error
})
return Response.render(
template, {
"welcome_message": welcome_message,
'roles': Role.list(),
'permissions': Permission.list(),
'inner_roles': InnerRole.list(),
'inner_permissions': InnerPermission.list(),
})
def update_profile(self, req):
template = self.view.get_template("user/update/profile.html")
user = User.retrieve(screen_name=req.params["id"])
roles = Role.list()
error = ""
if req.method == "POST":
try:
form = UserUpdateForm(req.post())
user.screen_name = form["screen_name"]
user.name = form["name"]
user.icon = (resize_icon(form["icon"])
if form["icon"] is not None else user.icon)
roles_ = []
for role in form["roles"]:
roles_.append(Role.retrieve(role))
user.roles = roles_
user.update()
return Response.redirect(
self.app.convert_url("/users/" + user.screen_name +
"/settings"))
except Exception as err:
error = str(err)
return Response.render(
template,
{
"user": user,
"screen_name": user.screen_name,
"name": user.name,
"icon": user.icon,
"roles": roles,
"error": error
},
)
def test_response(self):
res = Response(
text="Hello, world!",
headers={
"hoge": "piyo",
"foo": "bar",
"huga": "hogehuga",
},
status=200,
reason="OK",
content_type="text/html",
charset="utf-8",
)
def start_response(state, headers):
nonlocal self
self.assertEqual(state, "200 OK")
self.assertEqual(
headers,
[
("hoge", "piyo"),
("foo", "bar"),
("huga", "hogehuga"),
("Content-Type", "text/html"),
],
)
output = res.start(None, start_response)
self.assertEqual(output, [b"Hello, world!"])
def update_notification(self, req):
template = self.view.get_template("user/update/notification.html")
user = User.retrieve(screen_name=req.params["id"])
if user._id != req.user._id:
return Response.redirect(self.app.convert_url("/"))
error = ""
if req.method == "POST":
try:
form = SubscriptionForm(req.post())
if form["action"] == "subscribe":
subscription = PushSubscription()
subscription.subscription = form["subscription"]
subscription.create()
user.subscriptions.append(subscription)
user.update()
error = "通知の購読を設定しました"
else:
subscription = PushSubscription.retrieve(
subscription=form["subscription"])
subscription.delete()
error = "通知の購読を解除しました"
except Exception as err:
error = str(err)
return Response.render(
template,
{
"user": user,
"vapid_public_key": self.app.project.vapid["public_key"],
"error": error
},
)
def handle(self, request):
if not is_admin(request.user):
return Response.redirect(self.app.convert_url('/'))
error = ""
if request.method == "POST":
try:
form = SettingsForm(request.post())
for screen_name, permission_roles in form['permission'].items(
):
permission = InnerPermission.retrieve(
screen_name=screen_name)
permission.roles = [
InnerRole.retrieve(screen_name=role)
for role in permission_roles
]
permission.update()
error = "変更を保存しました"
except Exception as err:
error = str(err)
template = self.view.get_template('settings.html')
return Response.render(
template, {
"roles": InnerRole.list(),
"permissions": InnerPermission.list(),
"error": error
})
def create(self, request):
template = self.view.get_template("repo/create.html")
nodes = [*Group.list(), *User.list()]
try:
if request.method == 'POST':
body = request.post()
repo = Repo()
repo.name = body['name']
repo.owner = Node.retrieve(body['owner'])
repo.create()
if not (self.app.project_dir / 'git_template').is_dir:
git.Repo.init(self.app.project_dir / 'git_template',
bare=True)
git.Repo.init(self.app.project_dir /
('repos/' + repo.name + '.git'),
bare=True,
template=self.app.project_dir / 'git_template')
return Response.redirect(self.app.convert_url('/' + repo.name))
except Exception as err:
error = str(err)
traceback.print_exc(err)
return Response.render(template, {
'post': body,
'error': error,
'nodes': nodes
})
return Response.render(template, {'post': dict(), 'nodes': nodes})
def create(self, request):
template = self.view.get_template('merge/create.html')
repo = Repo.retrieve(name=request.params['repo'])
error = ""
if request.method == "POST":
try:
form = MergeCreateForm(request.post())
merge = Merge()
merge.base = form['base']
merge.compare = form['compare']
merge.title = form['title']
merge.body = form['body']
merge.repo = repo
merge.user = request.user
merge.create()
return Response.redirect(
self.app.convert_url('/' + repo.name + '/merge/' +
merge._id))
except Exception as err:
error = str(err)
return Response.render(template, {
"repo": repo,
"entity": repo.entity,
"error": error
})
def create(self, request):
template = self.view.get_template("create.html")
if request.method == "POST":
try:
form = ProfileForm(request.post())
prof = Profile()
prof.name = form["name"]
prof.epoch = form["epoch"]
prof.description = form["description"]
prof.image = form["image"]
for tag_ in [tag.strip() for tag in form["tags"].split(",")]:
tag = Tag(tag_)
Tag.query.session.add(tag)
prof.tags.append(tag)
Tag.query.session.commit()
prof.lcm = form["lcm"] == "on"
prof.mentor = form["mentor"] == "on"
prof.alumnight = form["alumnight"] == "on"
prof.create()
template = self.view.get_template("thanks.html")
return Response.render(template, {
"title": "図鑑登録",
})
except ValidationError as err:
return Response.render(template, {
"title": "図鑑登録",
"error": err.message,
})
return Response.render(template)
def update(self, request):
template = self.view.get_template('hook/update.html')
repo = Repo.retrieve(name=request.params['repo'])
if (repo.owner.object != request.user
and not InnerPermission.is_accepted('update_repository',
repo.owner, request.user)):
return Response.redirect(
self.app.convert_url('/' + request.params['repo'] + '/hook'))
error = ''
if request.method == 'POST':
form = HookCreateForm(request.post())
shutil.move(
self.app.project_dir / 'repos/{}.git/hooks/{}'.format(
repo.name, request.params['hook']), self.app.project_dir /
'repos/{}.git/hooks/{}'.format(repo.name, form['name']))
with open(
self.app.project_dir /
'repos/{}.git/hooks/{}'.format(repo.name, form['name']),
'w') as f:
f.write(form['code'])
return Response.redirect(
self.app.convert_url('/{}/hook/{}'.format(
repo.name, form['name'])))
with open(self.app.project_dir / 'repos/{}.git/hooks/{}'.format(
repo.name, request.params['hook'])) as f:
code = f.read()
return Response.render(
template, {
'repo': repo,
'name': request.params['hook'],
'code': code,
'error': error
})
def first_create(self, request):
template = self.view.get_template("create/profile.html")
error = ""
if request.method == "POST":
try:
form = ProfileForm(request.post())
prof = Profile()
prof.name = form["name"]
prof.ruby = form["ruby"]
prof.epoch = form["epoch"]
prof.image = resize(form["image"])
extra = form["extra"]
prof.email = form["email"]
prof.contactOption = int(form["contactOption"])
prof.contactIdent = form["contactIdent"]
prof.create()
for colid, value in extra.items():
col = ExtraColumn.retrieve(colid)
val = ExtraColumnValue()
val.column = col
val.profile = prof
val.value = value
val.create()
sess = request.session()
sess["profile_id"] = prof._id
return Response.redirect(
self.app.convert_url("/create/second"))
except Exception as err:
error = str(err)
return Response.render(template, {
"title": "図鑑登録",
"error": error,
"extra_columns": ExtraColumn.list()
})
def handle(self, req: Request):
for path in self.paths:
path_ = req.params["path"]
if path_ == "/":
path_ = "./"
elif path_[0] == "/":
path_ = path_[1:]
filename = path / path_
if filename.is_file():
mime = guess_type(
str(filename)) or ("application/octet-stream", )
with open(filename, "rb") as f:
return Response(body=f.read(), content_type=mime[0])
elif (filename / 'index.html').is_file():
mime = guess_type(str(filename / 'index.html'))
with open(filename / 'index.html', "rb") as f:
return Response(body=f.read(), content_type=mime[0])
for path in self.paths:
filename = path / "404.html"
if filename.is_file():
with open(filename) as f:
return Response(
text=f.read(),
status=404,
headers={"content-type": "text/html"},
)
template = self.view.get_template("404.html")
return Response.render(template, status=404)
def create(self, request):
template = self.view.get_template("create/profile.html")
if request.method == "POST":
try:
form = ProfileForm(request.post())
prof = Profile()
prof.name = form["name"]
prof.ruby = form["ruby"]
prof.epoch = form["epoch"]
prof.image = resize(form["image"])
extra = form["extra"]
prof.email = form["email"]
prof.contactOption = int(form["contactOption"])
prof.contactIdent = form["contactIdent"]
prof.create()
careers = form["careers"]
histories = form["histories"]
for career_ in careers.values():
career = Career()
career.type = int(career_["type"])
career.grade = int(career_["grade"])
career.profile = prof
career.create()
for history_ in histories.values():
history = TravelHistory()
history.year = history_["year"]
history.place = history_["place"]
history.profile = prof
history.description = history_["description"]
history.create()
for colid, value in extra.items():
col = ExtraColumn.retrieve(colid)
val = ExtraColumnValue()
val.column = col
val.profile = prof
val.value = value
val.create()
template = self.view.get_template("thanks.html")
return Response.render(template, {
"title": "図鑑登録",
"extra_columns": ExtraColumn.list()
})
except ValidationError as err:
return Response.render(
template, {
"title": "図鑑登録",
"error": err.message,
"extra_columns": ExtraColumn.list()
})
return Response.render(template, {
"title": "図鑑登録",
"extra_columns": ExtraColumn.list()
})
def process(self, request, handler):
sess = request.session()
if request.method == "POST":
session_token = sess["mitama_csrf_token"]
posts = request.post()
if "mitama_csrf_token" not in posts:
return Response(status=400, reason="Bad Request")
post_token = posts["mitama_csrf_token"]
if session_token != post_token:
return Response(status=400, reason="Bad Request")
else:
sess["mitama_csrf_token"] = token_hex(16)
return handler(request)
def login(self, request):
template = self.view.get_template("login.html")
if request.method == "POST":
try:
form = LoginForm(request.post())
result = User.password_auth(form["screen_name"],
form["password"])
sess = request.session()
sess["jwt_token"] = result.get_jwt()
redirect_to = request.query.get("redirect_to", ["/"])[0]
return Response.redirect(redirect_to)
except Exception as err:
return Response.render(template, {"error": err}, status=401)
return Response.render(template, status=401)
def create(self, request):
post = request.post()
try:
group = Group()
group.screen_name = post["screen_name"]
group.name = post["name"]
group.create()
return Response.json(group.to_dict())
except KeyError as err:
error = err
return Response.json({
"error": err.__class__.__name__,
"message": err.message,
"args": err.args,
})
def retrieve(self, request):
try:
id = request.params["id"]
if id.isdigit():
group = Group.retrieve(int(id))
else:
group = Group.retrieve(screen_name=id)
return Response.json(group.to_dict())
except KeyError as err:
error = err
return Response.json({
"error": err.__class__.__name__,
"message": err.message,
"args": err.args,
})
def retrieve(self, request):
template = self.view.get_template("repo/retrieve.html")
repo = Repo.retrieve(name=request.params['repo'])
current_head = request.params.get('head', 'master')
entity = git.Repo(
self.app.project_dir / 'repos/{}.git'.format(repo.name), )
head = getattr(entity.heads, current_head) if hasattr(
entity.heads, current_head) else None
commit = None
tree = None
readme = None
if head:
commit = head.commit
if commit:
tree = commit.tree
if tree:
for blob in tree:
if blob.name.startswith('README'):
readme = blob.data_stream.read().decode('utf-8')
return Response.render(
template, {
'repo': repo,
'current_head': current_head,
'head': head,
'tree': tree,
'entity': entity,
'readme': readme
})
def blob(self, request):
template = self.view.get_template("repo/blob.html")
repo = Repo.retrieve(name=request.params['repo'])
head = request.params.get('head', 'master')
entity = git.Repo(
self.app.project_dir / 'repos/{}.git'.format(repo.name), )
current_head = getattr(entity.heads, head) if hasattr(
entity.heads, head) else None
tree = current_head.commit.tree or None
data = tree / request.params['object']
content = (data.data_stream.read().decode("utf-8") if isinstance(
data, git.objects.blob.Blob) else None)
above = Path("/" + request.params['object']) / '../'
readme = None
if isinstance(data, git.objects.tree.Tree):
for blob in data:
if blob.name.startswith('README'):
readme = blob.data_stream.read().decode('utf-8')
return Response.render(
template, {
'repo': repo,
'current_head': head,
'tree': tree,
'entity': entity,
'name': request.params['object'],
'data': data,
'above': str(above.resolve()),
'content': content,
'readme': readme
})
def create(self, request):
post = request.post()
try:
user = User()
user.screen_name = post["screen_name"]
user.name = post["name"]
user.set_password(post["password"])
user.create()
return Response.json(user.to_dict())
except KeyError as err:
error = err
return Response.json({
"error": err.__class__.__name__,
"message": err.message,
"args": err.args,
})
def delete(self, request):
try:
id = request.params["id"]
if id.isdigit():
group = Group.retrieve(int(id))
else:
group = Group.retrieve(screen_name=id)
group.delete()
return Response.json({"_id": group._id})
except Exception as err:
error = err
return Response.json({
"error": err.__class__.__name__,
"message": err.message,
"args": err.args,
})
def icon(self, request):
try:
id = request.params["id"]
if id.isdigit():
group = Group.retrieve(int(id))
else:
group = Group.retrieve(screen_name=id)
f = magic.Magic(mime=True, uncompress=True)
mime = f.from_buffer(group.icon)
return Response(body=group.icon, content_type=mime)
except KeyError as err:
return Response.error({
"error": err.__class__.__name__,
"message": err.message,
"args": err.args,
})
def update(self, request):
data = request.post()
post = Post.retrieve(int(request.params['pid']))
post.content = data['content']
post.modified = datetime.now()
post.update()
return Response(text=template, content_type='application/json')
def user(self, request):
id = request.params['id']
user = User.retrieve(int(id))
boards = [
bg.board
for bg in BoardGuest.query.filter(BoardGuest.user == user).all()
]
return Response.json(list([board.to_dict() for board in boards]))
def retrieve(self, request):
template = self.view.get_template('merge/retrieve.html')
repo = Repo.retrieve(name=request.params['repo'])
merge = Merge.retrieve(request.params['merge'])
if request.method == 'POST':
post = request.post()
if post['action'] == 'merge':
merge.merge()
merge.delete()
else:
merge.delete()
return Response.redirect(self.app.convert_url('/' + repo.name))
return Response.render(template, {
"repo": repo,
"entity": repo.entity,
"merge": merge
})
def process(self, request, handler):
sess = request.session()
try:
if "jwt_token" in sess:
request.user = User.check_jwt(sess["jwt_token"])
else:
return Response.redirect(
request.app.project.login_page
+ "?redirect_to="
+ urllib.parse.quote(str(request.url), safe="")
)
except Exception:
return Response.redirect(
request.app.project.login_page
+ "?redirect_to="
+ urllib.parse.quote(str(request.url), safe="")
)
return handler(request)
def list(self, req):
template = self.view.get_template("apps/list.html")
apps = AppRegistry()
return Response.render(
template,
{
"apps": apps,
},
)
def list(self, req):
template = self.view.get_template("group/list.html")
groups = Group.tree()
return Response.render(
template,
{
"groups": groups,
},
)
def retrieve(self, req):
template = self.view.get_template("group/retrieve.html")
group = Group.retrieve(screen_name=req.params["id"])
return Response.render(
template,
{
"group": group,
},
)
def list(self, req):
template = self.view.get_template("user/list.html")
users = User.list()
return Response.render(
template,
{
"users": users,
},
)
def retrieve(self, req):
template = self.view.get_template("user/retrieve.html")
user = User.retrieve(screen_name=req.params["id"])
return Response.render(
template,
{
"user": user,
},
)
