Example usage for org.springframework.security.core.userdetails UsernameNotFoundException getClass

List of usage examples for org.springframework.security.core.userdetails UsernameNotFoundException getClass

Introduction

In this page you can find the example usage for org.springframework.security.core.userdetails UsernameNotFoundException getClass.

Prototype

@HotSpotIntrinsicCandidate
public final native Class<?> getClass();

Source Link

Document

Returns the runtime class of this Object .

Usage

From source file:net.navasoft.madcoin.backend.services.rest.impl.SessionService.java

/**
 * Login./*from  w w w.j a  va2s  . c  om*/
 * 
 * @param loginRequested
 *            the login requested
 * @return the user info success response vo
 * @since 31/08/2014, 07:37:51 PM
 */
public SuccessResponseVO login(SuccessRequestVO loginRequested) {
    SessionSuccessResponseVO response;
    try {
        loginRequested.processValues(this);
        requestingUser = String.valueOf(loginRequested.extractValue("requestingUser"));// (String)
        // loginRequested.getAttribute("Username");
        passwordProvided = BCrypt.hashpw(String.valueOf(loginRequested.extractValue("passwordProvided")),
                BCrypt.gensalt(14));// (String)
        // loginRequested.getAttribute("Password");
        type = (UserTypes) loginRequested.extractValue("type");
        model = String.valueOf(loginRequested.extractValue("model"));
        operativeSystem = String.valueOf(loginRequested.extractValue("operativeSystem"));
        serial = String.valueOf(loginRequested.extractValue("serial"));
        version = String.valueOf(loginRequested.extractValue("version"));
        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(requestingUser,
                passwordProvided);
        Authentication auth;
        String generatedToken;
        switch (type) {
        case END_USER_TYPE:
            response = new UserInfoSuccessResponseVO();
            auth = authenticationManager.authenticate(token);
            // SecurityContextHolder.getContext().setAuthentication(auth);
            generatedToken = tokenGenerator.getToken(requestingUser, passwordProvided);
            response.setToken(generatedToken.replace("+", "%2B").replace("/", "%2F"));
            requestAddress = String.valueOf(loginRequested.extractValue("requestAddress"));
            EndUsersPK key = new EndUsersPK();
            key.setAppUsername(auth.getName());
            EndUsers user = accessor.getByLogicalId(key);
            user.setLastLoggedIp(requestAddress);
            user.setLastLogged(Calendar.getInstance().getTime());
            try {
                user = accessor.edit(user);
            } catch (NonexistentEntityException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
            response.setFullName(user.getUserNames() + " " + user.getLastName());
            response.setEmail(user.getEmail());
            ((UserInfoSuccessResponseVO) response).setLastSuccessLoggedOn(user.getLastLogged());
            ((UserInfoSuccessResponseVO) response).setLastSuccessLoggedIP(user.getLastLoggedIp());
            ((UserInfoSuccessResponseVO) response).setLastSuccessLoggedWay(AllowedChannels
                    .valueOf(StringUtils.defaultString(user.getLastLoggedWay(), AllowedChannels.NONE.name())));
            response.setLastPasswordReset(user.getLastPasswordReset());
            response.setCreatedSince(user.getCreatedSince());
            response.setUserType(user.getIdUserType().getEndUserType());
            response.setUserTypeDescription(user.getIdUserType().getEndUserDescription());
            ((UserInfoSuccessResponseVO) response).setMobile(user.getMobile());
            ((UserInfoSuccessResponseVO) response).setBirthAge(user.getBirthAge());
            return response;
        case SERVICE_PROVIDER_TYPE:
            response = new ProviderInfoSuccessResponseVO();
            auth = authenticationProvider.authenticate(token);
            generatedToken = tokenGenerator.getToken(requestingUser, passwordProvided);
            response.setToken(generatedToken.replace("+", "%2B").replace("/", "%2F"));
            requestAddress = String.valueOf(loginRequested.extractValue("requestAddress"));
            ServiceProvidersPK keyProv = new ServiceProvidersPK();
            keyProv.setAppUsername(auth.getName());
            ServiceProviders userProv = accessorProvider.getByLogicalId(keyProv);
            // accessorProv.update(user);
            response.setFullName(userProv.getName() + " " + userProv.getLastName());
            response.setEmail(userProv.getEmail());
            response.setCreatedSince(userProv.getAuthorizedOn());
            response.setUserType(userProv.getProviderRole().getProviderType());
            response.setUserTypeDescription(userProv.getProviderRole().getProviderType());
            return response;
        }
        response = null;
    } catch (BadCredentialsException unmatched) {
        System.out.println("unmatched");
        throw ControllerExceptionFactory.createException(unmatched.getClass().getCanonicalName(), 3,
                loginRequested.getErrorProcessingValues());
    } catch (UsernameNotFoundException notfound) {
        System.out.println("notfound");
        throw ControllerExceptionFactory.createException(notfound.getClass().getCanonicalName(), 3,
                loginRequested.getErrorProcessingValues());
    } catch (DisabledException unable) {
        System.out.println("unable");
        throw ControllerExceptionFactory.createException(unable.getClass().getCanonicalName(), 3,
                loginRequested.getErrorProcessingValues());
    }
    return response;
}

From source file:net.navasoft.madcoin.backend.services.rest.impl.SessionService.java

/**
 * Sign up user./*from  w  w w .j  ava 2s .  co m*/
 * 
 * @param newUser
 *            the new user
 * @return the success response vo
 * @since 31/08/2014, 07:37:51 PM
 */
@Override
public SuccessResponseVO signUpUser(SuccessRequestVO newUser) {
    AppSignupSuccessResponseVO response = new AppSignupSuccessResponseVO();
    try {
        newUser.processValues(this);
        requestingUser = String.valueOf(newUser.extractValue("requestingUser"));
        passwordProvided = BCrypt.hashpw(String.valueOf(newUser.extractValue("passwordProvided")),
                BCrypt.gensalt(14));
        birthAge = Date.class.cast(newUser.extractValue("birthAge"));
        email = String.valueOf(newUser.extractValue("email"));
        first_names = String.valueOf(newUser.extractValue("first_names"));
        last_names = String.valueOf(newUser.extractValue("last_names"));
        mobile = String.valueOf(newUser.extractValue("mobile"));
        gender = (AllowedGender) (newUser.extractValue("gender"));
        model = String.valueOf(newUser.extractValue("model"));
        operativeSystem = String.valueOf(newUser.extractValue("operativeSystem"));
        serial = String.valueOf(newUser.extractValue("serial"));
        version = String.valueOf(newUser.extractValue("version"));
        type = UserTypes.class.cast(newUser.extractValue("type"));

        switch (type) {
        case END_USER_TYPE:
            if (requestingUser == null) {
                requestingUser = first_names.substring(0, 2)
                        + last_names.substring(last_names.length() - 5, last_names.length() - 1)
                        + String.valueOf(System.currentTimeMillis()).toLowerCase().toString().trim()
                                .substring(0, 18);
            }

            requestAddress = String.valueOf(newUser.extractValue("requestAddress"));
            EndUsersPK key = new EndUsersPK();
            key.setAppUsername(requestingUser);
            EndUsers user = new EndUsers();
            user.setEndUsersPK(key);
            user.setUserNames(first_names);
            user.setLastName(last_names);
            user.setAppPassword(passwordProvided);
            user.setBirthAge(birthAge);
            user.setCreatedSince(Calendar.getInstance().getTime());
            user.setEmail(email);
            user.setMobile(mobile);
            user.setUserStatus(1);
            user.setIdUserType(new EndUserTypes(5));

            EndUsers createdUser = accessor.create(user);

            // if (validateOrigin()) {
            // Collection<UserAuthors> originData = new
            // ArrayList<UserAuthors>();
            // UserAuthors origin = new UserAuthors();
            // origin.setGadgetModel(model);
            // origin.setGadgetOs(operativeSystem);
            // origin.setGadgetSerial(serial);
            // origin.setGadgetVersion(version);
            // origin.setInternetAddress(requestAddress);
            // origin.setEndUsers(createdUser);
            // originData.add(origin);
            // createdUser.setUserAuthorsCollection(originData);
            // }
            response.setCreatedSince(Calendar.getInstance().getTime());
            response.setEmail(email);
            response.setFullName(requestingUser);
            response.setUserTypeDescription(createdUser.getIdUserType().getEndUserDescription());
            break;
        case SERVICE_PROVIDER_TYPE:
            break;
        default:
            break;
        }
        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(requestingUser,
                passwordProvided);
        authenticationManager.authenticate(token);
        String generatedToken = tokenGenerator.getToken(requestingUser, passwordProvided);
        response.setToken(generatedToken.replace("+", "%2B").replace("/", "%2F"));
        return response;
    } catch (BadCredentialsException unmatched) {
        System.out.println("unmatched");
        throw ControllerExceptionFactory.createException(unmatched.getClass().getCanonicalName(), 3,
                newUser.getErrorProcessingValues());
    } catch (UsernameNotFoundException notfound) {
        System.out.println("notfound");
        throw ControllerExceptionFactory.createException(notfound.getClass().getCanonicalName(), 3,
                newUser.getErrorProcessingValues());
    } catch (DisabledException unable) {
        System.out.println("unable");
        throw ControllerExceptionFactory.createException(unable.getClass().getCanonicalName(), 3,
                newUser.getErrorProcessingValues());
    } catch (AlreadyOnSourceException duplicate) {
        throw duplicate;
    } catch (PreexistingEntityException e) {
        throw new AlreadyOnSourceException(e.getMessage());
    }
}

From source file:net.navasoft.madcoin.backend.services.rest.impl.OrdersService.java

/**
 * Book request.//from ww w .j  a  v  a2s .  c om
 * 
 * @param orderRequest
 *            the order request
 * @return the success response vo
 * @since 31/08/2014, 02:50:04 PM
 */
@Override
public SuccessResponseVO bookRequest(SuccessRequestVO orderRequest) {
    AnswerServiceSuccessResponseVO response = new AppAnswerServiceSuccessResponseVO();
    orderRequest.processValues(this);
    lob = String.valueOf(orderRequest.extractValue("lob"));
    category = String.valueOf(orderRequest.extractValue("category"));
    comments = String.valueOf(orderRequest.extractValue("comments"));
    location = String.valueOf(orderRequest.extractValue("location"));
    minCost = (Long) orderRequest.extractValue("minCost");
    maxCost = (Long) orderRequest.extractValue("maxCost");
    pretendedDate = Date.class.cast(orderRequest.extractValue("pretendedDate"));
    model = String.valueOf(orderRequest.extractValue("model"));
    operativeSystem = String.valueOf(orderRequest.extractValue("operativeSystem"));
    serial = String.valueOf(orderRequest.extractValue("serial"));
    version = String.valueOf(orderRequest.extractValue("version"));
    generatedToken = String.valueOf(orderRequest.extractValue("generatedToken"));
    generatedToken = generatedToken.replace("%2B", "+").replace("%2F", "/");
    try {
        if (tokenGenerator.validate(generatedToken)) {

            UserDetails userRequested = tokenGenerator.getUserFromToken(generatedToken);
            ServiceCategories cat = categoryDAO.getByLogicalId(category);
            if (cat.getParentLob().getLobPrefix().equals(lob)) {
                WorkRequests order = new WorkRequests();
                order.setGenerationDate(Calendar.getInstance().getTime());
                order.setRealArrival(pretendedDate);
                order.setServiceCategories(cat);
                EndUsersPK user = new EndUsersPK();
                user.setAppUsername(userRequested.getUsername());
                EndUsers requestingUser = endUsersDao.getByLogicalId(user);
                order.setComments(comments);
                order.setProcessStatus(OrderStatus.REGISTERED.name());
                try {
                    order = ordersDAO.create(order);
                    WorkRequestLocations locationOrder = new WorkRequestLocations();
                    locationOrder.setAddress(location);
                    locationOrder.setCity("BOGOTA");
                    locationOrder.setAdditionalData(location);
                    locationOrder.setWorkRequests(order);
                    locationDAO.create(locationOrder);
                    WorkRequestsXEndUsers cross = new WorkRequestsXEndUsers();
                    cross.setCreatedOn(Calendar.getInstance().getTime());
                    cross.setEndUsers(requestingUser);
                    cross.setWorkRequests(order);
                    requestorDAO.create(cross);

                    try {
                        order.setMinCost(minCost);
                        order.setMaxCost(maxCost);
                        master.init(order);
                        journal.info("Ejecutando la busqueda...");
                        master.getWorkspace();
                        journal.info("Paralelizando tareas...");
                        master.distribute();
                        journal.info("Ejecutando notificaciones...");
                        master.process();
                        journal.info("Esperando...");
                        master.getProcessedLoad();
                        journal.info("Finalizando...");
                        master.finish();
                    } catch (Exception e) {
                        journal.error(e.getMessage(), e);
                    }

                    response.setOrderSequence(order.getServiceCategories().getCategoryPrefix() + "-"
                            + String.valueOf(order.getWorkRequestsPK().getIdWorkRequests()));
                    response.setOrderStatus(OrderStatus.REGISTERED);
                    ((AppAnswerServiceSuccessResponseVO) response).setAttemptNumber(master.askWorkspace());
                    ((AppAnswerServiceSuccessResponseVO) response).setCyclicInterval(20000L);
                } catch (PersistenceException e) {
                    e.printStackTrace();
                } catch (PreexistingEntityException e) {
                    throw new AlreadyOnSourceException(e.getMessage());
                }
            } else {
                throw ControllerExceptionFactory.createException(
                        InexistentLOBException.class.getCanonicalName(), 2,
                        new ControllerExceptionArgument(lob));
            }

        } else {
            throw ControllerExceptionFactory.createException(BadCredentialsException.class.getCanonicalName(),
                    3, orderRequest.getErrorProcessingValues());
        }
    } catch (BadPaddingException badtoken) {
        throw ControllerExceptionFactory.createException(BadCredentialsException.class.getCanonicalName(), 3,
                orderRequest.getErrorProcessingValues());
    }

    catch (NoResultException categoryNotFound) {
        throw ControllerExceptionFactory.createException(InexistentCategoryException.class.getCanonicalName(),
                2, new ControllerExceptionArgument(category));
    } catch (UsernameNotFoundException invalidUser) {
        throw ControllerExceptionFactory.createException(invalidUser.getClass().getCanonicalName(), 3,
                orderRequest.getErrorProcessingValues());
    }
    return response;
}

From source file:net.navasoft.madcoin.backend.services.rest.impl.OrdersService.java

/**
 * Accept request.//from  w  ww. j  a  v a 2  s. c  o m
 * 
 * @param providerRequest
 *            the provider request
 * @return the success response vo
 * @since 31/08/2014, 02:50:04 PM
 */
@Override
public SuccessResponseVO acceptRequest(SuccessRequestVO providerRequest) {
    AnswerServiceSuccessResponseVO response = new AppAcceptServiceSuccessResponseVO();
    providerRequest.processValues(this);
    lob = String.valueOf(providerRequest.extractValue("lob"));
    category = String.valueOf(providerRequest.extractValue("category"));
    orderID = String.valueOf(providerRequest.extractValue("serviceID")).trim();
    comments = String.valueOf(providerRequest.extractValue("comments"));
    estimatedArrivalDate = Date.class.cast(providerRequest.extractValue("initDate"));
    estimatedClosingDate = Date.class.cast(providerRequest.extractValue("finishDate"));
    model = String.valueOf(providerRequest.extractValue("model"));
    operativeSystem = String.valueOf(providerRequest.extractValue("operativeSystem"));
    serial = String.valueOf(providerRequest.extractValue("serial"));
    version = String.valueOf(providerRequest.extractValue("version"));
    generatedToken = String.valueOf(providerRequest.extractValue("generatedToken"));
    generatedToken = generatedToken.replace("%2B", "+").replace("%2F", "/");
    try {
        if (providerTokenGenerator.validate(generatedToken)) {
            UserDetails providerAccepted = providerTokenGenerator.getUserFromToken(generatedToken);
            ServiceCategories cat = categoryDAO.getByLogicalId(category);
            if (cat.getParentLob().getLobPrefix().equals(lob)) {
                try {
                    WorkRequests order;
                    if (orderID.contains("-")) {
                        String[] compositeId = orderID.split("-");
                        ServiceCategories helper = categoryDAO.getByLogicalId(compositeId[0]);
                        if (!helper.equals(cat)) {
                            throw ControllerExceptionFactory.createException(
                                    InexistentCategoryException.class.getCanonicalName(), 2,
                                    new ControllerExceptionArgument(helper));
                        } else {
                            order = ordersDAO.getByLogicalId(new WorkRequestsPK(Long.valueOf(compositeId[1]),
                                    helper.getIdServiceCategory()));
                        }
                    } else {
                        order = ordersDAO.getByLogicalId(
                                new WorkRequestsPK(Long.valueOf(orderID), cat.getIdServiceCategory()));
                    }
                    if (order.getWorkRequestsXServiceProvidersCollection().size() == 0) {
                        ServiceProvidersPK user = new ServiceProvidersPK();
                        user.setAppUsername(providerAccepted.getUsername());
                        ServiceProviders acceptingUser = providersDao.getByLogicalId(user);
                        WorkRequestsXServiceProviders cross = new WorkRequestsXServiceProviders();
                        cross.setServiceProviders(acceptingUser);
                        cross.setWorkRequests(order);
                        WorkRequestsXServiceProvidersPK key = new WorkRequestsXServiceProvidersPK(
                                acceptingUser.getServiceProvidersPK().getIdServiceProvider(),
                                acceptingUser.getServiceProvidersPK().getAppUsername(),
                                order.getWorkRequestsPK().getIdWorkRequests(),
                                order.getWorkRequestsPK().getCategoryId());
                        cross.setWorkRequestsXServiceProvidersPK(key);
                        cross.setAssignedOn(Calendar.getInstance().getTime());
                        cross = attenderDAO.create(cross);
                        Collection<WorkRequestsXServiceProviders> attenders = new ArrayList<WorkRequestsXServiceProviders>();
                        attenders.add(cross);
                        order.setWorkRequestsXServiceProvidersCollection(attenders);
                        order.setEstimatedArrival(estimatedArrivalDate);
                        order.setEstimatedClosing(estimatedClosingDate);
                        order.setProcessStatus(OrderStatus.ACCEPTED.name());
                        Calendar accepted = Calendar.getInstance();
                        response.setOrderSequence(order.getServiceCategories().getCategoryPrefix() + "-"
                                + String.valueOf(order.getWorkRequestsPK().getIdWorkRequests()));
                        String hashed = BCrypt.hashpw(
                                providerAccepted.getUsername() + accepted.getTimeInMillis(), BCrypt.gensalt());
                        hashed = hashed.substring(hashed.length() - 5);
                        order.setSafetyCode(hashed);
                        order = ordersDAO.edit(order);
                        response.setOrderStatus(OrderStatus.ACCEPTED);
                        ((AppAcceptServiceSuccessResponseVO) response)
                                .setAcceptingMode(AllowedAcceptingMode.PROVIDER_MANUAL_ACCEPT);
                        ((AppAcceptServiceSuccessResponseVO) response).setAcceptedDate(accepted.getTime());
                        ((AppAcceptServiceSuccessResponseVO) response)
                                .setProviderName(providerAccepted.getUsername());
                        ((AppAcceptServiceSuccessResponseVO) response).setSafetyCode(hashed);
                        Calendar proxyDate = Calendar.getInstance();
                        proxyDate.setTime(order.getGenerationDate());
                        proxyDate.setTimeInMillis(accepted.getTimeInMillis() - proxyDate.getTimeInMillis());
                        ((AppAcceptServiceSuccessResponseVO) response).setWaitingTime(proxyDate.getTime());
                        for (WorkRequestsXEndUsers endUser : order.getWorkRequestsXEndUsersCollection()) {
                            // TODO Obtener token de logueo de usuario
                            journal.info("Notifying to user "
                                    + endUser.getEndUsers().getEndUsersPK().getAppUsername() + " with token "
                                    + "df75a122 60b499a0 ae60c94f 4040330d 2e10a37d ba657451 c4df2120 fca8ad25");
                            notifier.sendNotification(new Notification(1,
                                    "Su servicio " + order.getServiceCategories().getCategoryPrefix() + "-"
                                            + order.getWorkRequestsPK().getIdWorkRequests()
                                            + "  ha sido aceptado por " + providerAccepted.getUsername()
                                            + ". Su passcode es: " + hashed,
                                    "default",
                                    "df75a122 60b499a0 ae60c94f 4040330d 2e10a37d ba657451 c4df2120 fca8ad25"));
                        }
                    } else {
                        String providerUser = "";
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                        String acceptedDate = "";
                        for (WorkRequestsXServiceProviders acceptedProviders : order
                                .getWorkRequestsXServiceProvidersCollection()) {
                            providerUser += acceptedProviders.getWorkRequestsXServiceProvidersPK()
                                    .getNameServiceProvider() + ", ";
                            acceptedDate += sdf.format(acceptedProviders.getAssignedOn()) + ", ";
                        }
                        providerUser = providerUser.substring(0, providerUser.length() - 2);
                        acceptedDate = acceptedDate.substring(0, acceptedDate.length() - 2);
                        throw new AlreadyAcceptedException(
                                "Este servicio ya ha sido aceptado por otro(s) proveedor(es): {" + providerUser
                                        + "} en {" + acceptedDate + "}");
                    }
                } catch (NonexistentEntityException e) {
                    throw new InexistentOrderException(
                            "La orden que intenta aceptar no existe en el sistema: {" + orderID + "}");
                } catch (IndexOutOfBoundsException e) {
                    throw new InexistentOrderException(
                            "La orden que intenta aceptar no existe en el sistema: {" + orderID + "}");
                } catch (PushNotificationException e) {
                    e.printStackTrace();
                } catch (PreexistingEntityException e) {
                    throw new AlreadyAcceptedException(e.getMessage());
                } catch (AlreadyAcceptedException e) {
                    throw e;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                throw ControllerExceptionFactory.createException(
                        InexistentLOBException.class.getCanonicalName(), 2,
                        new ControllerExceptionArgument(lob));
            }
        } else {
            throw ControllerExceptionFactory.createException(BadCredentialsException.class.getCanonicalName(),
                    3, providerRequest.getErrorProcessingValues());
        }
    } catch (BadPaddingException badtoken) {
        throw ControllerExceptionFactory.createException(BadCredentialsException.class.getCanonicalName(), 3,
                providerRequest.getErrorProcessingValues());
    }

    catch (NoResultException categoryNotFound) {
        throw ControllerExceptionFactory.createException(InexistentCategoryException.class.getCanonicalName(),
                2, new ControllerExceptionArgument(category));
    } catch (UsernameNotFoundException invalidUser) {
        throw ControllerExceptionFactory.createException(invalidUser.getClass().getCanonicalName(), 3,
                providerRequest.getErrorProcessingValues());
    }
    return response;
}