def program_entry(request, program_id): """ Process requests for a single `ProgramModel`s. HTTP Methods ------------ DELETE: Removes the specified entry (in the URL) from the database. PUT: Updates the specified entry (in the URL) in the database. Parameters ---------- request: HttpRequest The request which should be processed. Returns ------- HttpResponse: If the HTTP method is not supported, then an `HttpResponseForbidden` is returned. """ if request.method == 'DELETE': try: ProgramModel.objects.get(id=program_id).delete() return StatusResponse.ok('') except ProgramModel.DoesNotExist as err: return StatusResponse(ProgramNotExistError(err, program_id)) elif request.method == 'PUT': # create form from a new QueryDict made from the request body # (request.PUT is unsupported) as an update (instance) of the # existing slave try: model = ProgramModel.objects.get(id=program_id) form = ProgramForm(QueryDict(request.body), instance=model) if form.is_valid(): program = form.save(commit=False) try: program.full_clean() form.save() return StatusResponse.ok('') except ValidationError as _: error_dict = { 'name': [ 'Program with this Name already exists on this Client.' ] } return StatusResponse.err(error_dict) else: return StatusResponse.err(form.errors) except ProgramModel.DoesNotExist as err: return StatusResponse(ProgramNotExistError(err, program_id)) else: return HttpResponseForbidden()
def script_put_post(data, script_id): """ This functions removes code duplication for `script_entry` and `script_set`. The logic for the PUT and POST method inside these functions are identical. For more information take a look at `script_entry` or `script_set` """ try: script = Script.from_json(data) if script_id is None: script.save() else: (new_model, _) = ScriptModel.objects.update_or_create( id=script_id, defaults={"name": script.name}, ) SGFModel.objects.filter(script_id=script_id).delete() SGPModel.objects.filter(script_id=script_id).delete() for program in script.programs: program.save(new_model) for filesystem in script.filesystems: filesystem.save(new_model) return StatusResponse.ok('') except FsimError as err: return StatusResponse(err) except KeyError as err: return StatusResponse.err("Could not find required key {}".format( err.args[0])) except TypeError as err: return StatusResponse.err(str(err)) except ValueError as err: return StatusResponse.err(str(err)) except ValidationError as err: return StatusResponse.err('; '.join(err.messages)) except IntegrityError as err: return StatusResponse.err(str(err))
def slave_entry(request, slave_id): """ Process requests for a single `SlaveModel`s. HTTP Methods ------------ DELETE: Removes the specified entry (in the URL) from the database. PUT: Updates the specified entry (in the URL) in the database. Parameters ---------- request: HttpRequest The request which should be processed. Returns ------- HttpResponse: If the HTTP method is not supported, then an `HttpResponseForbidden` is returned. """ if request.method == 'DELETE': try: SlaveModel.objects.get(id=slave_id).delete() return StatusResponse.ok('') except SlaveModel.DoesNotExist as err: return StatusResponse(SlaveNotExistError(err, slave_id)) elif request.method == 'PUT': try: # create form from a new QueryDict made from the request body # (request.PUT is unsupported) as an update (instance) of the # existing slave model = SlaveModel.objects.get(id=slave_id) form = SlaveForm(QueryDict(request.body), instance=model) if form.is_valid(): form.save() return StatusResponse.ok('') else: return StatusResponse.err(form.errors) except SlaveModel.DoesNotExist as err: return StatusResponse(SlaveNotExistError(err, slave_id)) else: return HttpResponseForbidden()
def filesystem_set(request): """ Process requests on a set of `FilesystemModel`s. HTTP Methods ------------ POST: Adds a new `FilesystemModel` to the database. GET: query with (?q=None) Searches for the name which is like ".*q.*" GET: query with (?slave=None&is_string=False) Searches for all `FilesystemModel`s which belong to the given `slave`. Where `is_string` specifies if the given `slave` is an unique name or and unique index. Parameters ---------- request: HttpRequest The request which should be processed. Returns ------- HttpResponse: If the HTTP method is not supported, then an `HttpResponseForbidden` is returned. """ if request.method == 'POST': form = FilesystemForm(request.POST or None) if form.is_valid(): filesystem = form.save(commit=False) filesystem.slave = form.cleaned_data['slave'] try: filesystem.full_clean() # IMPORTANT: remove trailing path seperator (if not the query # will not work [the query in filesystem_move]) filesystem.destination_path = up.remove_trailing_path_seperator( filesystem.destination_path) filesystem.source_path = up.remove_trailing_path_seperator( filesystem.source_path) form.save() return StatusResponse.ok("") except ValidationError as err: LOGGER.warning( "Error while adding filesystem `%s`: %s", filesystem.name, err, ) string = err.message_dict['__all__'][0] if 'Source path' in string and 'Destination path' in string and 'Slave' in string: error_msg = 'Filesystem with this source path and destination path already exists on this Client.' error_dict = { 'source_path': [error_msg], 'destination_path': [error_msg], } elif 'Name' in err.message_dict['__all__'][ 0] and 'Slave' in err.message_dict['__all__'][0]: error_dict = { 'name': [ 'Filesystem with this Name already exists on this Client.' ] } return StatusResponse.err(error_dict) else: return StatusResponse.err(form.errors) elif request.method == 'GET': query = request.GET.get('q', None) slave = request.GET.get('slave', None) slave_str = request.GET.get('is_string', False) if query is not None: filesystems = FilesystemModel.objects.filter( name__contains=query).values_list( "name", flat=True, ) elif slave is not None: if slave_str: slave_str = convert_str_to_bool(slave_str) try: slave = SlaveModel.from_identifier(slave, slave_str) except FsimError as err: return StatusResponse(err) except SlaveModel.DoesNotExist as err: return StatusResponse(SlaveNotExistError(err, slave)) filesystems = FilesystemModel.objects.filter( slave=slave).values_list( "name", flat=True, ) else: filesystems = FilesystemModel.objects.all().values_list( "name", flat=True, ) return StatusResponse.ok(list(filesystems)) else: return HttpResponseForbidden()
def program_set(request): """ Process requests on a set of `ProgramModel`s. HTTP Methods ------------ POST: Adds a new `ProgramModel` to the database. GET: query with (?q=None) Searches for the name which is like ".*q.*" GET: query with (?slave=None&is_string=False) Searches for all `ProgramModel`s which belong to the given `slave`. Where `is_string` specifies if the given `slave` is an unique name or and unique index. Parameters ---------- request: HttpRequest The request which should be processed. Returns ------- HttpResponse: If the HTTP method is not supported, then an `HttpResponseForbidden` is returned. """ if request.method == 'POST': form = ProgramForm(request.POST or None) if form.is_valid(): program = form.save(commit=False) program.slave = form.cleaned_data['slave'] try: program.full_clean() form.save() return StatusResponse.ok('') except ValidationError as _: error_dict = { 'name': ["Program with this Name already exists on this Client."] } return StatusResponse.err(error_dict) else: return StatusResponse.err(form.errors) elif request.method == 'GET': query = request.GET.get('q', None) slave = request.GET.get('slave', None) slave_str = request.GET.get('is_string', False) if query is not None: progs = ProgramModel.objects.filter( name__contains=query).values_list( "name", flat=True, ) elif slave is not None: if slave_str: slave_str = convert_str_to_bool(slave_str) try: slave = SlaveModel.from_identifier(slave, slave_str) except FsimError as err: return StatusResponse(err) except SlaveModel.DoesNotExist as err: return StatusResponse(SlaveNotExistError(err, slave)) progs = ProgramModel.objects.filter(slave=slave).values_list( "name", flat=True, ) else: progs = ProgramModel.objects.all().values_list( "name", flat=True, ) return StatusResponse.ok(list(progs)) else: return HttpResponseForbidden()
def slave_set(request): """ Process requests on a set of `SlaveModel`s. HTTP Methods ------------ POST: Adds a new `SlaveModel` to the database. GET: query with (?q=None) Searches for the name which is like ".*q.*" GET: query with (?programs=False) If this is True, then all `SlaveModel`s are returned which have a `ProgramModel`. GET: query with (?filesystems=False) If this is True, then all `SlaveModel`s are returned which have a `FilesystemModel`. Parameters ---------- request: HttpRequest The request which should be processed. Returns ------- HttpResponse: If the HTTP method is not supported, then an `HttpResponseForbidden` is returned. """ if request.method == 'POST': form = SlaveForm(request.POST) if form.is_valid(): form.save() return StatusResponse.ok('') return StatusResponse.err(form.errors) elif request.method == 'GET': query = request.GET.get('q', None) programs = request.GET.get('programs', '') programs = convert_str_to_bool(programs) filesystems = request.GET.get('filesystems', '') filesystems = convert_str_to_bool(filesystems) if query is not None: slaves = SlaveModel.objects.filter( name__contains=query).values_list( "name", flat=True, ) elif programs or filesystems: if programs and filesystems: return StatusResponse( SimultaneousQueryError('filesystems', 'programs')) elif programs: slaves = SlaveModel.with_programs() elif filesystems: slaves = SlaveModel.with_filesystems() else: slaves = SlaveModel.objects.all().values_list( 'name', flat=True, ) return StatusResponse.ok(list(slaves)) else: return HttpResponseForbidden()