(commented out mods for SYN-1492

UserController.java

package com.hydrafacial.nani.controllers;

import com.fasterxml.jackson.annotation.JsonUnwrapped;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.hydrafacial.nani.models.CountryCode;
import com.hydrafacial.nani.models.CumulusUser.UserReauthentication;
import com.hydrafacial.nani.models.CumulusUser.UserRegistration;
import com.hydrafacial.nani.models.CumulusUser.UserVerification;
import com.hydrafacial.nani.models.User;
import com.hydrafacial.nani.services.UserService;
import com.hydrafacial.nani.services.UserService.UserDTO;
import com.hydrafacial.nani.services.UserService.UserLookupDTO;
import com.hydrafacial.nani.services.UserServiceImpl.UserLookupDTO;

import org.springframework.graphql.data.method.annotation.Argument;
import org.springframework.graphql.data.method.annotation.MutationMapping;
import org.springframework.graphql.execution.DataFetcherExceptionResolver;
import org.springframework.stereotype.Controller;

import java.util.List;

import graphql.GraphQLError;
import graphql.schema.DataFetchingEnvironment;
import lombok.Builder;
import lombok.Data;
import lombok.experimental.Accessors;
import reactor.core.publisher.Mono;

@Controller
//public abstract class CloudAPIProxyController implements DataFetcherExceptionResolver {
public class UserController {

    private final UserService service;
//    protected ApiStatus apiStatus; // the human-friendly http error response/api status translation (for TPS support - long press in lilo reveals it)
    public UserController(UserService userService) {
        service = userService;
    }

//    public Mono<List<GraphQLError>> resolveException(Throwable exception, DataFetchingEnvironment environment) {
//        // 400
//        // 401
//        // 500
//    }

        // the swagger doc lists this as a required param for the request but i don't see it here
    // nor in the UserLookupInput schema?
    @Accessors(fluent = true)
    @Builder
    @Data
    @JsonDeserialize(builder = UserLookupRequest.UserLookupRequestBuilder.class)
    public static class UserLookupRequest {
        private String dialCode;
        private String email;
        private boolean excludeConsumer;
        private String mobile;
    }

    @Accessors(fluent = true)
    @Builder
    @Data
    @JsonDeserialize(builder = UserReauthenticationRequest.UserReauthenticationRequestBuilder.class)
    public static class UserReauthenticationRequest {
        private String appUserKey;
        private CodeDestination sendCodeTo;
    }

    @Accessors(fluent = true)
    @Builder
    @Data
    @JsonDeserialize(builder = UserRegistrationRequest.UserRegistrationRequestBuilder.class)
    public static class UserRegistrationRequest {
        private String code;
        private CountryCode country;
        private String emailAddress;
        private String firstName;
        private String language;
        private String lastName;
        private String mobileCountryCode;
        private String mobileNumber;
        private String regUserKey;
        private CodeDestination sendCodeTo;
        private String userRole;
    }

    @Accessors(fluent = true)
    @Builder
    @Data
    @JsonDeserialize(builder = UserResponse.UserResponseBuilder.class)
//    public static class UserResponse extends NaniGQLResponse implements ProxiedResponse {
    public static class UserResponse {
        private String appUserKey;
        private String regUserKey;
        private String status;
        @JsonUnwrapped
        private UserDTO user;
//        private ApiStatus apiStatus;

//        from(HttpStatus httpStatus) {
//            //switch and populate apiStatus field
//        }


//        processResponse(ProxiedCall response) {
//            is (instanceof ProxiedCall) {
//                // add apiStatus to response
//
//        }


        public static UserResponse userReauthenticationResult(UserReauthentication userReauthentication) {
            return userReauthentication == null ? null : UserResponse.builder().status(userReauthentication.status().name()).build();
        }

        public static UserResponse userRegistrationResult(UserRegistration userRegistration) {
            return userRegistration == null ? null : UserResponse.builder()
                    .user(User.builder()
                            .appUserKey(userRegistration.user().appUserKey())
                            .firstName(userRegistration.user().firstName())
                            .lastName(userRegistration.user().lastName())
                            .userRole(userRegistration.user().userRole())
                            .mobileNumber(userRegistration.user().mobileNumber())
                            .emailAddress(userRegistration.user().emailAddress())
                            .createDate(userRegistration.user().createDate())
                            .build())
                    .status(userRegistration.status().name())
                    .regUserKey(userRegistration.regUserKey())
                    .build();
        }
    }

    @Accessors(fluent = true)
    @Builder
    @Data
    @JsonDeserialize(builder = UserVerificationRequest.UserVerificationRequestBuilder.class)
    public static class UserVerificationRequest {
        private String appUserKey;
        private String code;
    }

    public enum CodeDestination {
        email,
        mobile
    }

    //    @QueryMapping("lookupUser") // not having a direct match to the gql entries defeats easy lookup in the IDE
    // should we really ever expect more than a single match? if not then the service shouldn't return a List
    public UserResponse lookupUser(@Argument("user") UserLookupRequest payload) {
        var dto = UserLookupDTO.from(payload);
        var user = service.lookup(dto);
        return UserResponse.builder().user(user).build();
    }

    @MutationMapping("reauthenticateUser")
    public UserResponse reauthenticate(@Argument("user") UserReauthenticationRequest payload) {
        return UserResponse.userReauthenticationResult(service.reauthenticate(payload.appUserKey(), payload.sendCodeTo().name()));
    }

    @MutationMapping("registerUser")
    public UserResponse register(@Argument("user") UserRegistrationRequest payload) {
        return UserResponse.userRegistrationResult(service.register(from(payload), payload.regUserKey(), payload.sendCodeTo().name(), payload.code()));
    }

    @MutationMapping("verifyUser")
    public UserResponse verify(@Argument("user") UserVerificationRequest payload) {
        return UserResponse.userVerificationResponse(service.verify(payload.appUserKey(), payload.code()));
    }

}