def group_page(request, group):
"""
Main page for group `group`
"""
group = group.replace("-", " ").replace("_", " ")
group = Group().load({"name": group})
if not group:
raise Http404
if request.user.is_authenticated() and group.is_member(request.user.id):
if not request.COOKIES.get('s1'):
return s2_group_sheets(request, group.name, True)
in_group = True
query = {"status": {"$in": ["unlisted","public"]}, "group": group.name}
else:
if not request.COOKIES.get('s1'):
return s2_group_sheets(request, group.name, False)
in_group = False
query = {"status": "public", "group": group.name}
sheets = db.sheets.find(query).sort([["title", 1]])
tags = sheet_tag_counts(query)
return render_to_response('sheets_list.html', {"sheets": sheets,
"tags": tags,
"status": "unlisted",
"group": group,
"in_group": in_group,
"title": "%s on Sefaria" % group.name,
}, RequestContext(request))
def view_sheet(request, sheet_id):
"""
View the sheet with sheet_id.
"""
sheet = get_sheet(sheet_id)
if "error" in sheet:
return HttpResponse(sheet["error"])
sheet["sources"] = annotate_user_links(sheet["sources"])
# Count this as a view
db.sheets.update({"id": int(sheet_id)}, {"$inc": {"views": 1}})
try:
owner = User.objects.get(id=sheet["owner"])
author = owner.first_name + " " + owner.last_name
owner_groups = get_user_groups(request.user.id) if sheet["owner"] == request.user.id else None
except User.DoesNotExist:
author = "Someone Mysterious"
owner_groups = None
sheet_class = make_sheet_class_string(sheet)
sheet_group = Group().load({"name": sheet["group"]}) if "group" in sheet and sheet["group"] != "None" else None
embed_flag = "embed" in request.GET
likes = sheet.get("likes", [])
like_count = len(likes)
if request.user.is_authenticated():
can_edit_flag = can_edit(request.user, sheet)
can_add_flag = can_add(request.user, sheet)
can_publish_flag = sheet_group.can_publish(request.user.id) if sheet_group else False
viewer_is_liker = request.user.id in likes
else:
can_edit_flag = False
can_add_flag = False
can_publish_flag = False
viewer_is_liker = False
canonical_url = request.get_full_path().replace("?embed=1", "").replace("&embed=1", "")
return render_to_response('sheets.html' if request.COOKIES.get('s1') else 's2_sheets.html', {"sheetJSON": json.dumps(sheet),
"sheet": sheet,
"sheet_class": sheet_class,
"can_edit": can_edit_flag,
"can_add": can_add_flag,
"can_publish": can_publish_flag,
"title": sheet["title"],
"author": author,
"is_owner": request.user.id == sheet["owner"],
"is_public": sheet["status"] == "public",
"owner_groups": owner_groups,
"sheet_group": sheet_group,
"like_count": like_count,
"viewer_is_liker": viewer_is_liker,
"current_url": request.get_full_path,
"canonical_url": canonical_url,
"assignments_from_sheet":assignments_from_sheet(sheet_id),
}, RequestContext(request))
def private_sheet_list_api(request, group):
group = group.replace("-", " ").replace("_", " ")
group = Group().load({"name": group})
if not group:
raise Http404
if request.user.is_authenticated and group.is_member(request.user.id):
return jsonResponse(group_sheets(group, True), callback=request.GET.get("callback", None))
else:
return jsonResponse(group_sheets(group, False), callback=request.GET.get("callback", None))
def groups_invite_api(request, group_name, uid_or_email, uninvite=False):
"""
API for adding or removing group members, or group invitations
"""
if request.method != "POST":
return jsonResponse({"error": "Unsupported HTTP method."})
group = Group().load({"name": group_name})
if not group:
return jsonResponse({"error": "No group named %s." % group_name})
if request.user.id not in group.admins:
return jsonResponse({"error": "You must be a group admin to invite new members."})
user = UserProfile(email=uid_or_email)
if not user.exists():
if uninvite:
group.remove_invitation(uid_or_email)
message = "Invitation removed."
else:
group.invite_member(uid_or_email, request.user.id)
message = "Invitation sent."
else:
is_new_member = not group.is_member(user.id)
if is_new_member:
group.add_member(user.id)
from sefaria.model.notification import Notification
notification = Notification({"uid": user.id})
notification.make_group_add(adder_id=request.user.id, group_name=group_name)
notification.save()
message = "Group member added."
else:
message = "%s is already a member of this group." % user.full_name
group_content = group.contents(with_content=True, authenticated=True)
return jsonResponse({"group": group_content, "message": message})
def edit_group_page(request, group=None):
if group:
group = group.replace("-", " ").replace("_", " ")
group = Group().load({"name": group})
if not group:
raise Http404
groupData = group.contents()
else:
groupData = None
return render_to_response('edit_group.html', {"groupData": groupData}, RequestContext(request))
def groups_pin_sheet_api(request, group_name, sheet_id):
if request.method != "POST":
return jsonResponse({"error": "Unsupported HTTP method."})
group = Group().load({"name": group_name})
if not group:
return jsonResponse({"error": "No group named %s." % group_name})
if request.user.id not in group.admins:
return jsonResponse({"error": "You must be a group admin to invite new members."})
sheet_id = int(sheet_id)
group.pin_sheet(sheet_id)
group_content = group.contents(with_content=True, authenticated=True)
return jsonResponse({"group": group_content, "status": "success"})
def groups_api(request, group=None):
if request.method == "GET":
if not group:
return jsonResponse({
"private": [g.listing_contents() for g in GroupSet().for_user(request.user.id)],
"public": [g.listing_contents() for g in GroupSet({"listed": True, "moderationStatus": {"$ne": "nolist"}}, sort=[("name", 1)])]
})
group = Group().load({"name": group})
if not group:
return jsonResponse({"error": "No group named '%s'" % group})
is_member = request.user.is_authenticated and group.is_member(request.user.id)
group_content = group.contents(with_content=True, authenticated=is_member)
return jsonResponse(group_content)
else:
return groups_post_api(request, group_name=group)
def groups_role_api(request, group_name, uid, role):
"""
API for setting a group members role, or removing them from a group.
"""
if request.method != "POST":
return jsonResponse({"error": "Unsupported HTTP method."})
group = Group().load({"name": group_name})
if not group:
return jsonResponse({"error": "No group named %s." % group_name})
uid = int(uid)
if request.user.id not in group.admins:
if not (uid == request.user.id and role == "remove"): # non admins can remove themselves
return jsonResponse({"error": "You must be a group admin to change member roles."})
user = UserProfile(uid)
if not user.exists():
return jsonResponse({"error": "No user with the specified ID exists."})
if role not in ("member", "publisher", "admin", "remove"):
return jsonResponse({"error": "Unknown group member role."})
if uid == request.user.id and group.admins == [request.user.id] and role != "admin":
return jsonResponse({"error": "This action would leave the group without any admins. Please appoint another admin first."})
if role == "remove":
group.remove_member(uid)
else:
group.add_member(uid, role)
group_content = group.contents(with_content=True, authenticated=True)
return jsonResponse(group_content)
def groups_post_api(request, group_name=None):
if request.method == "POST":
j = request.POST.get("json")
if not j:
return jsonResponse({"error": "No JSON given in post data."})
group = json.loads(j)
existing = Group().load({"name": group.get("previousName", group["name"])})
if existing:
# Don't overwrite existing group when posting to create a new group
if "new" in group:
return jsonResponse({"error": "A group with this name already exists."})
# check poster is a group admin
if request.user.id not in existing.admins:
return jsonResponse({"error": "You do not have permission to edit this group."})
from pprint import pprint
pprint(group)
existing.load_from_dict(group)
existing.save()
else:
if "-" in group["name"] or "_" in group["name"]:
return jsonResponse({"error": 'Group names may not contain "-" or "_".'})
del group["new"]
group["admins"] = [request.user.id]
group["publishers"] = []
group["members"] = []
Group(group).save()
return jsonResponse({"status": "ok"})
elif request.method == "DELETE":
if not group_name:
return jsonResponse({"error": "Please specify a group name in the URL."})
existing = Group().load({"name": group_name})
if existing:
if request.user.id not in existing.admins:
return jsonResponse({"error": "You do not have permission to delete this group."})
else:
GroupSet({"name": group_name}).delete()
return jsonResponse({"status": "ok"})
else:
return jsonResponse({"error": "Group named %s does not exist" % group_name})
else:
return jsonResponse({"error": "Unsupported HTTP method."})
# -*- coding: utf-8 -*-
import django
django.setup()
from sefaria.model.group import Group
g = Group().load({"name": u"גיליונות נחמה"})
g.toc = {
"categories": ["Tanakh", "Commentary"],
"title": "The Nechama Leibowitz Collection",
"heTitle": u"גיליונות נחמה",
"collectiveTitle": {
"en": "Nechama Leibowitz",
"he": u"נחמה ליבוביץ",
},
"description": "<span class='dedication'>In loving memory of our mother, grandmother, and great-grandmother Miriam Magda Reichner<br>The Rubinstein, Koschitzky & Pertman families<br> Toronto, Canada and Raanana, Israel</span>",
"heDescription": u"<span class='dedication'>לעילוי נשמת אמנו, סבתנו, וסבתא רבתא שלנו מרים רייכנער<br>נדבת משפחות רובינשטיין, קושיצקי ופרטמן<br>טורונטו, קנדה ורעננה, ישראל</span class='dedication'>"}
g.save()
# -*- coding: utf-8 -*-
"""
Creates a group document in Mongo for each Django Group.
"""
from django.contrib.auth.models import Group
from sefaria.model.group import Group as NewGroup
from sefaria.model.group import GroupSet
GroupSet().delete()
groups = Group.objects.all()
for group in groups:
print group.name
base = "http://www.sefaria.org/static/partner/"
path = group.name.replace(" ", "_")
newGroup = NewGroup({
"name": group.name,
"coverUrl": base + path + "/logo.png",
"headerUrl": base + path + "/header.png",
})
newGroup.save()
def view_sheet(request, sheet_id):
"""
View the sheet with sheet_id.
"""
panel = request.GET.get('panel', '0')
if panel == '1':
return catchall(request, sheet_id, True)
sheet = get_sheet(sheet_id)
if "error" in sheet:
return HttpResponse(sheet["error"])
sheet["sources"] = annotate_user_links(sheet["sources"])
# Count this as a view
db.sheets.update({"id": int(sheet_id)}, {"$inc": {"views": 1}})
try:
owner = User.objects.get(id=sheet["owner"])
author = owner.first_name + " " + owner.last_name
owner_groups = get_user_groups(
request.user.id) if sheet["owner"] == request.user.id else None
except User.DoesNotExist:
author = "Someone Mysterious"
owner_groups = None
sheet_class = make_sheet_class_string(sheet)
sheet_group = Group().load({
"name": sheet["group"]
}) if "group" in sheet and sheet["group"] != "None" else None
embed_flag = "embed" in request.GET
likes = sheet.get("likes", [])
like_count = len(likes)
if request.user.is_authenticated:
can_edit_flag = can_edit(request.user, sheet)
can_add_flag = can_add(request.user, sheet)
can_publish_flag = sheet_group.can_publish(
request.user.id) if sheet_group else False
viewer_is_liker = request.user.id in likes
else:
can_edit_flag = False
can_add_flag = False
can_publish_flag = False
viewer_is_liker = False
canonical_url = request.get_full_path().replace("?embed=1", "").replace(
"&embed=1", "")
return render(
request, 'sheets.html', {
"sheetJSON": json.dumps(sheet),
"sheet": sheet,
"sheet_class": sheet_class,
"can_edit": can_edit_flag,
"can_add": can_add_flag,
"can_publish": can_publish_flag,
"title": sheet["title"],
"author": author,
"is_owner": request.user.id == sheet["owner"],
"is_public": sheet["status"] == "public",
"owner_groups": owner_groups,
"sheet_group": sheet_group,
"like_count": like_count,
"viewer_is_liker": viewer_is_liker,
"current_url": request.get_full_path,
"canonical_url": canonical_url,
"assignments_from_sheet": assignments_from_sheet(sheet_id),
})
from sefaria.system.database import db
from sefaria.model.group import Group
from django.contrib.auth.models import User
from django.contrib.auth.models import Group as DjangoGroup
skip = ["Editors", "User Seeds"]
groups = DjangoGroup.objects.all()
for dgroup in groups:
if dgroup.name in skip:
continue
print(dgroup.name)
admins = [u.id for u in dgroup.user_set.all()]
group = Group().load({"name": dgroup.name})
fields = {
"name": dgroup.name,
"admins": admins,
"publishers": [],
"members": [],
}
if group:
fields["imageUrl"] = getattr(group, "coverUrl", None)
group.load_from_dict(fields)
group.save()
else:
Group(fields).save()
db.groups.create_index("name", unique=True)
db.groups.create_index("admins")
db.groups.create_index("publishers")
db.groups.create_index("members")
db.groups.create_index("listed")
# -*- coding: utf-8 -*-
import django
django.setup()
from sefaria.model.group import Group
g = Group().load({"name": "גיליונות נחמה"})
g.toc = {
"categories": ["Tanakh", "Commentary"],
"title":
"The Nechama Leibowitz Collection",
"heTitle":
"גיליונות נחמה",
"collectiveTitle": {
"en": "Nechama Leibowitz",
"he": "נחמה ליבוביץ",
},
"description":
"<span class='dedication'>In loving memory of our mother, grandmother, and great-grandmother Miriam Magda Reichner<br>The Rubinstein, Koschitzky & Pertman families<br> Toronto, Canada and Raanana, Israel</span>",
"heDescription":
"<span class='dedication'>לעילוי נשמת אמנו, סבתנו, וסבתא רבתא שלנו מרים רייכנער<br>נדבת משפחות רובינשטיין, קושיצקי ופרטמן<br>טורונטו, קנדה ורעננה, ישראל</span class='dedication'>"
}
g.save()
# -*- coding: utf-8 -*-
"""
Creates a group document in Mongo for each Django Group.
"""
from django.contrib.auth.models import Group
from sefaria.model.group import Group as NewGroup
from sefaria.model.group import GroupSet
GroupSet().delete()
groups = Group.objects.all()
for group in groups:
print(group.name)
base = "http://www.sefaria.org/static/partner/"
path = group.name.replace(" ", "_")
newGroup = NewGroup({
"name": group.name,
"coverUrl": base + path + "/logo.png",
"headerUrl": base + path + "/header.png",
})
newGroup.save()
def get_sheets_for_ref(tref, uid=None, in_group=None):
"""
Returns a list of sheets that include ref,
formating as need for the Client Sidebar.
If `uid` is present return user sheets, otherwise return public sheets.
If `in_group` (list) is present, only return sheets in one of the listed groups.
"""
oref = model.Ref(tref)
# perform initial search with context to catch ranges that include a segment ref
regex_list = oref.context_ref().regex(as_list=True)
ref_clauses = [{"includedRefs": {"$regex": r}} for r in regex_list]
query = {"$or": ref_clauses}
if uid:
query["owner"] = uid
else:
query["status"] = "public"
if in_group:
query["group"] = {"$in": in_group}
sheetsObj = db.sheets.find(
query, {
"id": 1,
"title": 1,
"owner": 1,
"viaOwner": 1,
"via": 1,
"dateCreated": 1,
"includedRefs": 1,
"views": 1,
"tags": 1,
"status": 1,
"summary": 1,
"attribution": 1,
"assigner_id": 1,
"likes": 1,
"group": 1,
"options": 1
}).sort([["views", -1]])
sheets = list((s for s in sheetsObj))
user_ids = list(set([s["owner"] for s in sheets]))
django_user_profiles = User.objects.filter(id__in=user_ids).values(
'email', 'first_name', 'last_name', 'id')
user_profiles = {item['id']: item for item in django_user_profiles}
mongo_user_profiles = list(
db.profiles.find({"id": {
"$in": user_ids
}}, {
"id": 1,
"slug": 1
}))
mongo_user_profiles = {item['id']: item for item in mongo_user_profiles}
for profile in user_profiles:
user_profiles[profile]["slug"] = mongo_user_profiles[profile]["slug"]
ref_re = "(" + '|'.join(regex_list) + ")"
results = []
for sheet in sheets:
potential_matches = [
r for r in sheet["includedRefs"] if r.startswith(oref.index.title)
]
matched_refs = [r for r in potential_matches if regex.match(ref_re, r)]
for match in matched_refs:
try:
match = model.Ref(match)
except InputError:
continue
ownerData = user_profiles.get(
sheet["owner"], {
'first_name': u'Ploni',
'last_name': u'Almoni',
'email': u'*****@*****.**',
'slug': 'Ploni-Almoni',
'id': None
})
default_image = "https://www.sefaria.org/static/img/profile-default.png"
gravatar_base = "https://www.gravatar.com/avatar/" + hashlib.md5(
ownerData["email"].lower()).hexdigest() + "?"
gravatar_url_small = gravatar_base + urllib.urlencode({
'd': default_image,
's': str(80)
})
if "assigner_id" in sheet:
asignerData = public_user_data(sheet["assigner_id"])
sheet["assignerName"] = asignerData["name"]
sheet["assignerProfileUrl"] = asignerData["profileUrl"]
if "viaOwner" in sheet:
viaOwnerData = public_user_data(sheet["viaOwner"])
sheet["viaOwnerName"] = viaOwnerData["name"]
sheet["viaOwnerProfileUrl"] = viaOwnerData["profileUrl"]
if "group" in sheet:
group = Group().load({"name": sheet["group"]})
sheet["groupLogo"] = getattr(group, "imageUrl", None)
sheet["groupTOC"] = getattr(group, "toc", None)
sheet_data = {
"owner":
sheet["owner"],
"_id":
str(sheet["_id"]),
"id":
str(sheet["id"]),
"anchorRef":
match.normal(),
"anchorVerse":
match.sections[-1] if len(match.sections) else 1,
"public":
sheet["status"] == "public",
"title":
strip_tags(sheet["title"]),
"sheetUrl":
"/sheets/" + str(sheet["id"]),
"options":
sheet["options"],
"naturalDateCreated":
naturaltime(
datetime.strptime(sheet["dateCreated"],
"%Y-%m-%dT%H:%M:%S.%f")),
"group":
sheet.get("group", None),
"groupLogo":
sheet.get("groupLogo", None),
"groupTOC":
sheet.get("groupTOC", None),
"ownerName":
ownerData["first_name"] + " " + ownerData["last_name"],
"via":
sheet.get("via", None),
"viaOwnerName":
sheet.get("viaOwnerName", None),
"assignerName":
sheet.get("assignerName", None),
"viaOwnerProfileUrl":
sheet.get("viaOwnerProfileUrl", None),
"assignerProfileUrl":
sheet.get("assignerProfileUrl", None),
"ownerProfileUrl":
"/profile/" + ownerData["slug"],
"ownerImageUrl":
gravatar_url_small,
"status":
sheet["status"],
"views":
sheet["views"],
"tags":
sheet.get("tags", []),
"likes":
sheet.get("likes", []),
"summary":
sheet.get("summary", None),
"attribution":
sheet.get("attribution", None),
"is_featured":
sheet.get("is_featured", False),
"category":
"Sheets", # ditto
"type":
"sheet", # ditto
}
results.append(sheet_data)
break
return results
from sefaria.system.database import db
from sefaria.model.group import Group
from django.contrib.auth.models import User
from django.contrib.auth.models import Group as DjangoGroup
skip = ["Editors", "User Seeds"]
groups = DjangoGroup.objects.all()
for dgroup in groups:
if dgroup.name in skip:
continue
print dgroup.name
admins = [u.id for u in dgroup.user_set.all()]
group = Group().load({"name": dgroup.name})
fields = {
"name": dgroup.name,
"admins": admins,
"publishers": [],
"members": [],
}
if group:
fields["imageUrl"] = getattr(group, "coverUrl", None)
group.load_from_dict(fields)
group.save()
else:
Group(fields).save()
db.groups.create_index("name", unique=True)
db.groups.create_index("admins")
db.groups.create_index("publishers")
db.groups.create_index("members")
db.groups.create_index("listed")
