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 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)