def ajax_checkout(request):
project = get_obj_from_request(request.POST, 'project', Project)
if project is None:
return json_failure(design.bad_project_id)
# make sure user can work on this band
if not project.band.permission_to_work(request.user):
return json_failure(
design.you_dont_have_permission_to_work_on_this_band)
if project.band.is_read_only():
return json_failure(design.band_in_readonly_mode)
# make sure project is available
if project.checked_out_to is not None:
return json_failure(design.this_project_already_checked_out)
project.checked_out_to = request.user
project.date_checked_out = datetime.now()
project.save()
# create log entry
entry = LogEntry()
entry.entry_type = LogEntry.SONG_CHECKED_OUT
entry.band = project.band
entry.project = project
entry.catalyst = request.user
entry.save()
return json_success()
def ajax_checkout(request):
project = get_obj_from_request(request.POST, 'project', Project)
if project is None:
return json_failure(design.bad_project_id)
# make sure user can work on this band
if not project.band.permission_to_work(request.user):
return json_failure(design.you_dont_have_permission_to_work_on_this_band)
if project.band.is_read_only():
return json_failure(design.band_in_readonly_mode)
# make sure project is available
if project.checked_out_to is not None:
return json_failure(design.this_project_already_checked_out)
project.checked_out_to = request.user
project.date_checked_out = datetime.now()
project.save()
# create log entry
entry = LogEntry()
entry.entry_type = LogEntry.SONG_CHECKED_OUT
entry.band = project.band
entry.project = project
entry.catalyst = request.user
entry.save()
return json_success()
def ajax_project_list(request):
# validate input
page_number = get_val(request.GET, 'page', 1)
filterName = request.GET.get('filter', 'all')
if not FILTERS.has_key(filterName):
filterName = DEFAULT_FILTER
searchText = request.GET.get('search', '')
band = get_obj_from_request(request.GET, 'band', Band)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_critique(request.user):
return json_failure(
design.you_dont_have_permission_to_critique_this_band)
# get a list of filtered projects
projects = performFilter(filterName, Project.objects.filter(band=band),
request.user)
# apply search text to query
if searchText:
# limit to 10 words
words = searchText.split()[:10]
for word in words:
projects = projects.filter(title__icontains=word)
paginator = Paginator(projects, settings.ITEMS_PER_PAGE)
def project_to_dict(project):
data = project.to_dict(access=SerializableModel.OWNER,
chains=['checked_out_to'])
data['latest_version'] = version_to_dict(project.latest_version,
request.user)
return data
try:
member_dict = BandMember.objects.get(band=band,
user=request.user).to_dict()
except BandMember.DoesNotExist:
member_dict = None
# build the json object
data = {
'projects':
[project_to_dict(x) for x in paginator.page(page_number).object_list],
'page_count':
paginator.num_pages,
'page_number':
page_number,
'band':
band.to_dict(access=SerializableModel.OWNER),
'band_member':
member_dict,
}
return json_success(data)
def ajax_edit_comment(request):
node = get_obj_from_request(request.POST, 'comment', SongCommentNode)
if node is None:
return json_failure(design.bad_song_comment_node_id)
# can only edit own comments
if node.owner != request.user:
return json_failure(design.can_only_edit_your_own_comment)
# can only delete within a certain amount of time
now = datetime.now()
if now > node.date_created + timedelta(
hours=settings.COMMENT_EDIT_TIME_HOURS):
return json_failure(design.too_late_to_edit_comment)
content = request.POST.get('content', '')
if len(content) == 0 or len(content) > 2000:
return json_failure(design.content_wrong_length)
node.content = content
node.save()
return json_success(node.to_dict())
def ajax_username_invite(request):
invitee_username = get_val(request.POST, 'username', '')
band = get_obj_from_request(request.POST, 'band', Band)
try:
invitee = User.objects.get(username=invitee_username)
except User.DoesNotExist:
return json_failure(design.that_user_does_not_exist)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_invite(request.user):
return json_failure(design.lack_permission_to_invite)
# make sure the user isn't already in the band
if BandMember.objects.filter(user=invitee, band=band).count() > 0:
return json_failure(design.x_already_in_band.format(invitee.username))
# make sure there isn't already an invitation for them
if BandInvitation.objects.filter(invitee=invitee, band=band).count() > 0:
return json_failure(design.already_invited_x_to_your_band.format(invitee.username))
invite = BandInvitation()
invite.inviter = request.user
invite.band = band
invite.role = BandMember.BAND_MEMBER
invite.invitee = invitee
invite.save()
# send a heads up email
send_invitation_email(invite, request.get_host())
return json_success()
def ajax_username_invite(request):
invitee_username = get_val(request.POST, 'username', '')
band = get_obj_from_request(request.POST, 'band', Band)
try:
invitee = User.objects.get(username=invitee_username)
except User.DoesNotExist:
return json_failure(design.that_user_does_not_exist)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_invite(request.user):
return json_failure(design.lack_permission_to_invite)
# make sure the user isn't already in the band
if BandMember.objects.filter(user=invitee, band=band).count() > 0:
return json_failure(design.x_already_in_band.format(invitee.username))
# make sure there isn't already an invitation for them
if BandInvitation.objects.filter(invitee=invitee, band=band).count() > 0:
return json_failure(
design.already_invited_x_to_your_band.format(invitee.username))
invite = BandInvitation()
invite.inviter = request.user
invite.band = band
invite.role = BandMember.BAND_MEMBER
invite.invitee = invitee
invite.save()
# send a heads up email
send_invitation_email(invite, request.get_host())
return json_success()
def handle_invite(request, accept):
invite = get_obj_from_request(request.POST, 'invitation', BandInvitation)
if invite is None:
raise Http404
# make sure the user has permission to reject this invitation
if invite.invitee != request.user:
return json_failure(design.invitation_not_sent_to_you)
# make sure it's not expired
if invite.expire_date is not None and datetime.now() > invite.expire_date:
return json_failure(design.invitation_expired)
if accept:
# apply the invitation
member = BandMember()
member.user = request.user
member.band = invite.band
member.role = invite.role
member.save()
createNewBandMemberLogEntry(member)
send_invitation_accepted_email(invite, request.get_host())
invite.delete()
return json_success()
def handle_invite(request, accept):
invite = get_obj_from_request(request.POST, 'invitation', BandInvitation)
if invite is None:
raise Http404
# make sure the user has permission to reject this invitation
if invite.invitee != request.user:
return json_failure(design.invitation_not_sent_to_you)
# make sure it's not expired
if invite.expire_date is not None and datetime.now() > invite.expire_date:
return json_failure(design.invitation_expired)
if accept:
# apply the invitation
member = BandMember()
member.user = request.user
member.band = invite.band
member.role = invite.role
member.save()
createNewBandMemberLogEntry(member)
send_invitation_accepted_email(invite, request.get_host())
invite.delete()
return json_success()
def ajax_create_band(request):
form = NewBandForm(request.POST)
if form.is_valid():
profile = request.user.get_profile()
if profile.bands_in_count() >= profile.band_count_limit:
return json_failure(design.you_have_reached_your_band_count_limit)
actually_create_band(request.user, form.cleaned_data.get('band_name'))
return json_success()
return json_failure(form_errors(form))
def ajax_create_band(request):
form = NewBandForm(request.POST)
if form.is_valid():
profile = request.user.get_profile()
if profile.bands_in_count() >= profile.band_count_limit:
return json_failure(design.you_have_reached_your_band_count_limit)
actually_create_band(request.user, form.cleaned_data.get('band_name'))
return json_success()
return json_failure(form_errors(form))
def ajax_upload_samples_as_version(request):
"""
Upload some samples and then add each uploaded sample
to a new project version.
"""
project = get_obj_from_request(request.POST, 'project', Project)
comments = request.POST.get('comments', '')
if project is None:
return json_failure(design.bad_project_id)
band = project.band
if not band.permission_to_work(request.user):
return json_failure(
design.you_dont_have_permission_to_work_on_this_band)
if band.is_read_only():
return json_failure(design.band_in_readonly_mode)
node = SongCommentNode()
node.owner = request.user
node.content = comments
node.save()
version = ProjectVersion()
version.project = project
version.owner = request.user
version.comment_node = node
version.version = project.latest_version.version # no +1, only adding samples.
version.save() # so we can add provided_samples
node.version = version
node.save()
def add_sample_to_version(sample):
version.provided_samples.add(sample)
files = request.FILES.getlist('file')
for item in files:
handle_sample_upload(item,
request.user,
band,
callback=add_sample_to_version)
band.save()
version.save()
version.makeLogEntry()
return json_success()
def ajax_project_list(request):
# validate input
page_number = get_val(request.GET, 'page', 1)
filterName = request.GET.get('filter', 'all')
if not FILTERS.has_key(filterName):
filterName = DEFAULT_FILTER
searchText = request.GET.get('search', '')
band = get_obj_from_request(request.GET, 'band', Band)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_critique(request.user):
return json_failure(design.you_dont_have_permission_to_critique_this_band)
# get a list of filtered projects
projects = performFilter(filterName, Project.objects.filter(band=band), request.user)
# apply search text to query
if searchText:
# limit to 10 words
words = searchText.split()[:10]
for word in words:
projects = projects.filter(title__icontains=word)
paginator = Paginator(projects, settings.ITEMS_PER_PAGE)
def project_to_dict(project):
data = project.to_dict(access=SerializableModel.OWNER, chains=['checked_out_to'])
data['latest_version'] = version_to_dict(project.latest_version, request.user)
return data
try:
member_dict = BandMember.objects.get(band=band, user=request.user).to_dict()
except BandMember.DoesNotExist:
member_dict = None
# build the json object
data = {
'projects': [project_to_dict(x) for x in paginator.page(page_number).object_list],
'page_count': paginator.num_pages,
'page_number': page_number,
'band': band.to_dict(access=SerializableModel.OWNER),
'band_member': member_dict,
}
return json_success(data)
def ajax_dependency_ownership(request):
profile = request.user.get_profile()
dep_type_int = get_val(request.POST, 'dependency_type', -1)
if dep_type_int == PluginDepenency.STUDIO:
dep_type = Studio
collection = profile.studios
else:
dep_type = PluginDepenency
collection = profile.plugins
dep = get_obj_from_request(request.POST, 'dependency_id', dep_type)
if dep is None:
return json_failure(design.bad_dependency_id)
have = request.POST.get('have', 'false')
if have == 'false':
have = False
else:
have = True
if have:
collection.add(dep)
else:
collection.remove(dep)
profile.save()
return json_success()
def ajax_project_filters(request):
band = get_obj_from_request(request.GET, 'band', Band)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_work(request.user):
return json_failure(design.you_dont_have_permission_to_work_on_this_band)
projects = Project.objects.filter(band=band)
results = dict(JFILTERS)
for filterId, filterData in results.iteritems():
filterData['count'] = performFilter(filterId, projects, request.user).count()
return json_success(results)
def ajax_dependency_ownership(request):
profile = request.user.get_profile()
dep_type_int = get_val(request.POST, 'dependency_type', -1)
if dep_type_int == PluginDepenency.STUDIO:
dep_type = Studio
collection = profile.studios
else:
dep_type = PluginDepenency
collection = profile.plugins
dep = get_obj_from_request(request.POST, 'dependency_id', dep_type)
if dep is None:
return json_failure(design.bad_dependency_id)
have = request.POST.get('have', 'false')
if have == 'false':
have = False
else:
have = True
if have:
collection.add(dep)
else:
collection.remove(dep)
profile.save()
return json_success()
def ajax_upload_samples_as_version(request):
"""
Upload some samples and then add each uploaded sample
to a new project version.
"""
project = get_obj_from_request(request.POST, 'project', Project)
comments = request.POST.get('comments', '')
if project is None:
return json_failure(design.bad_project_id)
band = project.band
if not band.permission_to_work(request.user):
return json_failure(design.you_dont_have_permission_to_work_on_this_band)
if band.is_read_only():
return json_failure(design.band_in_readonly_mode)
node = SongCommentNode()
node.owner = request.user
node.content = comments
node.save()
version = ProjectVersion()
version.project = project
version.owner = request.user
version.comment_node = node
version.version = project.latest_version.version # no +1, only adding samples.
version.save() # so we can add provided_samples
node.version = version
node.save()
def add_sample_to_version(sample):
version.provided_samples.add(sample)
files = request.FILES.getlist('file')
for item in files:
handle_sample_upload(item, request.user, band, callback=add_sample_to_version)
band.save()
version.save()
version.makeLogEntry()
return json_success()
def ajax_delete_comment(request):
node = get_obj_from_request(request.POST, 'comment', SongCommentNode)
if node is None:
return json_failure(design.bad_song_comment_node_id)
# can only delete own comments
if node.owner != request.user:
return json_failure(design.can_only_delete_your_own_comment)
# can only delete within a certain amount of time
now = datetime.now()
if now > node.date_created + timedelta(hours=settings.COMMENT_EDIT_TIME_HOURS):
return json_failure(design.too_late_to_delete_comment)
node.delete()
return json_success()
def ajax_rename_project(request):
"""
Make a new version that renames the project.
"""
form = RenameProjectForm(request.POST)
if form.is_valid():
new_title = form.cleaned_data.get('title')
comments = form.cleaned_data.get('comments', '')
project_id = form.cleaned_data.get('project')
try:
project = Project.objects.get(pk=project_id)
except Project.DoesNotExist:
return json_failure(design.bad_project_id)
if not project.band.permission_to_work(request.user):
return json_failure(
design.you_dont_have_permission_to_work_on_this_band)
if project.band.is_read_only():
return json_failure(design.band_in_readonly_mode)
node = SongCommentNode()
node.owner = request.user
node.content = comments
node.save()
version = ProjectVersion()
version.project = project
version.owner = request.user
version.comment_node = node
version.version = project.latest_version.version # no +1 because only renaming
version.new_title = new_title
version.old_title = project.title
version.save()
node.version = version
node.save()
project.title = new_title
project.save()
return json_success()
return json_failure(form_errors(form))
def ajax_provide_project(request):
version = get_obj_from_request(request.POST, 'version', ProjectVersion)
if version is None:
return json_failure(design.bad_version_id)
band = version.project.band
if not band.permission_to_work(request.user):
return json_failure(design.you_dont_have_permission_to_work_on_this_band)
if band.is_read_only():
return json_failure(design.band_in_readonly_mode)
project_handle = request.FILES.get('file')
handle_project_upload(project_handle, request.user, version.song)
return json_success()
def ajax_project_filters(request):
band = get_obj_from_request(request.GET, 'band', Band)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_work(request.user):
return json_failure(
design.you_dont_have_permission_to_work_on_this_band)
projects = Project.objects.filter(band=band)
results = dict(JFILTERS)
for filterId, filterData in results.iteritems():
filterData['count'] = performFilter(filterId, projects,
request.user).count()
return json_success(results)
def ajax_delete_comment(request):
node = get_obj_from_request(request.POST, 'comment', SongCommentNode)
if node is None:
return json_failure(design.bad_song_comment_node_id)
# can only delete own comments
if node.owner != request.user:
return json_failure(design.can_only_delete_your_own_comment)
# can only delete within a certain amount of time
now = datetime.now()
if now > node.date_created + timedelta(
hours=settings.COMMENT_EDIT_TIME_HOURS):
return json_failure(design.too_late_to_delete_comment)
node.delete()
return json_success()
def ajax_rename_project(request):
"""
Make a new version that renames the project.
"""
form = RenameProjectForm(request.POST)
if form.is_valid():
new_title = form.cleaned_data.get('title')
comments = form.cleaned_data.get('comments', '')
project_id = form.cleaned_data.get('project')
try:
project = Project.objects.get(pk=project_id)
except Project.DoesNotExist:
return json_failure(design.bad_project_id)
if not project.band.permission_to_work(request.user):
return json_failure(design.you_dont_have_permission_to_work_on_this_band)
if project.band.is_read_only():
return json_failure(design.band_in_readonly_mode)
node = SongCommentNode()
node.owner = request.user
node.content = comments
node.save()
version = ProjectVersion()
version.project = project
version.owner = request.user
version.comment_node = node
version.version = project.latest_version.version # no +1 because only renaming
version.new_title = new_title
version.old_title = project.title
version.save()
node.version = version
node.save()
project.title = new_title
project.save()
return json_success()
return json_failure(form_errors(form))
def ajax_provide_project(request):
version = get_obj_from_request(request.POST, 'version', ProjectVersion)
if version is None:
return json_failure(design.bad_version_id)
band = version.project.band
if not band.permission_to_work(request.user):
return json_failure(
design.you_dont_have_permission_to_work_on_this_band)
if band.is_read_only():
return json_failure(design.band_in_readonly_mode)
project_handle = request.FILES.get('file')
handle_project_upload(project_handle, request.user, version.song)
return json_success()
def ajax_upload_samples(request):
band = get_obj_from_request(request.POST, 'band', Band)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_work(request.user):
return json_failure(design.you_dont_have_permission_to_work_on_this_band)
if band.is_read_only():
return json_failure(design.band_in_readonly_mode)
files = request.FILES.getlist('file')
for item in files:
handle_sample_upload(item, request.user, band)
band.save()
return json_success()
def ajax_say(request):
room = get_obj_from_request(request.POST, 'room', ChatRoom)
if room is None:
return json_failure(design.bad_room_id)
data = {
'user': {
'is_authenticated': request.user.is_authenticated(),
'permission_read': room.permission_to_hear(request.user),
'permission_write': room.permission_to_chat(request.user),
},
'success': False,
}
if not room.is_active():
return json_failure(design.room_is_not_active)
message = request.POST.get('message', '')
if message == "":
return json_failure(design.cannot_say_blank_message)
if len(message) > ChatMessage._meta.get_field('message').max_length: #@UndefinedVariable
return json_failure(design.message_too_long)
if not data['user']['permission_write']:
return json_failure(design.you_lack_write_permission)
msgType = get_val(request.POST, 'type', ChatMessage.MESSAGE)
if msgType not in [ChatMessage.MESSAGE, ChatMessage.ACTION]:
msgType = ChatMessage.MESSAGE
# we're clear. add the message
m = ChatMessage()
m.room = room
m.type = msgType
m.author = request.user
m.message = message
m.save()
data['success'] = True
return json_response(data)
def ajax_create_invite(request):
band = get_obj_from_request(request.POST, 'band', Band)
invitee = get_obj_from_request(request.POST, 'invitee', User)
if band is None:
return json_failure(design.bad_band_id)
if not band.openness == Band.FULL_OPEN:
try:
member = BandMember.objects.get(user=request.user, band=band)
except BandMember.DoesNotExist:
return json_failure(design.can_only_invite_to_your_own_band)
if member.role != BandMember.MANAGER:
return json_failure(design.only_managers_can_create_invitations)
# make sure user isn't already in band
if BandMember.objects.filter(band=band, user=invitee).count() > 0:
return json_failure(design.x_already_in_band.format(invitee.username))
invite = BandInvitation()
invite.inviter = request.user
invite.band = band
invite.expire_date = datetime.now() + timedelta(days=30)
if invitee == None:
invite.code = create_hash(32)
invite.save()
data = {'url': invite.redeemHyperlink()}
return json_success(data)
else:
# make sure invitation doesn't exist already
if BandInvitation.objects.filter(band=band,
invitee=invitee).count() > 0:
return json_failure(
design.already_invited_x_to_your_band.format(invitee.username))
invite.invitee = invitee
invite.save()
send_invitation_email(invite, request.get_host())
return json_success()
def ajax_onliners(request):
room = get_obj_from_request(request.GET, 'room', ChatRoom)
if room is None:
return json_failure(design.bad_room_id)
if not room.is_active():
return json_success([])
expire_date = datetime.now() - timedelta(seconds=settings.CHAT_TIMEOUT)
data = [x.person.get_profile().to_dict() for x in Appearance.objects.filter(room=room, timestamp__gt=expire_date)]
return json_success(data)
def ajax_upload_samples(request):
band = get_obj_from_request(request.POST, 'band', Band)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_work(request.user):
return json_failure(
design.you_dont_have_permission_to_work_on_this_band)
if band.is_read_only():
return json_failure(design.band_in_readonly_mode)
files = request.FILES.getlist('file')
for item in files:
handle_sample_upload(item, request.user, band)
band.save()
return json_success()
def ajax_create_invite(request):
band = get_obj_from_request(request.POST, 'band', Band)
invitee = get_obj_from_request(request.POST, 'invitee', User)
if band is None:
return json_failure(design.bad_band_id)
if not band.openness == Band.FULL_OPEN:
try:
member = BandMember.objects.get(user=request.user, band=band)
except BandMember.DoesNotExist:
return json_failure(design.can_only_invite_to_your_own_band)
if member.role != BandMember.MANAGER:
return json_failure(design.only_managers_can_create_invitations)
# make sure user isn't already in band
if BandMember.objects.filter(band=band, user=invitee).count() > 0:
return json_failure(design.x_already_in_band.format(invitee.username))
invite = BandInvitation()
invite.inviter = request.user
invite.band = band
invite.expire_date = datetime.now() + timedelta(days=30)
if invitee == None:
invite.code = create_hash(32)
invite.save()
data = {'url': invite.redeemHyperlink()}
return json_success(data)
else:
# make sure invitation doesn't exist already
if BandInvitation.objects.filter(band=band, invitee=invitee).count() > 0:
return json_failure(design.already_invited_x_to_your_band.format(invitee.username))
invite.invitee = invitee
invite.save()
send_invitation_email(invite, request.get_host())
return json_success()
def ajax_provide_mp3(request):
version = get_obj_from_request(request.POST, 'version', ProjectVersion)
if version is None:
return json_failure(design.bad_version_id)
band = version.project.band
if not band.permission_to_work(request.user):
return json_failure(design.you_dont_have_permission_to_work_on_this_band)
if band.is_read_only():
return json_failure(design.band_in_readonly_mode)
mp3_handle = request.FILES.get('file')
result = handle_mp3_upload(mp3_handle, version.song)
if result['success']:
version.song.save()
return json_success()
else:
return json_failure(result['reason'])
def ajax_provide_mp3(request):
version = get_obj_from_request(request.POST, 'version', ProjectVersion)
if version is None:
return json_failure(design.bad_version_id)
band = version.project.band
if not band.permission_to_work(request.user):
return json_failure(
design.you_dont_have_permission_to_work_on_this_band)
if band.is_read_only():
return json_failure(design.band_in_readonly_mode)
mp3_handle = request.FILES.get('file')
result = handle_mp3_upload(mp3_handle, version.song)
if result['success']:
version.song.save()
return json_success()
else:
return json_failure(result['reason'])
def ajax_edit_comment(request):
node = get_obj_from_request(request.POST, 'comment', SongCommentNode)
if node is None:
return json_failure(design.bad_song_comment_node_id)
# can only edit own comments
if node.owner != request.user:
return json_failure(design.can_only_edit_your_own_comment)
# can only delete within a certain amount of time
now = datetime.now()
if now > node.date_created + timedelta(hours=settings.COMMENT_EDIT_TIME_HOURS):
return json_failure(design.too_late_to_edit_comment)
content = request.POST.get('content', '')
if len(content) == 0 or len(content) > 2000:
return json_failure(design.content_wrong_length)
node.content = content
node.save()
return json_success(node.to_dict())
def ajax_project(request):
"""
return the project history. if a last_version is supplied, only
return newer ones. Also return the current state - who has it
checked out, etc.
"""
last_version_id = get_val(request.GET, 'last_version', 0)
project = get_obj_from_request(request.GET, 'project', Project)
if project is None:
return json_failure(design.bad_project_id)
# make sure the user has permission
data = {
'user': {
'is_authenticated': request.user.is_authenticated(),
'has_permission':
project.band.permission_to_critique(request.user),
},
'success': False,
}
if not data['user']['has_permission']:
data['reason'] = design.you_dont_have_permission_to_critique_this_band
return json_response(data)
data['project'] = project.to_dict(SerializableModel.OWNER,
chains=['checked_out_to'])
data['project']['band'] = project.band.to_dict(SerializableModel.OWNER)
if last_version_id == 0:
# get entire version list
data['versions'] = [
version_to_dict(x, request.user)
for x in ProjectVersion.objects.filter(project=project)
]
else:
data['versions'] = [
version_to_dict(x, request.user)
for x in ProjectVersion.objects.filter(project=project,
id__gt=last_version_id)
]
data['user'].update(request.user.get_profile().to_dict())
data['success'] = True
return json_response(data)
def ajax_compo(request, compo_id):
compo_id = int(compo_id)
try:
compo = get_object_or_404(Competition, pk=compo_id)
except Competition.DoesNotExist:
return json_failure(design.competition_not_found)
data = {
'user': {
'is_authenticated': request.user.is_authenticated(),
},
'compo': compo_to_dict(compo, request.user),
'party': {
'buffer_time': settings.LISTENING_PARTY_BUFFER_TIME,
}
}
if request.user.is_authenticated():
max_votes = max_vote_count(compo.entry_set.count())
used_votes = ThumbsUp.objects.filter(owner=request.user,
entry__competition=compo)
data['user'].update(request.user.get_profile().to_dict())
data['votes'] = {
'max': max_votes,
'used': [x.to_dict() for x in used_votes],
'left': max_votes - used_votes.count(),
}
user_entries = Entry.objects.filter(competition=compo,
owner=request.user)
data['submitted'] = (user_entries.count() > 0)
def entry_to_dict(entry):
data = entry.to_dict(chains=['owner.solo_band'])
data['song'] = song_to_dict(entry.song, request.user)
if request.user.is_authenticated() and entry.owner == request.user:
version = ProjectVersion.objects.get(song=entry.song)
data['project_id'] = version.project.pk
data['version_number'] = version.version
return data
# entries. if competition is closed, sort by vote count.
data['entries'] = [entry_to_dict(x) for x in compo.entry_set.all()]
return json_response(data)
def ajax_compo(request, compo_id):
compo_id = int(compo_id)
try:
compo = get_object_or_404(Competition, pk=compo_id)
except Competition.DoesNotExist:
return json_failure(design.competition_not_found)
data = {
'user': {
'is_authenticated': request.user.is_authenticated(),
},
'compo': compo_to_dict(compo, request.user),
'party': {
'buffer_time': settings.LISTENING_PARTY_BUFFER_TIME,
}
}
if request.user.is_authenticated():
max_votes = max_vote_count(compo.entry_set.count())
used_votes = ThumbsUp.objects.filter(owner=request.user, entry__competition=compo)
data['user'].update(request.user.get_profile().to_dict());
data['votes'] = {
'max': max_votes,
'used': [x.to_dict() for x in used_votes],
'left': max_votes - used_votes.count(),
}
user_entries = Entry.objects.filter(competition=compo, owner=request.user)
data['submitted'] = (user_entries.count() > 0)
def entry_to_dict(entry):
data = entry.to_dict(chains=['owner.solo_band'])
data['song'] = song_to_dict(entry.song, request.user)
if request.user.is_authenticated() and entry.owner == request.user:
version = ProjectVersion.objects.get(song=entry.song)
data['project_id'] = version.project.pk
data['version_number'] = version.version
return data
# entries. if competition is closed, sort by vote count.
data['entries'] = [entry_to_dict(x) for x in compo.entry_set.all()]
return json_response(data)
def ajax_project(request):
"""
return the project history. if a last_version is supplied, only
return newer ones. Also return the current state - who has it
checked out, etc.
"""
last_version_id = get_val(request.GET, 'last_version', 0)
project = get_obj_from_request(request.GET, 'project', Project)
if project is None:
return json_failure(design.bad_project_id)
# make sure the user has permission
data = {
'user': {
'is_authenticated': request.user.is_authenticated(),
'has_permission': project.band.permission_to_critique(request.user),
},
'success': False,
}
if not data['user']['has_permission']:
data['reason'] = design.you_dont_have_permission_to_critique_this_band
return json_response(data)
data['project'] = project.to_dict(SerializableModel.OWNER, chains=['checked_out_to'])
data['project']['band'] = project.band.to_dict(SerializableModel.OWNER)
if last_version_id == 0:
# get entire version list
data['versions'] = [version_to_dict(x, request.user) for x in ProjectVersion.objects.filter(project=project)]
else:
data['versions'] = [version_to_dict(x, request.user) for x in ProjectVersion.objects.filter(project=project, id__gt=last_version_id)]
data['user'].update(request.user.get_profile().to_dict())
data['success'] = True
return json_response(data)
def ajax_comment(request):
parent = get_obj_from_request(request.POST, 'parent', SongCommentNode)
if parent is None:
return json_failure(design.bad_song_comment_node_id)
# make sure the user has permission to critique
if parent.song is not None:
if not parent.song.permission_to_critique(request.user):
return json_failure(design.you_dont_have_permission_to_comment)
else:
if not parent.version.project.band.permission_to_critique(
request.user):
return json_failure(design.you_dont_have_permission_to_comment)
# make sure the parent has enabled replies
if parent.reply_disabled:
return json_failure(design.comments_disabled_for_this_version)
position = request.POST.get('position')
if position is not None:
try:
position = float(position)
except ValueError:
position = None
if position < 0 or position > parent.song.length:
return json_failure(design.invalid_position)
content = request.POST.get('content')
if len(content) == 0 or len(content) > 2000:
return json_failure(design.content_wrong_length)
node = SongCommentNode()
node.song = parent.song
node.version = parent.version
node.parent = parent
node.owner = request.user
node.content = content
node.position = position
node.reply_disabled = False
node.save()
return json_success(node.to_dict())
def ajax_comment(request):
parent = get_obj_from_request(request.POST, 'parent', SongCommentNode)
if parent is None:
return json_failure(design.bad_song_comment_node_id)
# make sure the user has permission to critique
if parent.song is not None:
if not parent.song.permission_to_critique(request.user):
return json_failure(design.you_dont_have_permission_to_comment)
else:
if not parent.version.project.band.permission_to_critique(request.user):
return json_failure(design.you_dont_have_permission_to_comment)
# make sure the parent has enabled replies
if parent.reply_disabled:
return json_failure(design.comments_disabled_for_this_version)
position = request.POST.get('position')
if position is not None:
try:
position = float(position)
except ValueError:
position = None
if position < 0 or position > parent.song.length:
return json_failure(design.invalid_position)
content = request.POST.get('content')
if len(content) == 0 or len(content) > 2000:
return json_failure(design.content_wrong_length)
node = SongCommentNode()
node.song = parent.song
node.version = parent.version
node.parent = parent
node.owner = request.user
node.content = content
node.position = position
node.reply_disabled = False
node.save()
return json_success(node.to_dict())
def ajax_email_invite(request):
"send a band invitation by email."
to_email = get_val(request.POST, 'email', '')
band = get_obj_from_request(request.POST, 'band', Band)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_invite(request.user):
return json_failure(design.lack_permission_to_invite)
if to_email == '':
return json_failure(design.you_must_supply_an_email_address)
if not is_valid_email(to_email):
return json_failure(design.invalid_email_address)
# if the email is a registered solid composer user, simply translate into direct invitation.
try:
local_user = User.objects.get(email=to_email)
except User.DoesNotExist:
local_user = None
invite = BandInvitation()
invite.inviter = request.user
invite.band = band
invite.role = BandMember.BAND_MEMBER
subject = design.x_is_inviting_you_to_join_y.format(
request.user.username, band.title)
if local_user is not None:
# make sure the user isn't already in the band
if BandMember.objects.filter(user=local_user, band=band).count() > 0:
return json_failure(
design.x_already_in_band.format(local_user.username))
# make sure there isn't already an invitation for them
if BandInvitation.objects.filter(invitee=local_user,
band=band).count() > 0:
return json_failure(
design.already_invited_x_to_your_band.format(
local_user.username))
invite.invitee = local_user
invite.save()
# send a heads up email
if local_user.get_profile().email_notifications:
context = Context({
'user': request.user,
'band': band,
'invite': invite,
'host': request.get_host(),
})
message_txt = get_template(
'workbench/email/invitation_direct.txt').render(context)
message_html = get_template(
'workbench/email/invitation_direct.html').render(context)
send_html_mail(subject, message_txt, message_html, [to_email])
return json_success()
else:
# create invitation link
invite.expire_date = datetime.now() + timedelta(days=30)
invite.code = create_hash(32)
invite.save()
# send the invitation email
context = Context({
'user': request.user,
'band': band,
'invite': invite,
'host': request.get_host(),
})
message_txt = get_template(
'workbench/email/invitation_link.txt').render(context)
message_html = get_template(
'workbench/email/invitation_link.html').render(context)
send_html_mail(subject, message_txt, message_html, [to_email])
return json_success()
def ajax_hear(request):
"""
get new or all messages
"""
last_message_str = request.GET.get('last_message', 'null')
room = get_obj_from_request(request.GET, 'room', ChatRoom)
if room is None:
return json_failure(design.bad_room_id)
# make sure user has permission to be in this room
data = {
'user': {
'is_authenticated': request.user.is_authenticated(),
'permission_read': room.permission_to_hear(request.user),
'permission_write': room.permission_to_chat(request.user),
},
'room': room.to_dict(),
'messages': [],
'success': True
}
if request.user.is_authenticated():
data['user'].update({
'username': request.user.username,
})
if data['user']['permission_read']:
def add_to_message(msg):
return {
'id': msg.id,
'type': msg.type,
'author': {
'username': msg.author.username,
'id': msg.author.id,
},
'message': msg.message,
'timestamp': msg.timestamp,
}
if last_message_str == 'null':
# get entire log for this chat.
data['messages'] = [add_to_message(x) for x in ChatMessage.objects.filter(room=room)]
else:
try:
last_message_id = int(last_message_str)
except ValueError:
last_message_id = 0
data['messages'] = [add_to_message(x) for x in ChatMessage.objects.filter(room=room, id__gt=last_message_id)]
if data['user']['permission_write']:
# mark an appearance in the ChatRoom
if request.user.is_authenticated() and room.is_active():
appearances = Appearance.objects.filter(person=request.user, room=room)
if appearances.count() > 0:
appearances[0].save() # update the timestamp
else:
new_appearance = Appearance()
new_appearance.room = room
new_appearance.person = request.user
new_appearance.save()
# join message
m = ChatMessage()
m.room=room
m.type=ChatMessage.JOIN
m.author=request.user
m.save()
return json_response(data)
def ajax_checkin(request):
project = get_obj_from_request(request.POST, 'project', Project)
if project is None:
return json_failure(design.bad_project_id)
# make sure project is checked out to request user
if project.checked_out_to is None or project.checked_out_to.id != request.user.id:
return json_failure(design.not_checked_out_to_you)
if project.band.is_read_only():
return json_failure(design.band_in_readonly_mode)
project_file = request.FILES.get('project_file')
mp3_preview = request.FILES.get('mp3_preview')
comments = request.POST.get('comments', '')
if project_file is None and mp3_preview is None:
# just check in
project.checked_out_to = None
project.save()
# create log entry
entry = LogEntry()
entry.entry_type = LogEntry.SONG_JUST_CHECK_IN
entry.band = project.band
entry.catalyst = request.user
entry.project = project
entry.save()
return json_success()
# must supply a project file
if project_file is None:
return json_failure(design.must_submit_project_file)
new_version_number = project.latest_version.version + 1
filename_appendix = "_" + str(new_version_number)
# upload the song and make a new project version
result = upload_song(request.user,
file_mp3_handle=mp3_preview,
file_source_handle=project_file,
band=project.band,
song_title=project.title,
song_comments=comments,
filename_appendix=filename_appendix)
if not result['success']:
return json_failure(result['reason'])
song = result['song']
song.save()
# make a new version
version = ProjectVersion()
version.project = project
version.song = song
version.version = new_version_number
version.saveNewVersion()
# update project info
project.checked_out_to = None
project.latest_version = version
project.title = song.title
project.save()
return json_success()
def ajax_checkin(request):
project = get_obj_from_request(request.POST, 'project', Project)
if project is None:
return json_failure(design.bad_project_id)
# make sure project is checked out to request user
if project.checked_out_to is None or project.checked_out_to.id != request.user.id:
return json_failure(design.not_checked_out_to_you)
if project.band.is_read_only():
return json_failure(design.band_in_readonly_mode)
project_file = request.FILES.get('project_file')
mp3_preview = request.FILES.get('mp3_preview')
comments = request.POST.get('comments', '')
if project_file is None and mp3_preview is None:
# just check in
project.checked_out_to = None
project.save()
# create log entry
entry = LogEntry()
entry.entry_type = LogEntry.SONG_JUST_CHECK_IN
entry.band = project.band
entry.catalyst = request.user
entry.project = project
entry.save()
return json_success()
# must supply a project file
if project_file is None:
return json_failure(design.must_submit_project_file)
new_version_number = project.latest_version.version + 1
filename_appendix = "_" + str(new_version_number)
# upload the song and make a new project version
result = upload_song(request.user,
file_mp3_handle=mp3_preview,
file_source_handle=project_file,
band=project.band,
song_title=project.title,
song_comments=comments,
filename_appendix=filename_appendix)
if not result['success']:
return json_failure(result['reason'])
song = result['song']
song.save()
# make a new version
version = ProjectVersion()
version.project = project
version.song = song
version.version = new_version_number
version.saveNewVersion()
# update project info
project.checked_out_to = None
project.latest_version = version
project.title = song.title
project.save()
return json_success()
def ajax_submit_entry(request):
compo = get_obj_from_request(request.POST, 'compo', Competition)
if compo is None:
return json_failure(design.competition_not_found)
# make sure it's still submission time
now = datetime.now()
if now >= compo.submit_deadline:
return json_failure(design.past_submission_deadline)
if now <= compo.start_date:
return json_failure(design.competition_not_started)
title = request.POST.get('entry-title','')
comments = request.POST.get('entry-comments', '')
mp3_file = request.FILES.get('entry-file-mp3')
source_file = request.FILES.get('entry-file-source')
is_open_source = request.POST.get('entry-open-source', False)
entries = Entry.objects.filter(owner=request.user, competition=compo)
resubmitting = entries.count() > 0
# make sure files are small enough
if not resubmitting and mp3_file is None:
return json_failure(design.mp3_required)
if mp3_file is not None and mp3_file.size > settings.FILE_UPLOAD_SIZE_CAP:
return json_failure(design.mp3_too_big)
if source_file is not None:
if source_file.size > settings.FILE_UPLOAD_SIZE_CAP:
return json_failure(design.source_file_too_big)
if title == '':
return json_failure(design.entry_title_required)
if mp3_file is not None:
band = request.user.get_profile().solo_band
if resubmitting:
entry = entries[0]
project = Project.objects.get(latest_version__song=entry.song)
new_version_number = project.latest_version.version + 1
filename_appendix = "_" + str(new_version_number)
else:
filename_appendix = ""
result = upload_song(request.user,
file_mp3_handle=mp3_file,
file_source_handle=source_file,
max_song_len=settings.COMPO_ENTRY_MAX_LEN,
band=band,
song_title=title,
song_album=compo.title,
song_comments=comments,
filename_appendix=filename_appendix)
if not result['success']:
return json_failure(result['reason'])
song = result['song']
song.is_open_source = is_open_source
song.is_open_for_comments = True
song.save()
# make a new version and attach that to the entry
if resubmitting:
# create new version
version = ProjectVersion()
version.project = project
version.song = song
version.version = new_version_number
version.saveNewVersion()
old_length = entry.song.length
buffer_time = 0
else:
# create the project
project = Project()
project.band = band
project.save()
# create the first version
version = ProjectVersion()
version.project = project
version.song = song
version.version = 1
version.saveNewVersion()
# subscribe the creator
project.subscribers.add(request.user)
project.save()
# create new entry
entry = Entry()
entry.competition = compo
entry.owner = request.user
old_length = 0
buffer_time = settings.LISTENING_PARTY_BUFFER_TIME
entry.song = song
entry.save()
# update competition dates based on this newfound length
vote_period_delta = timedelta(seconds=compo.vote_period_length)
if compo.have_listening_party:
compo.listening_party_end_date += timedelta(seconds=(song.length-old_length+buffer_time))
compo.vote_deadline = compo.listening_party_end_date + vote_period_delta
else:
compo.vote_deadline = compo.submit_deadline + vote_period_delta
compo.save()
chatroom = compo.chat_room
chatroom.end_date = compo.listening_party_end_date + timedelta(hours=1)
chatroom.save()
else:
# only providing source and possibly renaming.
entry = entries[0]
song = entry.song
if source_file is not None:
handle_project_upload(source_file, request.user, song)
song.title = title
song.is_open_source = is_open_source
song.comments = comments
song.save()
return json_response({'success': True})
def ajax_submit_entry(request):
compo = get_obj_from_request(request.POST, 'compo', Competition)
if compo is None:
return json_failure(design.competition_not_found)
# make sure it's still submission time
now = datetime.now()
if now >= compo.submit_deadline:
return json_failure(design.past_submission_deadline)
if now <= compo.start_date:
return json_failure(design.competition_not_started)
title = request.POST.get('entry-title', '')
comments = request.POST.get('entry-comments', '')
mp3_file = request.FILES.get('entry-file-mp3')
source_file = request.FILES.get('entry-file-source')
is_open_source = request.POST.get('entry-open-source', False)
entries = Entry.objects.filter(owner=request.user, competition=compo)
resubmitting = entries.count() > 0
# make sure files are small enough
if not resubmitting and mp3_file is None:
return json_failure(design.mp3_required)
if mp3_file is not None and mp3_file.size > settings.FILE_UPLOAD_SIZE_CAP:
return json_failure(design.mp3_too_big)
if source_file is not None:
if source_file.size > settings.FILE_UPLOAD_SIZE_CAP:
return json_failure(design.source_file_too_big)
if title == '':
return json_failure(design.entry_title_required)
if mp3_file is not None:
band = request.user.get_profile().solo_band
if resubmitting:
entry = entries[0]
project = Project.objects.get(latest_version__song=entry.song)
new_version_number = project.latest_version.version + 1
filename_appendix = "_" + str(new_version_number)
else:
filename_appendix = ""
result = upload_song(request.user,
file_mp3_handle=mp3_file,
file_source_handle=source_file,
max_song_len=settings.COMPO_ENTRY_MAX_LEN,
band=band,
song_title=title,
song_album=compo.title,
song_comments=comments,
filename_appendix=filename_appendix)
if not result['success']:
return json_failure(result['reason'])
song = result['song']
song.is_open_source = is_open_source
song.is_open_for_comments = True
song.save()
# make a new version and attach that to the entry
if resubmitting:
# create new version
version = ProjectVersion()
version.project = project
version.song = song
version.version = new_version_number
version.saveNewVersion()
old_length = entry.song.length
buffer_time = 0
else:
# create the project
project = Project()
project.band = band
project.save()
# create the first version
version = ProjectVersion()
version.project = project
version.song = song
version.version = 1
version.saveNewVersion()
# subscribe the creator
project.subscribers.add(request.user)
project.save()
# create new entry
entry = Entry()
entry.competition = compo
entry.owner = request.user
old_length = 0
buffer_time = settings.LISTENING_PARTY_BUFFER_TIME
entry.song = song
entry.save()
# update competition dates based on this newfound length
vote_period_delta = timedelta(seconds=compo.vote_period_length)
if compo.have_listening_party:
compo.listening_party_end_date += timedelta(
seconds=(song.length - old_length + buffer_time))
compo.vote_deadline = compo.listening_party_end_date + vote_period_delta
else:
compo.vote_deadline = compo.submit_deadline + vote_period_delta
compo.save()
chatroom = compo.chat_room
chatroom.end_date = compo.listening_party_end_date + timedelta(hours=1)
chatroom.save()
else:
# only providing source and possibly renaming.
entry = entries[0]
song = entry.song
if source_file is not None:
handle_project_upload(source_file, request.user, song)
song.title = title
song.is_open_source = is_open_source
song.comments = comments
song.save()
return json_response({'success': True})
def ajax_email_invite(request):
"send a band invitation by email."
to_email = get_val(request.POST, 'email', '')
band = get_obj_from_request(request.POST, 'band', Band)
if band is None:
return json_failure(design.bad_band_id)
if not band.permission_to_invite(request.user):
return json_failure(design.lack_permission_to_invite)
if to_email == '':
return json_failure(design.you_must_supply_an_email_address)
if not is_valid_email(to_email):
return json_failure(design.invalid_email_address)
# if the email is a registered solid composer user, simply translate into direct invitation.
try:
local_user = User.objects.get(email=to_email)
except User.DoesNotExist:
local_user = None
invite = BandInvitation()
invite.inviter = request.user
invite.band = band
invite.role = BandMember.BAND_MEMBER
subject = design.x_is_inviting_you_to_join_y.format(request.user.username, band.title)
if local_user is not None:
# make sure the user isn't already in the band
if BandMember.objects.filter(user=local_user, band=band).count() > 0:
return json_failure(design.x_already_in_band.format(local_user.username))
# make sure there isn't already an invitation for them
if BandInvitation.objects.filter(invitee=local_user, band=band).count() > 0:
return json_failure(design.already_invited_x_to_your_band.format(local_user.username))
invite.invitee = local_user
invite.save()
# send a heads up email
if local_user.get_profile().email_notifications:
context = Context({
'user': request.user,
'band': band,
'invite': invite,
'host': request.get_host(),
})
message_txt = get_template('workbench/email/invitation_direct.txt').render(context)
message_html = get_template('workbench/email/invitation_direct.html').render(context)
send_html_mail(subject, message_txt, message_html, [to_email])
return json_success()
else:
# create invitation link
invite.expire_date = datetime.now() + timedelta(days=30)
invite.code = create_hash(32)
invite.save()
# send the invitation email
context = Context({
'user': request.user,
'band': band,
'invite': invite,
'host': request.get_host(),
})
message_txt = get_template('workbench/email/invitation_link.txt').render(context)
message_html = get_template('workbench/email/invitation_link.html').render(context)
send_html_mail(subject, message_txt, message_html, [to_email])
return json_success()
