def setUp(self):
self.group, created = Group.objects.get_or_create(name='test')
self.user, created = DjangoUser.objects.get_or_create(username=self.username)
self.user.set_password(self.password)
self.user.save()
perspective, created = Perspective.objects.get_or_create(
name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = Folder(name='test')
self.folder.set_default_user()
self.folder.save()
self.document = Document(title='test_document', folder=self.folder)
self.document.set_default_user()
self.document.save()
self.file = File(name='test_file', folder=self.folder)
self.file.set_default_user()
self.file.save()
self.link = WebLink(title='test', folder=self.folder, url='test')
self.link.set_default_user()
self.link.save()
def folders(request):
folders = Folder.objects.filter(user=request.user)
context = {'folders':folders}
if request.method == 'POST':
# changing to a different folder
if "change_folder" in request.POST:
request.session['notes_folder'] = request.POST['folder']
# If we are changing folders we don't
# want to keep to what page we were on in
# the other folder.
if 'page' in request.session:
del request.session['page']
return redirect('cloud_notes.views.list')
if "create_folder" in request.POST:
form = NewFolderForm(request.POST)
if form.is_valid():
folder_name = form.cleaned_data['folder']
folder = Folder(name = folder_name)
folder.save()
return redirect('cloud_notes.views.list')
else:
context['form'] = form
return render(request, 'cloud_notes/folders.html', context)
else:
return render(request, 'cloud_notes/folders.html', context)
def folder_add_typed(request, folder_id=None, response_format='html'):
"Folder add to preselected folder"
folder = None
if folder_id:
folder = get_object_or_404(Folder, pk=folder_id)
if not request.user.profile.has_permission(folder, mode='x'):
folder = None
if request.POST:
if 'cancel' not in request.POST:
folder = Folder()
form = FolderForm(
request.user.profile, folder_id, request.POST, instance=folder)
if form.is_valid():
folder = form.save()
folder.set_user_from_request(request)
return HttpResponseRedirect(reverse('documents_folder_view', args=[folder.id]))
else:
return HttpResponseRedirect(reverse('document_index'))
else:
form = FolderForm(request.user.profile, folder_id)
context = _get_default_context(request)
context.update({'form': form,
'folder': folder})
return render_to_response('documents/folder_add_typed', context,
context_instance=RequestContext(request),
response_format=response_format)
def test_get(self):
"""A logged in user ask to move a valid favorite."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, godzilla)
folders = []
for i in range(10):
folder = Folder(name="folder-%s" % i, user=godzilla)
folder.save()
folders.append(folder)
target_url = reverse('favorites:favorite_move',
kwargs = {
'object_id': favorite.pk,
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
instance = response.context['favorite']
self.assertEquals(instance.pk, favorite.pk)
favorite.delete()
godzilla.delete()
for folder in folders:
folder.delete()
dummy.delete()
def create_vin(request):
topics = ['NBA']
for fld in topics:
logging.info('Entra en bucle para %s' % fld)
directory = "media/%s" % fld
root = Folder.create(fld,request.user.profile,None,'/media/example_folder.png')
root.save()
for serie in os.listdir(directory):
logging.info('Entra en bucle series para %s' % serie)
if not serie.startswith('.'):
s = Folder.create(serie,request.user.profile,root,None)
s.pic = None #TODO revisar codigo inutil
for season in os.listdir(directory+'/'+serie):
if not season.startswith('.'):
if fld == 'NBA':
pic = '/media/example_folder.png'
else:
pic = '/'+directory+'/'+serie+'/'+season+'/season.jpeg'
if s.pic == None:
s.pic = pic
s.save()
ss = Folder.create(season,request.user.profile,s,pic)
ss.save()
for episode in os.listdir(directory+'/'+serie+'/'+season+'/'):
if not episode.startswith('.') and '.jpeg' not in episode:
# if fld == 'NBA':
# pic = '/media/example_folder.png'
# else:
# pic = '/'+directory+'/'+serie+'/'+season+'/season.jpeg'
url = open(directory+'/'+serie+'/'+season+'/'+episode,'r').readline()
if url.__len__ > 0:
c = Card.create(episode,url,ss)
if fld == 'NBA':
c.pic = fld+'/'+serie+'/'+season +'/'+ episode+'.jpeg'
c.save()
def main(request, rest_of_address):
address = Address(rest_of_address)
#import pdb; pdb.set_trace()
if not address.folder:
return render_to_response('documents_folders/error.html', {'error':'no_folder', 'current_folder_path': address.folder_path})
if address.file_path and not address.file:
return render_to_response('documents_folders/error.html', {'error':'no_file', 'current_folder': address.folder_path, 'open_file':address.file_path})
if 'submit_comment' in request.POST:
add_comment(request, address)
#Create new folder
if 'file' in request.FILES:
upload_file(request, address.folder.id)
if 'new_folder_name' in request.POST:
folder_name = str(request.POST.get('new_folder_name'))
if folder_name.strip():
p = Folder(name = folder_name, parent_folder = address.folder.id, folder_path = address.folder_path+'/'+folder_name)
p.save()
#Remove folder and all sub-folders of that folder
for folder_id in [a for a, b in request.POST.iteritems() if b == 'Delete']:
remove_folder(folder_id)
sub_folders = Folder.objects.filter(parent_folder=address.folder.id)
sub_files = File.objects.filter(parent_folder = address.folder.id)
relevant_comments = Comment.objects.filter(attached_to_type = address.type, attached_to_id = address.id)
try:
parent_folder = Folder.objects.get(id = address.folder.parent_folder)
except:
parent_folder = None
return render_to_response('documents_folders/blah.html', {'relevant_comments':relevant_comments, 'sub_folders': sub_folders, 'current_folder_path': address.folder.folder_path, 'parent_folder': parent_folder, 'sub_files':sub_files, 'open_file':address.file_path, 'current_path': '/documents/'+rest_of_address}, context_instance=RequestContext(request))
def post(self):
user = get_user_from_id(session['user_id'])
name = request.json['name']
new_folder = Folder(name=name)
new_folder.user_id = user.id
db.session.add(new_folder)
db.session.commit()
return {'folder': new_folder.as_json()}, 201
def handle_uploaded_json_file(f, user):
def convert_date(str_date):
new_str = str_date.replace('+00:00','')
try:
new_dt = datetime.strptime(new_str, '%Y-%m-%d %H:%M:%S.%f')
except ValueError:
new_dt = datetime.strptime(new_str, '%Y-%m-%d %H:%M:%S')
return new_dt
with open('notes.json', 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
f.close()
with open('notes.json', 'r') as fh:
json_data = json.load(fh)
fh.close()
version, notes = json_data
# for user in User.objects.all():
# if not Folder.)objects.filter(user = user, name = "Main").exists():
# folder = Folder(name="Main", user = user)
# folder.save()
# if not Folder.objects.filter(user = user, name = ")Trash").exists():
# folder = Folder(name="Trash", user = u)ser)
# folder.save()
for note in notes:
created_at = convert_date(note['created_at'])
title = note['title']
username = note['user']
# TODO: If user is blank we need to assign to a default user. For now just skip.
# Its technically a database integrity violation anyway.
if username is None: continue
user = User.objects.get(username = username)
if not Note.objects.filter(title = title,
created_at = created_at).exists():
new_note = Note()
new_note.title = title
new_note.created_at = created_at
new_note.modified_at = convert_date(note['modified_at'])
new_note.note_type = note['post_type']
new_note.note = note['note']
foldr = note['folder']
try:
folder = Folder.objects.get(name = foldr, user = user)
except Folder.DoesNotExist:
folder = Folder(name = foldr, user = user)
folder.save()
new_note.folder = folder
new_note.user = user
new_note.save()
def test_model_document(self):
"""Test Document Model"""
folder = Folder(name='test')
folder.save()
obj = Document(title='test', folder=folder)
obj.save()
self.assertEquals(folder, obj.folder)
self.assertNotEquals(obj.id, None)
obj.delete()
def test_model_file(self):
"""Test File Model"""
folder = Folder(name='test')
folder.save()
obj = File(name='test', folder=folder)
obj.save()
self.assertEquals(folder, obj.folder)
self.assertNotEquals(obj.id, None)
obj.delete()
def test_model_weblink(self):
"""Test WebLink Model"""
folder = Folder(name='test')
folder.save()
obj = WebLink(title='test', folder=folder, url='test')
obj.save()
self.assertEquals(folder, obj.folder)
self.assertNotEquals(obj.id, None)
obj.delete()
def test_login_required(self):
"""User should be logged it to delete an object."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(reverse('favorites:folder_update', args=(folder.pk,)))
self.assertEquals(response.status_code, 302)
folder.delete()
godzilla.delete()
def RPC__Folder__getRoot(self):
"""Return the main folder for the current user ("My folders"). """
try:
folder = Folder.objects.get(user=self.user, parent=None)
except Folder.DoesNotExist:
folder = Folder(user=self.user, name="My folders")
folder.save()
self.return_api_result({'uuid': folder.uuid, 'name': folder.name})
def test_get(self):
"""User want to update an existing folder."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(reverse('favorites:folder_update', args=(folder.pk,)))
self.assertEquals(response.status_code, 200)
godzilla.delete()
folder.delete()
def test_get(self):
"""Test that the page is reachable with an existing folder."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(reverse('favorites:folder_delete', args=(folder.pk,)))
self.assertEquals(response.status_code, 200)
folder.delete()
godzilla.delete()
def create_folder(user, folder_name):
"""
Args:
user: django.contrib.auth.models.User
returns:
models.Folder
"""
f = Folder(name=folder_name, user=user, times_used=0)
f.save()
return f
def post_folder():
session = create_session()
user_id = g.current_user['sub']
data = json.loads(request.data.decode('utf-8'))
folder = Folder(name=data['name'], user_id=user_id)
session.add(folder)
session.commit()
folder = folder.to_json()
session.close()
return jsonify(folder)
def test_post(self):
"""Submit a delete form with good credentials. Returns a redirect."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
self.client.login(username='******', password='******')
response = self.client.post(reverse('favorites:folder_delete', args=(folder.pk,)), {'object_id': folder.pk})
self.assertEquals(response.status_code, 302)
self.assertEquals(Folder.objects.filter(user=godzilla).count(), 0)
godzilla.delete()
def test_invalid_permission(self):
"""Try to delete a folder owned by someone else. Returns a 403."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
response = self.client.post(reverse('favorites:folder_delete', args=(folder.pk,)), {'object_id': folder.pk})
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
def create_folder(request, internal=False):
folder_form = FolderForm(request.POST or None)
if folder_form is not None and folder_form.is_valid():
title = folder_form.cleaned_data['title']
owner = Searcher.objects.filter(user_profile=request.user)[0]
new_folder = Folder(title=title, owner=owner)
new_folder.save()
else:
print "error"
if internal:
return new_folder
def test_invalid_permission_on_favorite(self):
"""User should own the folder to delete it. Returns a 403."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=leviathan)
folder.save()
response = self.client.get(reverse('favorites:folder_update', args=(folder.pk,)))
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
folder.delete()
def test_post(self):
"""Submit a delete form with good credentials. Returns a redirect."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
self.client.login(username='******', password='******')
response = self.client.post(
reverse('favorites:folder_delete', args=(folder.pk, )),
{'object_id': folder.pk})
self.assertEquals(response.status_code, 302)
self.assertEquals(Folder.objects.filter(user=godzilla).count(), 0)
godzilla.delete()
def test_get(self):
"""User request a valid content type / folder combination. Returns 200."""
godzilla = self.user('godzilla')
japan = Folder(name='japan', user=godzilla)
japan.save()
china = Folder(name='china', user=godzilla)
china.save()
def create_favorites(model, folder):
m = model()
m.save()
favorite = Favorite.objects.create_favorite(m, godzilla, folder)
return m, favorite
japan_folder_pks = []
instances = []
for _ in range(5):
instance, favorite = create_favorites(DummyModel, japan)
japan_folder_pks.append(favorite.pk)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(DummyModel, china)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(BarModel, japan)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(BarModel, china)
instances.append((instance, favorite))
self.client.login(username='******', password='******')
target_url = reverse('favorites:favorite_content_type_and_folder_list',
kwargs = {
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name,
'folder_id': japan.pk
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
self.assertIsNotNone(response.context['favorites'])
for instance in response.context['favorites']:
self.assertIn(instance.pk, japan_folder_pks)
godzilla.delete()
for instance in instances:
instance[0].delete()
instance[1].delete()
japan.delete()
china.delete()
def test_invalid_permission(self):
"""Try to delete a folder owned by someone else. Returns a 403."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
response = self.client.post(
reverse('favorites:folder_delete', args=(folder.pk, )),
{'object_id': folder.pk})
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
def test_post(self):
"""User submit a valid POST request, updating the folder. Returns a redirect."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.post(reverse('favorites:folder_update', args=(folder.pk,)),
{'name': 'Nippon-koku'})
self.assertEquals(response.status_code, 302)
folder = Folder.objects.get(pk=folder.pk)
self.assertEquals(folder.name, 'Nippon-koku')
godzilla.delete()
folder.delete()
def RPC__Folder__create(self, name, uuid=None):
"""Create a new folder and add it to a parent with the given ``uuid``. """
try:
if uuid is not None:
parent = Folder.objects.get(user=self.user, uuid=uuid)
else:
parent = None
except Folder.DoesNotExist:
self.return_api_error('does-not-exist')
else:
folder = Folder(user=self.user, parent=parent, name=name)
folder.save()
self.return_api_result({'uuid': folder.uuid})
def folders():
if request.method == 'POST':
req = request.get_json()
try:
f = Folder.create(name=req['name'])
f.save()
return jsonify(message='OK'), 201
except peewee.IntegrityError as e:
print e
return jsonify(message='error'), 409
if request.method == 'GET':
folders = Folder.select()
items = [x.name for x in folders]
return jsonify(message='OK', items=items)
def test_get_owned_favorites_only(self):
"""User should only see her/his favorites."""
# setup
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
def create_object_n_favorite(user, folder=None):
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, user, folder)
return dummy, favorite
godzilla_instances = []
godzilla_favorite_pks = []
for i in range(5):
instance, favorite = create_object_n_favorite(godzilla)
godzilla_instances.append((instance, favorite))
godzilla_favorite_pks.append(favorite.pk)
japan = Folder(name='japan', user=godzilla)
japan.save()
for i in range(5):
instance, favorite = create_object_n_favorite(godzilla, japan)
godzilla_instances.append((instance, favorite))
godzilla_favorite_pks.append(favorite.pk)
leviathan_instances = []
for i in range(5):
leviathan_instances.append(create_object_n_favorite(leviathan))
# tests
target_url = reverse('favorites:favorite_content_type_list',
kwargs={
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
self.assertIsNotNone(response.context['favorites'])
for instance in response.context['favorites']:
self.assertIn(instance.pk, godzilla_favorite_pks)
# teardown
for instances in (leviathan_instances, godzilla_instances):
for instance, favorite in instances:
instance.delete()
favorite.delete()
godzilla.delete()
leviathan.delete()
def folders_add(user):
if not user.admin:
return error_response("not_admin", "You must be an administrator to "
"add a folder")
schema = {
"type": "object",
"properties": {
"name": {"type": "string"}
},
"required": ["name"]
}
error = validate_schema(request.json, schema)
if error:
return error
folder = request.json
if not folder.get("name").strip():
return error_response("input_validation_fail", "You must supply a name "
"for this folder");
if Folder.query.filter(Folder.name==folder.get("name")).count():
return error_response("already_exists", "A folder with that name "
"already exists")
f = Folder(name=folder.get("name"))
db_session.add(f)
db_session.commit()
return jsonify(success=True, folder_id=f.id)
def get(self, key):
filelist = FileList.get(key)
folders = Folder.all().order('count')
self.render('views/admin/fileedit.html', {
'filelist': filelist,
'folders': folders
})
def getSubFolders(folder_key):
logging.info('getSubfolders(): Start')
#temporary class to save folder details temporarily before saving it in to folder dictionary.
class folderclass:
pass
#declare alist to store subfolders. Lists needs to be declared before using it
subfolders_list = []
#get subfolders in this folder
#create query to find folders with filter parent_folder = folder_key - folder key retrieved from the GUI interface
subfolders = Folder.query(Folder.parent_folder == folder_key).order(
Folder.name).fetch()
#iterate through folder contents retrieved by above query
for folder in subfolders:
folder_temp = folderclass(
) #create instance of folderclass to temporarily store folder details before writing to dictionary.
#assign folder details of datastore to temporary folder class
folder_temp.key = folder.key.urlsafe()
folder_temp.name = folder.name
#append this folder details to the list. ___dict__ will return the dictionary format of the object
subfolders_list.append(folder_temp.__dict__)
#subfolders to json format
subfolders_json = json.dumps(subfolders_list)
#return json object
return subfolders_json
def test_get(self):
"""Test that ``folder_list`` url.
Tests that the ``folder_list`` url returns a template
in which user's folders were in the context."""
godzilla = self.user('godzilla')
Folder(name="foo", user=godzilla).save()
Folder(name="bar", user=godzilla).save()
self.client.login(username='******', password='******')
response = self.client.get(reverse('favorites:folder_list'))
for folder in response.context['object_list']:
self.assertIn(folder.name, ['foo', 'bar'])
godzilla.delete()
def register():
if request.method == 'POST':
email = request.form['username']
phone = request.form['phone']
passwd = request.form['passwd']
u = User.query.filter(or_(User.email == email, User.phone == phone)).first()
if u:
if email == u.email:
return render_template(url_for('register'), message='* 该用户名已经存在')
elif phone == u.phone:
return render_template(url_for('register'), message='* 该手机号已经注册')
else:
try:
u = User(email=email, phone=phone, passwd=passwd)
db.session.add(u)
db.session.commit()
user_id = (User.query.filter_by(email=email).first()).id
fo = Folder(name='默认收件箱', user_id=user_id)
db.session.add(fo)
db.session.commit()
except Exception as e:
print(e)
return redirect(url_for('error'))
else:
session['email'] = email
return redirect(url_for('success'))
else:
return render_template('register.html')
def test_get(self):
"""User make a valid request, returns a 200"""
user = User.objects.create(username='******')
user.set_password('user')
user.save()
folder = Folder(user=user, name='name')
folder.save()
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(user=user,
content_object=dummy)
target_url = reverse('favorites:favorite_move_to_folder',
args=(favorite.pk, folder.pk))
client = Client()
self.assertTrue(client.login(username='******', password='******'))
response = client.get(target_url)
self.assertEqual(response.status_code, 200)
def folders():
if request.method == "POST":
req = request.get_json()
try:
f = Folder.create(name=req["name"])
f.save()
return jsonify(message="OK"), 201
except peewee.IntegrityError as e:
return jsonify(message="error"), 409
if request.method == "GET":
query = Folder.select()
if (query.exists()):
return jsonify(message="OK",
data=[model_to_dict(folder) for folder in query])
else:
return jsonify(message="OK", data=[])
def test_get_owned_favorites_only(self):
"""User should only see her/his favorites."""
# setup
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
def create_object_n_favorite(user, folder=None):
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, user, folder)
return dummy, favorite
godzilla_instances = []
godzilla_favorite_pks = []
for i in range(5):
instance, favorite = create_object_n_favorite(godzilla)
godzilla_instances.append((instance, favorite))
godzilla_favorite_pks.append(favorite.pk)
japan = Folder(name='japan', user=godzilla)
japan.save()
for i in range(5):
instance, favorite = create_object_n_favorite(godzilla, japan)
godzilla_instances.append((instance, favorite))
godzilla_favorite_pks.append(favorite.pk)
leviathan_instances = []
for i in range(5):
leviathan_instances.append(create_object_n_favorite(leviathan))
# tests
target_url = reverse('favorites:favorite_content_type_list',
kwargs = {
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
self.assertIsNotNone(response.context['favorites'])
for instance in response.context['favorites']:
self.assertIn(instance.pk, godzilla_favorite_pks)
# teardown
for instances in (leviathan_instances, godzilla_instances):
for instance, favorite in instances:
instance.delete()
favorite.delete()
godzilla.delete()
leviathan.delete()
def create_subfolder(request, parent_id):
parent = Folder.objects.get(pk=parent_id)
name = request.POST['name']
logger.info("Creating subfolder {} of {}".format(name, parent.name))
collection, collection_is_new = Collection.objects.get_or_create(
name="Dummy collection", disk_path="")
new_folder = Folder(name=name,
collection=collection,
disk_path="",
parent=parent)
new_folder.save()
response = {'id': new_folder.id}
return JsonResponse(response)
def test_invalid_permission_on_folder(self):
"""User try to list favorites for a folder he or she doesn't own. Returns a 403."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
folder = Folder(name='china', user=leviathan)
folder.save()
self.client.login(username='******', password='******')
target_url = reverse('favorites:favorite_content_type_and_folder_list',
kwargs = {
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name,
'folder_id': folder.pk
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
folder.delete()
def get_folders():
session = create_session()
user_id = g.current_user['sub']
folders = session.query(Folder).filter_by(user_id=user_id).all()
# 初期フォルダーの作成
# 英語の時どうする？
if len(folders) == 0:
folder = Folder(name="ロングトーン", user_id=user_id)
session.add(folder)
folder = Folder(name="スケール", user_id=user_id)
session.add(folder)
folder = Folder(name="アルペジオ", user_id=user_id)
session.add(folder)
session.commit()
folders = session.query(Folder).filter_by(user_id=user_id).all()
folders = [f.to_json() for f in folders]
session.close()
return jsonify(folders)
def test_get(self):
"""User make a valid request, returns a 200"""
user = User.objects.create(username='******')
user.set_password('user')
user.save()
folder = Folder(user=user, name='name')
folder.save()
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(user=user,
content_object=dummy)
target_url = reverse('favorites:favorite_move_to_folder',
args=(favorite.pk,
folder.pk))
client = Client()
self.assertTrue(client.login(username='******', password='******'))
response = client.get(target_url)
self.assertEqual(response.status_code, 200)
def create_searcher(request):
searcher_form = SearcherForm(request.POST or None)
if searcher_form is not None and searcher_form.is_valid():
name = searcher_form.cleaned_data['name']
user = User.custom_objects.get_or_none(username=name)
if not user:
user = User(username=name)
user.save()
searcher = Searcher(user_profile=user)
root_folder = Folder(title="Bookmarks", owner=searcher)
root_folder.save()
complexity_score = BoozeComplexityScore.objects.create(level=random.randint(0, 4))
searcher.complexity_score = complexity_score
print searcher
searcher.save()
else:
return create_account(request)
return redirect(index)
def test_post(self):
"""User submit a valid form, the favorite is added to his or her favorites."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
dummy = DummyModel()
dummy.save()
target_url = reverse('favorites:favorite_add', kwargs={ # The target model
'app_label': DummyModel._meta.app_label, # doesn't have to be valid
'object_name': DummyModel._meta.module_name,
'object_id': dummy.pk
})
response = self.client.post(target_url,
{'folder_id': folder.pk})
self.assertEquals(response.status_code, 302)
godzilla.delete()
folder.delete()
dummy.delete()
def test_get_empty(self):
"""Tests that ``folder_list`` url list nothing.
Tests that the ``folder_list`` url returns a templates
in which user's folders are injects, except that the user
has no folders. this test testify that an user only his or her
folders."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
Folder(name="foo", user=godzilla).save()
Folder(name="bar", user=godzilla).save()
self.client.login(username='******', password='******')
response = self.client.get(reverse('favorites:folder_list'))
self.assertEquals(len(response.context['object_list']), 0)
Folder.objects.all().delete()
godzilla.delete()
def create_user(name: str, password: str) -> dict:
new_user = User(name=name, password=password)
db.session.add(new_user)
db.session.flush()
root_folder = Folder(user_id=new_user.id, name="root")
db.session.add(root_folder)
db.session.commit()
return {"new_user": new_user.id}
def test_invalid_permission_on_favorite(self):
"""User try to move a favorite he or she doesn't own. Returns a 403."""
user = User.objects.create(username='******')
user.set_password('user')
user.save()
user2 = User.objects.create(username='******')
user2.set_password('user2')
user2.save()
folder = Folder(user=user, name='name')
folder.save()
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(user=user2,
content_object=dummy)
target_url = reverse('favorites:favorite_move_to_folder',
args=(favorite.pk, folder.pk))
client = Client()
self.assertTrue(client.login(username='******', password='******'))
response = client.get(target_url)
self.assertEqual(response.status_code, 403)
def add_folder():
foldername = request.form['foldername']
try:
fo = Folder(name=foldername, user_id=session['id'])
db.session.add(fo)
db.session.commit()
except:
return redirect(url_for('error'))
else:
global folders
folders = Folder.query.filter_by(user_id=session['id']).all()
return redirect(url_for('zhuye'))
def main():
session = create_session()
user = User()
session.add(user)
session.commit()
musics = [Music(user_id=user.id, name="music") for _ in range(5)]
session.add_all(musics)
session.commit()
folder = Folder(name="フォルダ1", user_id=user.id)
session.add(folder)
session.commit()
def scan_directory(dirname):
for root, subdirs, files in os.walk(dirname):
folder = Folder(root)
for file in files:
if is_audio_file(file):
filepath = os.path.join(root, file)
metadata_file = mutagen.File(filepath)
metadata = {}
for key in metadata_file.keys():
metadata[key] = metadata_file.get(key)
song = Song(
title=metadata_file.get('TIT2') or file,
path=filepath,
start_time=0.0,
duration=metadata_file.info.length,
bitrate=metadata_file.info.bitrate,
sample_rate=metadata_file.info.sample_rate,
**metadata)
put_song_in_album(song)
put_song_in_artist(song)
folder.add(song)
# print(song.pprint(verbose=True))
# print('\n')
if folder.num_tracks != 0:
print(folder.pprint())
print('\n')
for key, album in album_map.items():
print(album.pprint())
for song in album.tracks:
print(song.pprint())
for key, artist in artist_map.items():
print(artist.pprint())
def test_get(self):
"""A logged in user ask to move a valid favorite."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, godzilla)
folders = []
for i in range(10):
folder = Folder(name="folder-%s" % i, user=godzilla)
folder.save()
folders.append(folder)
target_url = reverse('favorites:favorite_move',
kwargs={
'object_id': favorite.pk,
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
instance = response.context['favorite']
self.assertEquals(instance.pk, favorite.pk)
favorite.delete()
godzilla.delete()
for folder in folders:
folder.delete()
dummy.delete()
def test_model_folder(self):
"""Test Folder Model"""
obj = Folder(name='test')
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def folder_add(request, response_format='html'):
"New folder form"
if request.POST:
if 'cancel' not in request.POST:
folder = Folder()
form = FolderForm(
request.user.profile, None, request.POST, instance=folder)
if form.is_valid():
folder = form.save()
folder.set_user_from_request(request)
return HttpResponseRedirect(reverse('documents_folder_view', args=[folder.id]))
else:
return HttpResponseRedirect(reverse('document_index'))
else:
form = FolderForm(request.user.profile, None)
context = _get_default_context(request)
context.update({'form': form})
return render_to_response('documents/folder_add', context,
context_instance=RequestContext(request),
response_format=response_format)
