@Override
 public Account getAccountByKeys(String access, String secretKey) {
   try {
     Credential credential =
         create()
             .selectFrom(CREDENTIAL)
             .where(CREDENTIAL.STATE.eq(CommonStatesConstants.ACTIVE))
             .and(CREDENTIAL.PUBLIC_VALUE.eq(access))
             .and(CREDENTIAL.KIND.in(SUPPORTED_TYPES.get()))
             .fetchOne();
     if (credential == null) {
       return null;
     }
     boolean secretIsCorrect =
         ApiContext.getContext()
             .getTransformationService()
             .compare(secretKey, credential.getSecretValue());
     if (secretIsCorrect) {
       return create()
           .selectFrom(ACCOUNT)
           .where(
               ACCOUNT
                   .ID
                   .eq(credential.getAccountId())
                   .and(ACCOUNT.STATE.eq(CommonStatesConstants.ACTIVE)))
           .fetchOneInto(AccountRecord.class);
     } else {
       return null;
     }
   } catch (InvalidResultException e) {
     throw new ClientVisibleException(ResponseCodes.CONFLICT, "MultipleKeys");
   }
 }
 @Override
 public Account getAccountByLogin(String publicValue, String secretValue) {
   Credential credential =
       create()
           .selectFrom(CREDENTIAL)
           .where(CREDENTIAL.STATE.eq(CommonStatesConstants.ACTIVE))
           .and(
               CREDENTIAL
                   .PUBLIC_VALUE
                   .eq(publicValue)
                   .and(CREDENTIAL.KIND.equalIgnoreCase(CredentialConstants.KIND_PASSWORD)))
           .fetchOne();
   if (credential == null) {
     return null;
   }
   boolean secretIsCorrect =
       ApiContext.getContext()
           .getTransformationService()
           .compare(secretValue, credential.getSecretValue());
   if (secretIsCorrect) {
     return create()
         .selectFrom(ACCOUNT)
         .where(
             ACCOUNT
                 .ID
                 .eq(credential.getAccountId())
                 .and(ACCOUNT.STATE.eq(CommonStatesConstants.ACTIVE)))
         .fetchOneInto(AccountRecord.class);
   } else {
     return null;
   }
 }
 @Override
 public Account getAccountByUuid(String uuid) {
   return create()
       .selectFrom(ACCOUNT)
       .where(ACCOUNT.UUID.eq(uuid).and(ACCOUNT.STATE.eq(CommonStatesConstants.ACTIVE)))
       .orderBy(ACCOUNT.ID.asc())
       .limit(1)
       .fetchOne();
 }
 @Override
 public Account getAccountById(Long id) {
   return create()
       .selectFrom(ACCOUNT)
       .where(
           ACCOUNT
               .ID
               .eq(id)
               .and(ACCOUNT.STATE.ne(CommonStatesConstants.PURGED))
               .and(ACCOUNT.REMOVED.isNull()))
       .fetchOne();
 }
 @Override
 public Account getAdminAccount() {
   return create()
       .selectFrom(ACCOUNT)
       .where(
           ACCOUNT
               .STATE
               .eq(CommonStatesConstants.ACTIVE)
               .and(ACCOUNT.KIND.eq(AccountConstants.ADMIN_KIND)))
       .orderBy(ACCOUNT.ID.asc())
       .limit(1)
       .fetchOne();
 }
 @Override
 public Account getAccountByExternalId(String externalId, String externalType) {
   return create()
       .selectFrom(ACCOUNT)
       .where(
           ACCOUNT
               .EXTERNAL_ID
               .eq(externalId)
               .and(ACCOUNT.EXTERNAL_ID_TYPE.eq(externalType))
               .and(ACCOUNT.STATE.ne("purged")))
       .orderBy(ACCOUNT.ID.asc())
       .fetchOne();
 }
 @Override
 public List<Account> searchUsers(String username) {
   return create()
       .select(ACCOUNT.fields())
       .from(ACCOUNT)
       .join(CREDENTIAL)
       .on(CREDENTIAL.ACCOUNT_ID.eq(ACCOUNT.ID))
       .where(
           ACCOUNT
               .STATE
               .eq(CommonStatesConstants.ACTIVE)
               .and(CREDENTIAL.STATE.eq(CommonStatesConstants.ACTIVE))
               .and(CREDENTIAL.PUBLIC_VALUE.contains(username))
               .and(CREDENTIAL.KIND.eq(CredentialConstants.KIND_PASSWORD)))
       .orderBy(ACCOUNT.ID.asc())
       .fetchInto(Account.class);
 }
 @Override
 public Account getByUsername(String username) {
   try {
     return create()
         .select(ACCOUNT.fields())
         .from(ACCOUNT)
         .join(CREDENTIAL)
         .on(CREDENTIAL.ACCOUNT_ID.eq(ACCOUNT.ID))
         .where(
             ACCOUNT
                 .STATE
                 .eq(CommonStatesConstants.ACTIVE)
                 .and(CREDENTIAL.STATE.eq(CommonStatesConstants.ACTIVE))
                 .and(CREDENTIAL.PUBLIC_VALUE.eq(username)))
         .and(CREDENTIAL.KIND.eq(CredentialConstants.KIND_PASSWORD))
         .fetchOneInto(AccountRecord.class);
   } catch (InvalidResultException e) {
     throw new ClientVisibleException(ResponseCodes.CONFLICT, "MultipleOfUsername");
   }
 }