def sheets_tag(request, tag, public=True, group=None):
"""
View sheets for a particular tag.
"""
if public:
if request.flavour == "mobile":
return s2_sheets_by_tag(request, tag)
elif not request.COOKIES.get('s1'):
return s2_sheets_by_tag(request, tag)
sheets = get_sheets_by_tag(tag)
elif group:
sheets = get_sheets_by_tag(tag, group=group)
else:
sheets = get_sheets_by_tag(tag, uid=request.user.id)
in_group = request.user.is_authenticated() and group in [g.name for g in get_user_groups(request.user.id)]
groupCover = Group().load({"name": group}).coverUrl if Group().load({"name": group}) else None
return render_to_response('tag.html', {
"tag": tag,
"sheets": sheets,
"public": public,
"group": group,
"groupCover": groupCover,
"in_group": in_group,
}, RequestContext(request))
return render_to_response('sheet_tags.html', {"tags_list": tags_list, }, RequestContext(request))
def sheets_tag(request, tag, public=True, group=None):
"""
View sheets for a particular tag.
"""
if public:
sheets = get_sheets_by_tag(tag)
elif group:
sheets = get_sheets_by_tag(tag, group=group)
else:
sheets = get_sheets_by_tag(tag, uid=request.user.id)
in_group = request.user.is_authenticated(
) and group in request.user.groups.all()
groupCover = Group().load({
"name": group
}).coverUrl if Group().load({"name": group}) else None
return render_to_response(
'tag.html', {
"tag": tag,
"sheets": sheets,
"public": public,
"group": group,
"groupCover": groupCover,
"in_group": in_group,
}, RequestContext(request))
return render_to_response('sheet_tags.html', {
"tags_list": tags_list,
}, RequestContext(request))
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:
reservedChars = ['-', '_', '|']
if any([c in group["name"] for c in reservedChars]):
return jsonResponse({
"error":
'Group names may not contain the following characters: {}'.
format(', '.join(reservedChars))
})
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."})
def groups_post_api(request, user_id, 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 user_id not in existing.admins:
return jsonResponse({
"error":
"You do not have permission to edit this group."
})
existing.load_from_dict(group)
existing.save()
else:
del group["new"]
group["admins"] = [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 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."})
def partner_page(request, partner):
"""
Views the partner page for 'partner' which lists sheets in the partner group.
"""
partner = partner.replace("-", " ").replace("_", " ")
group = Group().load({"name": partner})
if not group:
return redirect("home")
if not request.user.is_authenticated(
) or group.name not in request.user.groups.all():
in_group = False
query = {"status": 7, "group": group.name}
else:
in_group = True
query = {"status": {"$in": [6, 7]}, "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": 6,
"group": group,
"in_group": in_group,
"title": "%s on Sefaria" % group.name,
}, RequestContext(request))
def partner_page(request, partner):
"""
Views the partner page for 'partner' which lists sheets in the partner group.
"""
partner = partner.replace("-", " ").replace("_", " ")
group = Group().load({"name": partner})
if not group:
raise Http404
if request.user.is_authenticated() and group.name in [g.name for g in request.user.groups.all()]:
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 sheet_to_html_string(sheet):
"""
Create the html string of sheet with sheet_id.
"""
sheet["sources"] = annotate_user_links(sheet["sources"])
sheet = resolve_options_of_sources(sheet)
try:
owner = User.objects.get(id=sheet["owner"])
author = owner.first_name + " " + owner.last_name
except User.DoesNotExist:
author = "Someone Mysterious"
sheet_group = (Group().load({"name": sheet["group"]})
if "group" in sheet and sheet["group"] != "None" else None)
context = {
"sheetJSON": json.dumps(sheet),
"sheet": sheet,
"sheet_class": make_sheet_class_string(sheet),
"can_edit": False,
"can_add": False,
"title": sheet["title"],
"author": author,
"is_owner": False,
"is_public": sheet["status"] == "public",
"owner_groups": None,
"sheet_group": sheet_group,
"like_count": len(sheet.get("likes", [])),
"viewer_is_liker": False,
"assignments_from_sheet": assignments_from_sheet(sheet['id']),
}
return render_to_string('gdocs_sheet.html', context).encode('utf-8')
def get_sheet_for_panel(id=None):
sheet = get_sheet(id)
if "error" in sheet:
return sheet
if "assigner_id" in sheet:
asignerData = public_user_data(sheet["assigner_id"])
sheet["assignerName"] = asignerData["name"]
if "viaOwner" in sheet:
viaOwnerData = public_user_data(sheet["viaOwner"])
sheet["viaOwnerName"] = viaOwnerData["name"]
ownerData = public_user_data(sheet["owner"])
sheet["ownerName"] = ownerData["name"]
sheet["ownerProfileUrl"] = public_user_data(sheet["owner"])["profileUrl"]
sheet["ownerImageUrl"] = public_user_data(sheet["owner"])["imageUrl"]
sheet["naturalDateCreated"] = naturaltime(
datetime.strptime(sheet["dateCreated"], "%Y-%m-%dT%H:%M:%S.%f"))
sheet["sources"] = annotate_user_links(sheet["sources"])
sheet["topics"] = add_langs_to_topics(sheet.get("topics", []))
if "group" in sheet:
group = Group().load({"name": sheet["group"]})
try:
sheet["groupLogo"] = group.imageUrl
except:
sheet["groupLogo"] = None
return sheet
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 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 can_add(user, sheet):
"""
Returns True if user has adding persmission on sheet.
Returns False if user has the higher permission "can_edit"
"""
if not user.is_authenticated:
return False
if can_edit(user, sheet):
return False
if "assigner_id" in sheet:
if sheet["assigner_id"] == user.id:
return True
if "collaboration" not in sheet["options"]:
return False
if sheet["options"]["collaboration"] == "anyone-can-add":
return True
if sheet["options"]["collaboration"] == "group-can-add":
if "group" in sheet:
try:
return Group().load({
"name": sheet["group"]
}).is_member(user.id)
except:
return False
return False
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 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 private_sheet_list_api(request, partner):
partner = partner.replace("-", " ").replace("_", " ")
group = Group().load({"name": partner})
if not group:
raise Http404
if request.user.is_authenticated() and group.name in [g.name for g in request.user.groups.all()]:
return jsonResponse(partner_sheets(partner, True), callback=request.GET.get("callback", None))
else:
return jsonResponse(partner_sheets(partner, False), callback=request.GET.get("callback", None))
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 can_publish(user, sheet):
"""
Returns True if user and sheet both belong to the same Group, and user has publish rights in that group
Returns False otherwise, including if the sheet is not in a Group at all
"""
if "group" in sheet:
try:
return Group().load({"name": sheet["group"]}).can_publish(user.id)
except:
return False
return False
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 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):
return s2_group_sheets(request, group.name, True)
else:
return s2_group_sheets(request, group.name, False)
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 view_visual_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)
can_edit_flag = can_edit(request.user, sheet)
can_add_flag = can_add(request.user, 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)
viewer_is_liker = request.user.id in likes
return render(
request, 'sheets_visual.html', {
"sheetJSON": json.dumps(sheet),
"sheet": sheet,
"sheet_class": sheet_class,
"can_edit": can_edit_flag,
"can_add": can_add_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,
})
def _data_object(cls, **kwargs):
from sefaria.model.group import Group
sheet_ids = kwargs.get("sheet_ids")
g = Group().load({"name": kwargs.get("group_name")})
assert g
return {
"sheet_ids": sheet_ids,
"group_image": getattr(g, "imageUrl", ""),
"group_url": g.url,
"title": {
"en": g.name,
"he": g.name
}
}
def assigned_sheet(request, assignment_id):
"""
A new sheet prefilled with an assignment.
"""
sheet = get_sheet(assignment_id)
if "error" in sheet:
return HttpResponse(sheet["error"])
sheet["sources"] = annotate_user_links(sheet["sources"])
# Remove keys from we don't want transferred
for key in ("id", "like", "views"):
if key in sheet:
del sheet[key]
assigner = UserProfile(id=sheet["owner"])
assigner_id = assigner.id
owner_groups = get_user_groups(request.user)
sheet_class = make_sheet_class_string(sheet)
can_edit_flag = True
can_add_flag = can_add(request.user, 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)
viewer_is_liker = request.user.id in likes
return render_to_response(
'sheets.html', {
"sheetJSON": json.dumps(sheet),
"sheet": sheet,
"assignment_id": assignment_id,
"assigner_id": assigner_id,
"new_sheet": True,
"sheet_class": sheet_class,
"can_edit": can_edit_flag,
"can_add": can_add_flag,
"title": sheet["title"],
"is_owner": True,
"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,
}, RequestContext(request))
def _data_object(cls, **kwargs):
from sefaria.model.group import Group
sheet_ids = kwargs.get("sheet_ids")
g = Group().load({"name": kwargs.get("group_name")})
assert g
d = {
"sheet_ids": sheet_ids,
"group_image": getattr(g, "imageUrl", ""),
"group_url": g.url,
"title": kwargs.get("title",{"en": g.name, "he": g.name}),
"cozy": kwargs.get("cozy", False)
}
if kwargs.get("lead"):
d["lead"] = kwargs.get("lead")
return d
def can_edit(user, sheet):
"""
Returns True if user can edit sheet.
"""
if sheet["owner"] == user.id:
return True
if "collaboration" not in sheet["options"]:
return False
if sheet["options"]["collaboration"] == "anyone-can-edit":
return True
if sheet["options"]["collaboration"] == "group-can-edit":
if "group" in sheet:
try:
return Group().load({"name": sheet["group"]}).is_member(user.id)
except:
return False
return False
def groups_api(request):
j = request.POST.get("json")
if not j:
return jsonResponse({"error": "No JSON given in post data."})
group = json.loads(j)
if request.method == "POST":
existing = GroupSet({"name": group["name"]})
if len(existing):
existing.update(group)
existing.save()
else:
Group(group).save()
DjangoGroup.objects.create(name=group["name"])
return jsonResponse({"status": "ok"})
elif request.method == "DELETE":
GroupSet(group).delete()
return jsonResponse({"status": "ok"})
else:
return jsonResponse({"error": "Unsupported HTTP method."})
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
segment_refs = [r.normal() for r in oref.all_segment_refs()]
query = {"expandedRefs": {"$in": segment_refs}}
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,
"expandedRefs": 1,
"views": 1,
"topics": 1,
"status": 1,
"summary": 1,
"attribution": 1,
"assigner_id": 1,
"likes": 1,
"group": 1,
"options": 1
}).sort([["views", -1]])
sheetsObj.hint("expandedRefs_1")
sheets = [s for s in sheetsObj]
user_ids = list({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,
"profile_pic_url_small": 1
}))
mongo_user_profiles = {item['id']: item for item in mongo_user_profiles}
for profile in user_profiles:
try:
user_profiles[profile]["slug"] = mongo_user_profiles[profile][
"slug"]
except:
user_profiles[profile]["slug"] = "/"
try:
user_profiles[profile][
"profile_pic_url_small"] = mongo_user_profiles[profile].get(
"profile_pic_url_small", '')
except:
user_profiles[profile]["profile_pic_url_small"] = ""
results = []
for sheet in sheets:
anchor_ref_list, anchor_ref_expanded_list = oref.get_all_anchor_refs(
segment_refs, sheet.get("includedRefs", []),
sheet.get("expandedRefs", []))
ownerData = user_profiles.get(
sheet["owner"], {
'first_name': 'Ploni',
'last_name': 'Almoni',
'email': '*****@*****.**',
'slug': 'Ploni-Almoni',
'id': None,
'profile_pic_url_small': ''
})
if len(ownerData.get('profile_pic_url_small', '')) == 0:
default_image = "https://www.sefaria.org/static/img/profile-default.png"
gravatar_base = "https://www.gravatar.com/avatar/" + hashlib.md5(
ownerData["email"].lower().encode('utf8')).hexdigest() + "?"
gravatar_url_small = gravatar_base + urllib.parse.urlencode(
{
'd': default_image,
's': str(80)
})
ownerData['profile_pic_url_small'] = gravatar_url_small
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)
natural_date_created = naturaltime(
datetime.strptime(sheet["dateCreated"], "%Y-%m-%dT%H:%M:%S.%f"))
topics = add_langs_to_topics(sheet.get("topics", []))
for anchor_ref, anchor_ref_expanded in zip(anchor_ref_list,
anchor_ref_expanded_list):
sheet_data = {
"owner": sheet["owner"],
"_id": str(sheet["_id"]),
"id": str(sheet["id"]),
"public": sheet["status"] == "public",
"title": strip_tags(sheet["title"]),
"sheetUrl": "/sheets/" + str(sheet["id"]),
"anchorRef": anchor_ref.normal(),
"anchorRefExpanded": [r.normal() for r in anchor_ref_expanded],
"options": sheet["options"],
"naturalDateCreated": natural_date_created,
"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": ownerData.get('profile_pic_url_small', ''),
"status": sheet["status"],
"views": sheet["views"],
"topics": topics,
"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)
return results
def get_sheets_for_ref(tref, uid=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.
"""
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"
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"]})
try:
sheet["groupLogo"] = group.imageUrl
except:
sheet["groupLogo"] = 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")),
"groupLogo":
sheet.get("groupLogo", 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),
"category":
"Sheets", # ditto
"type":
"sheet", # ditto
}
results.append(sheet_data)
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")
# -*- 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()
