cb.query().setName_Equal(username);
        });
    }

    public void store(final User user) {
        if (StringUtil.isBlank(user.getSurname())) {
            user.setSurname(user.getName());
        }

        ComponentUtil.getAuthenticationManager().insert(user);

        userBhv.insertOrUpdate(user, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

                f.renameTo(f2);
                try {
                    assertTrue(f2.exists());
                    renamed = true;

                    assertEquals(nameSrc, f.getName());
                    assertEquals(nameTgt, f2.getName());

                    assertFalse(f.exists());
                }
                finally {
                    f2.delete();
                }
            }

     * 
     */
    public FileBothDirectoryInfo ( Configuration config, boolean unicode ) {
        this.config = config;
        this.unicode = unicode;
    }


    @Override
    public String getName () {
        return this.filename;
    }


    @Override
    public int getType () {
        return SmbConstants.TYPE_FILESYSTEM;
    }


    /**
     * @return the fileIndex
     */

            throw new DuplicateParameterException(parameter.getName()
                    + " has been declared multiple times in mojo with goal: " + getGoal() + " (implementation: "
                    + getImplementation() + ")");
        }

        parameters.add(parameter);
    }

    /**
     * @return the list parameters as a Map (keyed by {@link Parameter#getName()}) that is built from

        return nextHeaderIndex + 1 + index
      }

      @Throws(IOException::class)
      private fun readLiteralHeaderWithoutIndexingIndexedName(index: Int) {
        val name = getName(index)
        val value = readByteString()
        headerList.add(Header(name, value))
      }

      @Throws(IOException::class)
      private fun readLiteralHeaderWithoutIndexingNewName() {

        body.dictId = dictId;
        validateApi(body, messages -> {});
        return stopwordsService.getStopwordsFile(body.dictId)
                .map(file -> asStream(new File(file.getPath()).getName()).contentTypeOctetStream().stream(out -> {
                    file.writeOut(out);
                })).orElseGet(() -> {

                (et, vl) -> ((ScheduledJob) et).setJobLogging(DfTypeUtil.toBoolean(vl)), "jobLogging");
        setupEpg(_epgMap, et -> ((ScheduledJob) et).getName(), (et, vl) -> ((ScheduledJob) et).setName(DfTypeUtil.toString(vl)), "name");
        setupEpg(_epgMap, et -> ((ScheduledJob) et).getScriptData(), (et, vl) -> ((ScheduledJob) et).setScriptData(DfTypeUtil.toString(vl)),
                "scriptData");

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends FileAuthentication> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;

        } catch (final IOException e) {
            throw new DictionaryException("Failed to parse " + path, e);
        }
    }

    public String getSimpleName() {
        return new File(path).getName();
    }

    public synchronized void update(final InputStream in) throws IOException {
        try (MappingUpdater updater = new MappingUpdater(null)) {
            reload(updater, in);
        }
    }

    /**
     * @return the parent
     */
    public final SmbResource getParent () {
        return this.parent;
    }


    private final boolean filter ( FileEntry fe ) {
        String name = fe.getName();
        if ( name.length() < 3 ) {
            int h = name.hashCode();
            if ( h == SmbFile.HASH_DOT || h == SmbFile.HASH_DOT_DOT ) {
                if ( name.equals(".") || name.equals("..") )