def DeleteTool(user, ToolID):
tool = GetTool(user, ToolID)
if ToolPermissions.CanAdministrate(user, tool):
tool.DeletedInd = True
tool.save()
else:
raise PermissionDenied
def CopyParameters(user, old_version, new_version):
if ToolPermissions.CanPublish(user, old_version.Tool):
parameters = GetParameters(old_version)
params = {}
for old_param in parameters:
parent_param_id = old_param.ParameterID
param = deepcopy(old_param)
param.ParameterID = None
param.ToolVersion = new_version
#if this is a child parameter, update the parent to the copy of the parent
if param.ParentParameter:
param.ParentParameter = params[
param.ParentParameter.ParameterID]
#save to add copy to datebase with new ID
param.save()
ParameterOptions.CopyOptions(user, old_param, param)
#store the ID change for any child parameters
params[parent_param_id] = param
else:
raise PermissionDenied
def DeleteParameter(user, parameter_id):
param = Parameter.objects.get(ParameterID=parameter_id)
if ToolPermissions.CanEdit(user, param.ToolVersion.Tool):
param.delete()
else:
raise PermissionDenied
def AddParameterOption(user, parameter, text, value):
if ToolPermissions.CanEdit(user, parameter.ToolVersion.Tool):
return ParameterOption.objects.create(ParameterOptionText=text,
ParameterOptionValue=value,
Parameter=parameter)
else:
raise PermissionDenied
def UpdateResources(user, version, resource_manager, resources):
if ToolPermissions.CanEdit(user, version.Tool):
#get existing resources
existing = ToolVersionResource.objects.filter(
ToolVersion=version, ResourceManager=resource_manager)
#loop through new resources, add and update as required
for r in resources:
e = existing.filter(Key=r["Key"])
if len(e) == 0:
#resource doesn;t yet exist so add it
ToolVersionResource.objects.create(
ToolVersion=version,
ResourceManager=resource_manager,
Key=r["Key"],
Value=r["Value"],
Label=r["Label"])
else:
#resource exists so update it
e[0].Value = r["Value"]
e[0].Label = r["Label"]
e[0].save()
else:
raise PermissionDenied
def DeleteExpectedOutput(user, output_id):
output = get_object_or_404(ExpectedOutput, pk=output_id)
if ToolPermissions.CanEdit(user, output.ToolVersion.Tool):
output.delete()
else:
raise PermissionDenied
def GetParameter(user, parameter_id):
param = Parameter.objects.get(ParameterID=parameter_id)
if ToolPermissions.CanView(user, param.ToolVersion.Tool):
return param
else:
raise PermissionDenied
def UpdateAvailability(user, tool, PublicInd):
if ToolPermissions.CanAdministrate(user, tool):
tool.PublicInd = PublicInd
tool.save()
return tool
else:
raise PermissionDenied
def GetParameterAndChildren(user, parameter_id):
param = Parameter.objects.filter(
Q(ParameterID=parameter_id) | Q(ParentParameter_id=parameter_id))
if ToolPermissions.CanView(user, param[0].ToolVersion.Tool):
return param
else:
raise PermissionDenied
def UpdateParameterOption(user, parameter, option_id, text, value):
option = parameter.ParameterOptions.get(pk=option_id)
if ToolPermissions.CanEdit(user, parameter.ToolVersion.Tool):
option.ParameterOptionText = text
option.ParameterOptionValue = value
option.save()
return option
else:
raise PermissionDenied
def UpdateTool(user, tool, ToolName, CategoryID, ToolDescription):
if ToolPermissions.CanEdit(user, tool):
tool.ToolName = ToolName
tool.Category_id = CategoryID
tool.ToolDescription = ToolDescription
tool.save()
return tool
else:
raise PermissionDenied
def CreateFile(user, ToolID, path):
tool = GetTool(user, ToolID)
if ToolPermissions.CanEdit(user, tool):
if os.path.exists(path) and os.path.isfile(path):
raise Exception("Cannot create file with this name. File already exists.")
File.print_to_file(path, '', permissions=0755)
else:
raise PermissionDenied
def PublishToolVersion(user, dev, version_num):
if ToolPermissions.CanPublish(user, dev.Tool):
new = deepcopy(dev)
new.ToolVersionID = None
new.ToolVersionNum = version_num
new.save()
return new
else:
raise PermissionDenied
def ShareTool(user,
tool,
share_user,
Run=True,
Export=False,
Publish=False,
Edit=False,
Admin=False):
ToolPermissions.Share(user, tool, share_user, Run, Export, Publish, Edit,
Admin)
def CopyOutputs(user, old_version, new_version):
if ToolPermissions.CanPublish(user, old_version.Tool):
outputs = old_version.ExpectedOutputs.all()
for out in outputs:
out.ExpectedOutputID = None
out.ToolVersion = new_version
out.save()
else:
raise PermissionDenied
def AddExpectedOutput(user, tool, output_name, file_name, file_type_id):
version = ToolVersions.GetToolVersion(tool, "dev")
if ToolPermissions.CanEdit(user, tool):
return ExpectedOutput.objects.create(OutputName=output_name,
FileName=file_name,
FileType_id=file_type_id,
ToolVersion=version)
else:
raise PermissionDenied
def UpdateToolVersion(user, version, ShortDescription, LongDescription,
Command):
if ToolPermissions.CanEdit(user, version.Tool):
version.ShortDescription = ShortDescription
version.LongDescription = LongDescription
version.Command = Command
version.save()
return version
else:
raise PermissionDenied
def CopyOptions(user, old_parameter, new_parameter):
if ToolPermissions.CanEdit(user, old_parameter.ToolVersion.Tool):
for old_option in old_parameter.ParameterOptions.all():
option = deepcopy(old_option)
option.ParameterOptionID = None
option.Parameter = new_parameter
option.save()
else:
raise PermissionDenied
def CopyResources(user, old_version, new_version):
if ToolPermissions.CanPublish(user, old_version.Tool):
resources = old_version.Resources.all()
for old in resources:
new = old
new.ToolVersionResourceID = None
new.ToolVersion = new_version
new.save()
else:
raise PermissionDenied
def UpdateExpectedOutput(user, output_id, output_name, file_name,
file_type_id):
output = get_object_or_404(ExpectedOutput, pk=output_id)
if ToolPermissions.CanEdit(user, output.ToolVersion.Tool):
output.OutputName = output_name
output.FileName = file_name
output.FileType_id = file_type_id
output.save()
return output
else:
raise PermissionDenied
def UploadFiles(user, ToolID, path, file_dict):
tool = GetTool(user, ToolID)
if ToolPermissions.CanEdit(user, tool):
for k, v in file_dict.iteritems():
for f in file_dict.getlist(k):
with open(os.path.join(path, f.name), 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
os.chmod(os.path.join(path, f.name), 0700)
return os.listdir(path)
else:
raise PermissionDenied
def AddToolVersion(user,
Tool,
ToolVersionNum,
ShortDescription,
LongDescription,
Command=""):
if ToolPermissions.CanPublish(user, Tool):
return ToolVersion.objects.create(Tool=Tool,
ToolVersionNum=ToolVersionNum,
ShortDescription=ShortDescription,
LongDescription=LongDescription,
Command=Command)
else:
raise PermissionDenied
def AddParameter(user, tool, parameter_name, parent_id=None):
version = ToolVersions.GetToolVersion(tool, "dev")
index = len(version.ToolParameters.all())
if ToolPermissions.CanEdit(user, tool):
return Parameter.objects.create(ParameterName=parameter_name,
Context="",
InputBy="user",
Value="",
ParameterType_id=1,
ToolVersion=version,
ParameterIndex=index,
ParentParameter_id=parent_id)
else:
raise PermissionDenied
def UpdateParameter(user, parameter, param_name, context, input_by, value,
multiple, param_type, delimiter, optional, index):
if ToolPermissions.CanEdit(user, parameter.ToolVersion.Tool):
parameter.ParameterName = param_name
parameter.Context = context
parameter.InputBy = input_by
parameter.Value = value
parameter.Multiple = multiple
parameter.ParameterType_id = param_type
parameter.Delimiter = delimiter
parameter.Optional = optional
parameter.ParameterIndex = index
parameter.save()
else:
raise PermissionDenied
def GetFileList(user, ToolID, path):
tool = GetTool(user, ToolID)
if ToolPermissions.CanEdit(user, tool):
return os.listdir(path)
else:
raise PermissionDenied
def ExportTool(user, ToolID):
tool = GetTool(user, ToolID)
if ToolPermissions.CanExport(user, tool):
raise NotImplementedError
else:
raise PermissionDenied
def UnshareTool(user, tool, share_user):
ToolPermissions.Unshare(user, tool, share_user)
def DeleteFile(user, ToolID, path):
tool = GetTool(user, ToolID)
if ToolPermissions.CanEdit(user, tool):
os.remove(path)
else:
raise PermissionDenied
def ReadFile(user, ToolID, path):
tool = GetTool(user, ToolID)
if ToolPermissions.CanEdit(user, tool):
return File.read_file(path)
else:
raise PermissionDenied
def SaveFile(user, ToolID, path, content):
tool = GetTool(user, ToolID)
if ToolPermissions.CanEdit(user, tool):
File.print_to_file(path, content, permissions=0777)
else:
raise PermissionDenied