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 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 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 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_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 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 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 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 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_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 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_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 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 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_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 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 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 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 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 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 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 copyAllSubFolders(folder, target_folder):
#TODO Need to copy subfolders tree contents
logging.info('copyAllSubFolder(): Start')
#Create new folder element to copy the folder
new_folder = Folder(parent=genFolderParentKey())
#Copy the folder to new folder
logging.info('copyAllSubFolders: copying folder |' + folder.name +
'| to: |' + target_folder.name)
new_folder.populate(
**folder.to_dict()
) #to_dict returns the dictionary of 'folder' and '.populate()' will save the value pairs to new folder
#change necessary parameters
new_folder.parent_folder = target_folder.key #parent of new folder should be the target folder
new_folder.date_c = datetime.datetime.now()
new_folder.date_m = datetime.datetime.now()
new_folder.path = target_folder.path + new_folder.name + '/' #path is calcuated from the give target folder's path
#save new folder
new_folder.put()
#find and copy files in this folder
subLinks = Link.query(Link.parent_folder == folder.key).fetch()
for subLink in subLinks:
logging.info("Copying Link: " + subLink.name)
#Create new link
new_link = Link(parent=genLinkParentKey())
#Copy the links to new folder
logging.info('copyAllSubFolders: copying file |' + subLink.name +
'| to: |' + target_folder.name)
new_link.populate(
**subLink.to_dict()
) #to_dict returns the dictionary of 'subLink' and '.populate()' will save the value pairs to new link
new_link.parent_folder = new_folder.key #parent of new folder should be the one provided by the user
new_link.date_c = datetime.datetime.now()
new_link.date_m = datetime.datetime.now()
new_link.path = new_folder.path
#save new link
new_link.put()
#find and copy the subfolders in this folder
subfolders = Folder.query(Folder.parent_folder == folder.key).fetch()
for subfolder in subfolders:
copyAllSubFolders(subfolder, new_folder)
return "success"
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_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 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 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 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 addFolder(params):
logging.info('addFolder(): Start')
folder = Folder(parent=genFolderParentKey(
)) #Create a datastore entity with parent as the key generated above
#assign form data to entity properties
if 'name' in params:
folder.name = params['name']
else:
folder.name = 'Folder'
if 'icon' in params:
folder.icon = params['icon']
else:
folder.icon = '/images/folder-icon.png'
if 'color' in params:
folder.color = params['color']
else:
folder.color = 'Default'
folder.date_c = datetime.datetime.now()
folder.date_m = datetime.datetime.now()
folder.n_items = 0 #this value needs to be calculated and populated.
if 'view' in params:
folder.view = params['view']
else:
folder.view = 'Default'
if 'parent_folder_key' in params:
folder.parent_folder = params['parent_folder_key']
folder.path = params['parent_folder_key'].get(
).path + folder.name + '/' #calculate path from parent folder and save - parent folder path + my name
#increment parent folder's items count and save. Do it only if current folder is not root,
params['parent_folder_key'].get().n_items += 1
params['parent_folder_key'].get().put()
#TODO if no parent folder mentioned, set parent as links
logging.info('Adding Folder - ' + folder.name)
new_folder_key = folder.put() #save the folder and capture the key
return new_folder_key # return the folder key
