def test_project_update(self):
"Test updating the project"
changed = auth.create_project(user=self.owner, name="New name",
uid=self.project.uid, update=True)
self.assertEqual(changed.uid, self.project.uid)
def handle(self, *args, **options):
uid = options['uid']
name = options['name'] or "Project Name"
privacy = Project.PUBLIC if options["public"] else Project.PRIVATE
update = options["update"]
info = options["info"]
# Find project at uid.
project = Project.objects.get_all(uid=uid).first()
# You can only update existing projects.
if project and not update:
error(f"Project with uid={uid} exists! Set --update to overwrite.")
# Project description may be a text of a file path.
if info and os.path.isfile(info):
# Read the project info from a file.
info = open(info).read()
# Select project owner.
user = User.objects.filter(is_staff=True).first()
# Create the project.
pr = auth.create_project(user=user,
name=name,
uid=uid,
text=info,
update=update,
privacy=privacy)
if update:
print(f"*** Updated project uid={pr.uid} name={pr.name}")
else:
print(f"*** Created project uid={pr.uid} name={pr.name}")
def setUp(self):
logger.setLevel(logging.WARNING)
owner = models.User.objects.filter(is_superuser=True).first()
self.project = auth.create_project(user=owner, name="test",
text="Text", summary="summary", uid="testing")
def make_project_dir(self, root_project, path):
"""
Create a project in the database and refresh the
projects tab in the FTP server so it shows up as a directory.
"""
user = self.fs.user["user"]
if self.fs.projects.filter(name=root_project):
self.respond('550 Directory already exists.')
return
# Create a new project
auth.create_project(user=user, name=root_project)
# Refresh projects tab
self.fs.projects = auth.get_project_list(user=user)
line = self.fs.fs2ftp(path)
self.respond('257 "%s" directory created.' % line.replace('"', '""'))
logger.info(f"path={path}")
return path
def setUp(self):
logger.setLevel(logging.WARNING)
# Set up generic owner
self.owner = models.User.objects.create_user(username="******", email="*****@*****.**", is_staff=True)
self.owner.set_password("test")
# Set up project to edit
self.project = auth.create_project(user=self.owner, name="test", text="Text", summary="summary",
uid="testing")
def setUp(self):
logger.setLevel(logging.WARNING)
# Set up generic owner
self.owner = models.User.objects.create_user(username=f"tested{util.get_uuid(10)}", email="*****@*****.**")
self.owner.set_password("tested")
self.project = auth.create_project(user=self.owner, name="tested", text="Text", summary="summary",
uid="tested")
self.project.save()
# Set up generic data for editing
self.data = auth.create_data(project=self.project, path=__file__, name="tested")
def setUp(self):
logger.setLevel(logging.WARNING)
# Set up generic owner
self.owner = models.User.objects.create_user(username="******", email="*****@*****.**", is_staff=True)
self.owner.set_password("test")
self.factory = RequestFactory()
self.project = auth.create_project(user=self.owner, name="test", text="Text", summary="summary",
uid="testing")
#Test data
self.recipe = auth.create_analysis(project=self.project, json_text="{}", template="")
self.recipe.save()
def parse_json(json,
root,
privacy=Project.PRIVATE,
sticky=False,
jobs=False,
update=False):
"""
Create a project from a JSON data
"""
# Load everything relative to the root.
fpath = os.path.join(root, json)
json_data = hjson.load(open(fpath, 'rb'))
# The base node of the JSON file.
base = json_data.get("settings", {})
store = parse_params(fpath=fpath, base_dict=base)
exists = Project.objects.filter(uid=store.uid).exists()
project = auth.create_project(user=store.user,
uid=store.uid,
summary=store.summary,
name=store.name,
text=store.text,
stream=store.stream,
privacy=privacy,
sticky=sticky,
update=update)
# Avoid duplicating data and recipe when updating a project.
if update or exists:
action = "updated" if update else "exists"
logger.info(
f"Project {action}. You can update the recipes individually. ")
return
# Add extra data specified in the project json file
management.call_command("data", json=fpath, root=root, id=project.id)
analyses = json_data.get("analyses", '')
for row in reversed(analyses):
json = os.path.join(root, row['json'])
template = os.path.join(root, row['template'])
management.call_command("analysis",
id=project.id,
add=True,
json=json,
template=template,
jobs=jobs)
def test_user_delete(self):
"Test deleting a user."
# Set up projects/posts to key user to
project = create_project(user=self.user,
name="tested project",
text="Text",
summary="summary",
uid="testing")
posts = create_post(title="Title of post",
author=self.user,
content="Post content",
post_type=Post.QUESTION)
self.user.delete()
def setUp(self):
logger.setLevel(logging.WARNING)
self.owner = models.User.objects.create(username="******", email="*****@*****.**")
self.owner.set_password("testing")
self.owner.save()
self.project = auth.create_project(user=self.owner, name="Test project",
privacy=models.Project.PUBLIC, uid="testing")
data = auth.create_data(project=self.project, path=__file__)
analysis = auth.create_analysis(project=self.project, json_text='{}', template="")
self.job = auth.create_job(analysis=analysis)
self.proj_params = dict(uid=self.project.uid)
self.analysis_params = dict(uid=analysis.uid)
self.data_params = dict(uid=data.uid)
self.job_params = dict(uid=self.job.uid)
def setUp(self):
logger.setLevel(logging.WARNING)
# Set up generic owner
self.owner = models.User.objects.create_user(username="******",
email="*****@*****.**")
self.owner.set_password("test")
self.project = auth.create_project(user=self.owner,
name="test",
text="Text",
summary="summary",
uid="testing")
self.recipe = auth.create_analysis(project=self.project,
json_text="{}",
template="",
security=models.Analysis.AUTHORIZED)
self.job = auth.create_job(analysis=self.recipe, user=self.owner)
self.job.save()
def parse_json(json, root, privacy=Project.PRIVATE, sticky=False, jobs=False):
"""
Create a project from a JSON data
"""
# Load everything relative to the root.
fpath = os.path.join(root, json)
# The directory that the project file is located in.
dirname = os.path.dirname(fpath)
# This is the
json_data = hjson.load(open(fpath, 'rb'))
# The base node of the JSON file.
base = json_data.get("settings", {})
if not base:
logger.error(f"Project {json} must have a 'settings' key")
sys.exit()
# The uid is a required element.
uid = base.get("uid", None)
if not uid:
logger.error(f"Project 'settings' dictionary must have a 'uid' field.")
sys.exit()
# See if project already exists.
project = Project.objects.filter(uid=uid).first()
# Each project uid may only be loaded once.
if project:
logger.warning(f"Project uid={project.uid} already exists.")
return
# Get more settings into the project.
name = base.get("name", '')
text = base.get("text", '')
summary = base.get("summary", '')
imgpath = join(dirname, base.get("image", ""))
# Set the image file stream.
if os.path.isfile(imgpath):
stream = File(open(imgpath, 'rb'))
else:
stream = None
# Recipes added at the command line will belong to the superuser.
user = User.objects.filter(is_superuser=True).first()
# Setup error. Site has no users.
if not user:
logger.error("No valid user was found.")
return
# Create the project.
project = auth.create_project(user=user,
uid=uid,
summary=summary,
name=name,
text=text,
stream=stream,
privacy=privacy,
sticky=sticky)
# Add extra data specified in the project json file.
management.call_command("data", json=fpath, root=root, id=project.id)
# Add the analyses specified in the project json.
analyses = json_data.get("analyses", '')
# The analyses need are specified relative to the root folder.
for row in reversed(analyses):
other_json = os.path.join(root, row['json'])
template = os.path.join(root, row['template'])
management.call_command("analysis",
id=project.id,
add=True,
json=other_json,
template=template,
jobs=jobs)
def ftp_MKD(self, path):
# Copied from parent class
# The 257 response is supposed to include the directory
# name and in case it contains embedded double-quotes
# they must be doubled (see RFC-959, chapter 7, appendix 2).
root_project, tab, name, tail = parse_virtual_path(ftppath=path)
projects = self.fs.projects
user = self.fs.user["user"]
# Creating a directory at the root dir
if root_project and not tab:
if projects.filter(name=root_project):
self.respond('550 Directory already exists.')
return
else:
# Create a new project
project = auth.create_project(user=user, name=root_project)
self.fs.projects = chain(
projects, models.Project.objects.filter(pk=project.pk))
line = self.fs.fs2ftp(path)
self.respond('257 "%s" directory created.' %
line.replace('"', '""'))
return path
if tab == "data" and name and not tail:
instance = query_tab(tab=tab,
project=root_project,
name=name,
show_instance=True)
if instance:
self.respond('550 Directory already exists.')
return
else:
project = self.fs.projects.filter(name=root_project)
data = auth.create_data(project=project.first(),
user=user,
name=name)
self.fs.data = chain(self.fs.data,
models.Data.objects.filter(pk=data.pk))
line = self.fs.fs2ftp(path)
self.respond('257 "%s" directory created.' %
line.replace('"', '""'))
logger.info(f"path={path}")
return path
# Add the data to the tail and update the toc_name.
logger.info(
f"new_dir={path}, path={path}, root_project={root_project}, project={projects.filter(name=root_project)}"
)
1 / 0
return path
