def mkdir(self, path=None): """ Directory creation view method :param path: Optional directory path. If not provided, will use the base directory """ # Get path and verify if it is valid base_path, directory, path = self._normalize_path(path) dir_url = self._get_dir_url('.index', path) if not self.can_mkdir: flash(gettext('Directory creation is disabled.'), 'error') return redirect(dir_url) if not self.is_accessible_path(path): flash(gettext('Permission denied.'), 'error') return redirect(self._get_dir_url('.index')) form = self.name_form() if self.validate_form(form): try: os.mkdir(op.join(directory, form.name.data)) self.on_mkdir(directory, form.name.data) return redirect(dir_url) except Exception as ex: flash(gettext('Failed to create directory: %(error)s', error=ex), 'error') else: helpers.flash_errors(form, message='Failed to create directory: %(error)s') return self.render(self.mkdir_template, form=form, dir_url=dir_url)
def upload(self, path=None): """ Upload view method :param path: Optional directory path. If not provided, will use the base directory """ # Get path and verify if it is valid base_path, directory, path = self._normalize_path(path) if not self.can_upload: flash(gettext('File uploading is disabled.'), 'error') return redirect(self._get_dir_url('.index', path)) if not self.is_accessible_path(path): flash(gettext('Permission denied.'), 'error') return redirect(self._get_dir_url('.index')) form = self.upload_form() if self.validate_form(form): try: self._save_form_files(directory, path, form) return redirect(self._get_dir_url('.index', path)) except Exception as ex: flash(gettext('Failed to save file: %(error)s', error=ex), 'error') return self.render(self.upload_template, form=form)
def validate_upload(self, field): if not self.upload.data: raise validators.ValidationError(gettext('File required.')) filename = self.upload.data.filename if not self.admin.is_file_allowed(filename): raise validators.ValidationError(gettext('Invalid file type.'))
def pre_validate(self, form): if self._is_uploaded_file(self.data) and not self.is_file_allowed(self.data.filename): raise ValidationError(gettext('Invalid file extension')) # Handle overwriting existing content if not self._is_uploaded_file(self.data): return if self._allow_overwrite == False and os.path.exists(self._get_path(self.data.filename)): raise ValidationError(gettext('File "%s" already exists.' % self.data.filename))
def action_delete(self, items): if not self.can_delete: flash(gettext('File deletion is disabled.'), 'error') return for path in items: base_path, full_path, path = self._normalize_path(path) if self.is_accessible_path(path): try: os.remove(full_path) flash(gettext('File "%(name)s" was successfully deleted.', name=path)) except Exception as ex: flash(gettext('Failed to delete file: %(name)s', name=ex), 'error')
def rename(self): """ Rename view method """ form = self.name_form() path = form.path.data if path: base_path, full_path, path = self._normalize_path(path) return_url = self._get_dir_url('.index', op.dirname(path)) else: return redirect(self.get_url('.index')) if not self.can_rename: flash(gettext('Renaming is disabled.'), 'error') return redirect(return_url) if not self.is_accessible_path(path): flash(gettext('Permission denied.'), 'error') return redirect(self._get_dir_url('.index')) if not op.exists(full_path): flash(gettext('Path does not exist.'), 'error') return redirect(return_url) if self.validate_form(form): try: dir_base = op.dirname(full_path) filename = secure_filename(form.name.data) os.rename(full_path, op.join(dir_base, filename)) self.on_rename(full_path, dir_base, filename) flash(gettext('Successfully renamed "%(src)s" to "%(dst)s"', src=op.basename(path), dst=filename)) except Exception as ex: flash(gettext('Failed to rename: %(error)s', error=ex), 'error') return redirect(return_url) else: helpers.flash_errors(form, message='Failed to rename: %(error)s') return self.render(self.rename_template, form=form, path=op.dirname(path), name=op.basename(path), dir_url=return_url)
def update_model(self, form, model): """ Update model helper :param form: Form instance :param model: Model instance to update """ try: form.populate_obj(model) self._on_model_change(form, model, False) model.save() except Exception as ex: if not self.handle_view_exception(ex): flash(gettext('Failed to update record. %(error)s', error=format_error(ex)), 'error') log.exception('Failed to update record.') return False else: self.after_model_change(form, model, False) return True
def create_model(self, form): """ Create model from form. :param form: Form instance """ try: with self.session.begin_nested(): model = self.model() form.populate_obj(model) self.session.add(model) self._on_model_change(form, model, True) self.session.flush() except Exception as ex: if not self.handle_view_exception(ex): flash(gettext('Failed to create record. %(error)s', error=str(ex)), 'error') log.exception('Failed to create record.') transaction.doom() return False else: self.after_model_change(form, model, True) return model
def action_delete(self, ids): try: model_pk = getattr(self.model, self._primary_key) if self.fast_mass_delete: count = self.model.delete().where(model_pk << ids).execute() else: count = 0 query = self.model.select().filter(model_pk << ids) for m in query: self.on_model_delete(m) m.delete_instance(recursive=True) count += 1 flash( ngettext( "Record was successfully deleted.", "%(count)s records were successfully deleted.", count, count=count, ) ) except Exception as ex: if not self.handle_view_exception(ex): flash(gettext("Failed to delete records. %(error)s", error=str(ex)), "error")
def action_delete(self, ids): try: query = get_query_for_ids(self.get_query(), self.model, ids) if self.fast_mass_delete: count = query.delete(synchronize_session=False) else: count = 0 for m in query.all(): if self.delete_model(m): count += 1 self.session.flush() flash(ngettext('Record was successfully deleted.', '%(count)s records were successfully deleted.', count, count=count)) except Exception as ex: if not self.handle_view_exception(ex): raise transaction.doom() flash(gettext('Failed to delete records. %(error)s', error=str(ex)), 'error')
def update_model(self, form, model): """ Update model from form. :param form: Form instance :param model: Model instance """ try: with self.session.begin_nested(): form.populate_obj(model) self._on_model_change(form, model, False) except Exception as ex: if not self.handle_view_exception(ex): flash(gettext('Failed to update record. %(error)s', error=str(ex)), 'error') log.exception('Failed to update record.') transaction.doom() return False else: self.after_model_change(form, model, False) return True
def _save_form_files(self, directory, path, form): filename = op.join(directory, secure_filename(form.upload.data.filename)) if op.exists(filename): flash(gettext('File "%(name)s" already exists.', name=filename), 'error') else: self.save_file(filename, form.upload.data) self.on_file_upload(directory, path, filename)
def _save_file(self, data, filename): path = self._get_path(filename) if not op.exists(op.dirname(path)): os.makedirs(os.path.dirname(path), self.permission | 0o111) if self._allow_overwrite == False and os.path.exists(path): raise ValueError(gettext('File "%s" already exists.' % path)) data.save(path) return filename
def get_one(self, id): """ Return a single model instance by its ID :param id: Model ID """ try: return self.get_query().filter(pk=id).first() except mongoengine.ValidationError as ex: flash(gettext('Failed to get model. %(error)s', error=format_error(ex)), 'error') return None
def delete_model(self, model): try: self.on_model_delete(model) model.delete_instance(recursive=True) except Exception as ex: if not self.handle_view_exception(ex): flash(gettext("Failed to delete record. %(error)s", error=str(ex)), "error") log.exception("Failed to delete record.") return False else: self.after_model_delete(model) return True
def action_delete(self, ids): try: count = 0 # TODO: Optimize me for pk in ids: if self.delete_model(self.get_one(pk)): count += 1 flash(ngettext('Record was successfully deleted.', '%(count)s records were successfully deleted.', count, count=count)) except Exception as ex: flash(gettext('Failed to delete records. %(error)s', error=str(ex)), 'error')
def action_delete(self, ids): try: count = 0 all_ids = [self.object_id_converter(pk) for pk in ids] for obj in self.get_query().in_bulk(all_ids).values(): count += self.delete_model(obj) flash(ngettext('Record was successfully deleted.', '%(count)s records were successfully deleted.', count, count=count)) except Exception as ex: if not self.handle_view_exception(ex): flash(gettext('Failed to delete records. %(error)s', error=str(ex)), 'error')
def process_formdata(self, valuelist): if valuelist: date_str = u' '.join(valuelist) if date_str.strip(): for format in self.formats: try: timetuple = time.strptime(date_str, format) self.data = datetime.time(timetuple.tm_hour, timetuple.tm_min, timetuple.tm_sec) return except ValueError: pass raise ValueError(gettext('Invalid time format')) else: self.data = None
def update_model(self, form, model): try: form.populate_obj(model) self._on_model_change(form, model, False) model.save() # For peewee have to save inline forms after model was saved save_inline(form, model) except Exception as ex: if not self.handle_view_exception(ex): flash(gettext("Failed to update record. %(error)s", error=str(ex)), "error") log.exception("Failed to update record.") return False else: self.after_model_change(form, model, False) return True
def delete(self): """ Delete view method """ form = self.delete_form() path = form.path.data if path: return_url = self._get_dir_url('.index', op.dirname(path)) else: return_url = self.get_url('.index') if self.validate_form(form): # Get path and verify if it is valid base_path, full_path, path = self._normalize_path(path) if not self.can_delete: flash(gettext('Deletion is disabled.'), 'error') return redirect(return_url) if not self.is_accessible_path(path): flash(gettext('Permission denied.'), 'error') return redirect(self._get_dir_url('.index')) if op.isdir(full_path): if not self.can_delete_dirs: flash(gettext('Directory deletion is disabled.'), 'error') return redirect(return_url) try: shutil.rmtree(full_path) self.on_directory_delete(full_path, path) flash(gettext('Directory "%(path)s" was successfully deleted.', path=path)) except Exception as ex: flash(gettext('Failed to delete directory: %(error)s', error=ex), 'error') else: try: os.remove(full_path) self.on_file_delete(full_path, path) flash(gettext('File "%(name)s" was successfully deleted.', name=path)) except Exception as ex: flash(gettext('Failed to delete file: %(name)s', name=ex), 'error') else: helpers.flash_errors(form, message='Failed to delete file. %(error)s') return redirect(return_url)
def _execute_command(self, name, args): """ Execute single command. :param name: Command name :param args: Command arguments """ # Do some remapping new_cmd = self.remapped_commands.get(name) if new_cmd: name = new_cmd # Execute command if name not in self.commands: return self._error(gettext('Cli: Invalid command.')) handler, _ = self.commands[name] return self._result(handler(*args))
def create_model(self, form): """ Create model helper :param form: Form instance """ try: model = form.data self._on_model_change(form, model, True) self.coll.insert(model) except Exception as ex: flash(gettext('Failed to create record. %(error)s', error=str(ex)), 'error') log.exception('Failed to create record.') return False else: self.after_model_change(form, model, True) return model
def delete_model(self, model): """ Delete model helper :param model: Model instance """ try: self.on_model_delete(model) model.delete() except Exception as ex: if not self.handle_view_exception(ex): flash(gettext('Failed to delete record. %(error)s', error=format_error(ex)), 'error') log.exception('Failed to delete record.') return False else: self.after_model_delete(model) return True
def delete_model(self, model): """ Delete model. :param model: Model to delete """ try: with self.session.begin_nested(): self.on_model_delete(model) self.session.delete(model) self.session.flush() except Exception as ex: if not self.handle_view_exception(ex): flash(gettext('Failed to delete record. %(error)s', error=str(ex)), 'error') log.exception('Failed to delete record.') transaction.doom() return False else: self.after_model_delete(model) return True
def __call__(self, field, **kwargs): kwargs.setdefault('data-role', 'select2-ajax') kwargs.setdefault('data-url', get_url('.ajax_lookup', name=field.loader.name)) allow_blank = getattr(field, 'allow_blank', False) if allow_blank and not self.multiple: kwargs['data-allow-blank'] = u'1' kwargs.setdefault('id', field.id) kwargs.setdefault('type', 'hidden') if self.multiple: result = [] ids = [] for value in field.data: data = field.loader.format(value) result.append(data) ids.append(as_unicode(data[0])) separator = getattr(field, 'separator', ',') kwargs['value'] = separator.join(ids) kwargs['data-json'] = json.dumps(result) kwargs['data-multiple'] = u'1' else: data = field.loader.format(field.data) if data: kwargs['value'] = data[0] kwargs['data-json'] = json.dumps(data) placeholder = gettext(field.loader.options.get('placeholder', 'Please select model')) kwargs.setdefault('data-placeholder', placeholder) return HTMLString('<input %s>' % html_params(name=field.name, **kwargs))
def delete_model(self, model): """ Delete model helper :param model: Model instance """ try: pk = self.get_pk_value(model) if not pk: raise ValueError('Document does not have _id') self.on_model_delete(model) self.coll.remove({'_id': pk}) except Exception as ex: flash(gettext('Failed to delete record. %(error)s', error=str(ex)), 'error') log.exception('Failed to delete record.') return False else: self.after_model_delete(model) return True
def update_model(self, form, model): """ Update model helper :param form: Form instance :param model: Model instance to update """ try: model.update(form.data) self._on_model_change(form, model, False) pk = self.get_pk_value(model) self.coll.update({'_id': pk}, model) except Exception as ex: flash(gettext('Failed to update record. %(error)s', error=str(ex)), 'error') log.exception('Failed to update record.') return False else: self.after_model_change(form, model, False) return True
def operation(self): return gettext('smaller than')
def operation(self): return gettext('greater than')
def operation(self): return gettext('not contains')