584 lines
16 KiB
Go
584 lines
16 KiB
Go
package usersroute
|
|
|
|
import (
|
|
b64 "encoding/base64"
|
|
"fmt"
|
|
"math/rand"
|
|
"sync"
|
|
"time"
|
|
|
|
"bitbucket.org/nemt/nemt-portal-api/application/applicationservice"
|
|
"bitbucket.org/nemt/nemt-portal-api/application/third/eligibility/bcbsi"
|
|
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
|
|
"bitbucket.org/nemt/nemt-portal-api/domain"
|
|
"bitbucket.org/nemt/nemt-portal-api/infra/auth"
|
|
"bitbucket.org/nemt/nemt-portal-api/infra/cache"
|
|
"bitbucket.org/nemt/nemt-portal-api/infra/config"
|
|
"bitbucket.org/nemt/nemt-portal-api/server/authorization"
|
|
"bitbucket.org/nemt/nemt-portal-api/server/validation"
|
|
"bitbucket.org/nemt/nemt-portal-api/server/router/routeutils"
|
|
"github.com/labstack/echo"
|
|
"golang.org/x/net/context"
|
|
"googlemaps.github.io/maps"
|
|
)
|
|
|
|
var (
|
|
instance *controller
|
|
once sync.Once
|
|
)
|
|
|
|
type controller struct {
|
|
svc *applicationservice.Service
|
|
cfg *config.Config
|
|
bcbsi *bcbsi.Service
|
|
}
|
|
|
|
func controllerInstance(svc *applicationservice.Service, cfg *config.Config) *controller {
|
|
once.Do(func() {
|
|
instance = &controller{
|
|
svc: svc,
|
|
cfg: cfg,
|
|
bcbsi: bcbsi.New(cfg),
|
|
}
|
|
})
|
|
return instance
|
|
}
|
|
|
|
func (c *controller) handleGetAll(ctx echo.Context) error {
|
|
page, quantity := routeutils.GetPagingParams(ctx)
|
|
|
|
list, err := c.svc.Users.GetAll(quantity, page)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, list)
|
|
}
|
|
|
|
func (c *controller) handleGetByID(ctx echo.Context) error {
|
|
userID, err := routeutils.GetAndValidateStringParam(ctx, "user_uuid", "mandatory field")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
authUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
item, err := c.svc.Users.GetByUUID(userID, "US")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
rides, err := c.svc.Rides.GetByUserUUID(userID, authUser)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
item.Rides = rides
|
|
|
|
return routeutils.ResponseAPIOK(ctx, item)
|
|
}
|
|
|
|
func (c *controller) handlePortalAddress(ctx echo.Context) error {
|
|
userID, err := routeutils.GetAndValidateStringParam(ctx, "user_uuid", "mandatory field")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
item, err := c.svc.Users.GetByUUID(userID, "")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
createdUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
if item.ID == "" {
|
|
return routeutils.ResponseAPIValidationError(ctx, "User not found")
|
|
} else {
|
|
var Address viewmodel.Address
|
|
if err := ctx.Bind(&Address); err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
Address.User = item
|
|
Address.CreatedUserUUID = createdUser.ID
|
|
Address, err = c.svc.Users.SaveAddress(Address)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
Address.User, err = c.svc.Users.GetByUUID(userID, "")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, Address)
|
|
}
|
|
}
|
|
|
|
func (c *controller) handleRemoveAddress(ctx echo.Context) error {
|
|
addressID, err := routeutils.GetAndValidateStringParam(ctx, "address_uuid", "mandatory field")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
err = c.svc.Users.RemoveAddress(addressID)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseNoContent(ctx, addressID)
|
|
}
|
|
|
|
func (c *controller) handlePortalContact(ctx echo.Context) error {
|
|
userID, err := routeutils.GetAndValidateStringParam(ctx, "user_uuid", "mandatory field")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
item, err := c.svc.Users.GetByUUID(userID, "")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
createdUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
if item.ID == "" {
|
|
return routeutils.ResponseAPIValidationError(ctx, "User not found")
|
|
} else {
|
|
var Contact viewmodel.Contact
|
|
if err := ctx.Bind(&Contact); err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
Contact.User = item
|
|
Contact.Author = createdUser
|
|
Contact, err = c.svc.Users.SaveContact(Contact)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
// Contact.User, err = c.svc.Users.GetByUUID(userID, "")
|
|
// if err != nil {
|
|
// return routeutils.HandleAPIError(ctx, err)
|
|
// }
|
|
|
|
return routeutils.ResponseAPIOK(ctx, Contact)
|
|
}
|
|
}
|
|
|
|
func (c *controller) handleRemoveContact(ctx echo.Context) error {
|
|
contactUUID, err := routeutils.GetAndValidateStringParam(ctx, "contact_uuid", "mandatory field")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
contact := viewmodel.Contact{
|
|
ID: contactUUID,
|
|
}
|
|
contact, err = c.svc.Users.RemoveContact(contact)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseNoContent(ctx, contact)
|
|
}
|
|
|
|
func (c *controller) handleMemberAddress(ctx echo.Context) error {
|
|
userID, err := routeutils.GetAndValidateStringParam(ctx, "user_uuid", "mandatory field")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
item, err := c.svc.Users.GetByUUID(userID, "")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
createdUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
if item.ID == "" {
|
|
return routeutils.ResponseAPIValidationError(ctx, "User not found")
|
|
} else {
|
|
var Address viewmodel.Address
|
|
if err := ctx.Bind(&Address); err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
Address.User = item
|
|
Address.CreatedUserUUID = createdUser.ID
|
|
Address, err = c.svc.Users.SaveAddress(Address)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
Address.User, err = c.svc.Users.GetByUUID(userID, "US")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, Address)
|
|
}
|
|
}
|
|
|
|
func (c *controller) handleMemberDetail(ctx echo.Context) error {
|
|
userID, err := routeutils.GetAndValidateStringParam(ctx, "user_uuid", "mandatory field")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
authUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
item, err := c.svc.Users.GetByUUID(userID, "US")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
rides, err := c.svc.Rides.GetByUserUUID(userID, authUser)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
item.Rides = rides
|
|
|
|
if item.ID == "" {
|
|
return routeutils.ResponseAPIValidationError(ctx, "User not found")
|
|
} else {
|
|
return routeutils.ResponseAPIOK(ctx, item)
|
|
}
|
|
}
|
|
|
|
func (c *controller) handlePortalDetail(ctx echo.Context) error {
|
|
userID, err := routeutils.GetAndValidateStringParam(ctx, "user_uuid", "mandatory field")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
item, err := c.svc.Users.GetByUUID(userID, "SP")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
if item.ID == "" {
|
|
return routeutils.ResponseAPIValidationError(ctx, "User not found")
|
|
} else {
|
|
return routeutils.ResponseAPIOK(ctx, item)
|
|
}
|
|
}
|
|
|
|
func (c *controller) stringWithCharset(length int, charset string) string {
|
|
b := make([]byte, length)
|
|
var seededRand *rand.Rand = rand.New(
|
|
rand.NewSource(time.Now().UnixNano()))
|
|
for i := range b {
|
|
b[i] = charset[seededRand.Intn(len(charset))]
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
func (c *controller) generatePassword(n int) string {
|
|
const (
|
|
charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
|
)
|
|
|
|
return c.stringWithCharset(n, charset)
|
|
}
|
|
|
|
func (c *controller) handleGetMember(ctx echo.Context) error {
|
|
users, err := c.svc.Users.GetUsersByProfile("US")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
authUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
rides, err := c.svc.Rides.GetAll(authUser)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
for i := range users {
|
|
for _, r := range rides {
|
|
if r.User.ID == users[i].ID {
|
|
users[i].Rides = append(users[i].Rides, r)
|
|
}
|
|
}
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, users)
|
|
}
|
|
|
|
func (c *controller) handleGetPortal(ctx echo.Context) error {
|
|
users, err := c.svc.Users.GetUsersByProfile("")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, users)
|
|
}
|
|
|
|
func (c *controller) handleMember(ctx echo.Context) error {
|
|
var user viewmodel.User
|
|
if err := ctx.Bind(&user); err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
authUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
if user.PhoneNumber == nil && user.Email == nil || len(*user.PhoneNumber) == 0 && len(*user.Email) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "phonenumber or email is required", false)
|
|
}
|
|
|
|
if len(user.Pass) == 0 {
|
|
user.Pass = c.generatePassword(8)
|
|
} else {
|
|
pass, err := b64.StdEncoding.DecodeString(user.Pass)
|
|
if err != nil {
|
|
return routeutils.ResponseAPIAuthError(ctx, "Invalid password", false)
|
|
}
|
|
user.Pass = string(pass)
|
|
}
|
|
|
|
if user.BirthDate == nil || user.BirthDate.IsZero() {
|
|
return routeutils.ResponseAPIAuthError(ctx, "birthdate is required", false)
|
|
}
|
|
|
|
if user.Member == nil || len(*user.Member) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "member is required", false)
|
|
}
|
|
|
|
if user.Gender == nil || len(*user.Gender) == 0 || (*user.Gender != "M" && *user.Gender != "F" && *user.Gender != "U") {
|
|
return routeutils.ResponseAPIAuthError(ctx, "gender is required", false)
|
|
}
|
|
|
|
if len(user.Name) == 0 && len(user.First) == 0 && len(user.Last) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "name is required", false)
|
|
}
|
|
|
|
if len(user.First) != 0 && len(user.Last) != 0 {
|
|
user.Name = fmt.Sprintf("%s %s", user.First, user.Last)
|
|
}
|
|
|
|
profile, err := c.svc.Profile.GetByKey("US")
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
user.Profiles = append(user.Profiles, profile)
|
|
|
|
user, err = c.svc.Users.Create(user, authUser)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
eligibility := viewmodel.Eligibility{}
|
|
eligibility.Provider.ProviderNPI = "1699849786"
|
|
eligibility.Provider.ProviderName = "LITHOLINK CORPORATION"
|
|
eligibility.TrackingID = user.ID
|
|
eligibility.Subscriber.SubscriberID = *user.Member
|
|
eligibility.Subscriber.PatientType = "S"
|
|
eligibility.Subscriber.Name.First = user.First
|
|
eligibility.Subscriber.Name.Last = user.Last
|
|
eligibility.Subscriber.DemographicInfo.DateOfBirth = *user.BirthDate
|
|
eligibility.Subscriber.DemographicInfo.Gender = *user.Gender
|
|
eligibility.ServiceInfo.DateOfService = time.Now()
|
|
eligibility.ServiceInfo.ServiceTypeCodes = []string{"30"}
|
|
|
|
resp, err := c.bcbsi.BXE.Get271(eligibility)
|
|
if err != nil {
|
|
fmt.Println("Eligibility Not Found or Error: ", err.Error())
|
|
} else {
|
|
address := viewmodel.Address{}
|
|
header := resp.Division.HealthCareEligibilityResponse.LoopHL0030[0].HL_0460[0].HL_0890[0].NM1_0920[0].N3_0950
|
|
body := resp.Division.HealthCareEligibilityResponse.LoopHL0030[0].HL_0460[0].HL_0890[0].NM1_0920[0].N4_0960
|
|
|
|
address.AddressTypeName = "Home"
|
|
address.AddressType = "home"
|
|
address.Name = fmt.Sprintf("%s, %s", header.N301, body.N401)
|
|
address.Address = fmt.Sprintf("%s, %s", header.N301, body.N401)
|
|
address.CreatedUserUUID = authUser.ID
|
|
address.User = user
|
|
|
|
googleMapsAPI, err := maps.NewClient(maps.WithClientIDAndSignature("gme-bluecrossandblue1", "msqgD-jdqCyR0M_1u5C1HION5iI="))
|
|
if err != nil {
|
|
fmt.Println("Error to instantiate googles api: ", err.Error())
|
|
}
|
|
|
|
r := &maps.GeocodingRequest{
|
|
Address: address.Address + " " + body.N402 + ", " + body.N403,
|
|
}
|
|
|
|
result, err := googleMapsAPI.Geocode(context.Background(), r)
|
|
if err != nil {
|
|
fmt.Println("Error to instantiate googles api: ", err.Error())
|
|
}
|
|
|
|
if len(result) > 0 {
|
|
address.Latitude = result[0].Geometry.Location.Lat
|
|
address.Longitude = result[0].Geometry.Location.Lng
|
|
|
|
_, err := c.svc.Users.SaveAddress(address)
|
|
if err != nil {
|
|
fmt.Println("Error to save address: ", err.Error())
|
|
}
|
|
}
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, user)
|
|
}
|
|
|
|
func (c *controller) handleBulkPortal(ctx echo.Context) error {
|
|
var users []viewmodel.User
|
|
if err := ctx.Bind(&users); err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
authUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
for i, _ := range users {
|
|
if len(users[i].Profiles) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "profile is required", false)
|
|
}
|
|
|
|
if users[i].PhoneNumber == nil || len(*users[i].PhoneNumber) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "phonenumber is required", false)
|
|
}
|
|
|
|
if users[i].Email == nil || len(*users[i].Email) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "email is required", false)
|
|
}
|
|
|
|
if len(users[i].Pass) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "password is required", false)
|
|
}
|
|
|
|
pass, err := b64.StdEncoding.DecodeString(users[i].Pass)
|
|
if err != nil {
|
|
return routeutils.ResponseAPIAuthError(ctx, "Invalid password", false)
|
|
}
|
|
users[i].Pass = string(pass)
|
|
|
|
if len(users[i].Name) == 0 && len(users[i].First) == 0 && len(users[i].Last) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "name is required", false)
|
|
}
|
|
|
|
if len(users[i].First) != 0 && len(users[i].Last) != 0 {
|
|
users[i].Name = fmt.Sprintf("%s %s", users[i].First, users[i].Last)
|
|
}
|
|
}
|
|
|
|
returnUser, err := c.svc.Users.CreateBulk(users, authUser)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, returnUser)
|
|
}
|
|
|
|
func (c *controller) handlePortal(ctx echo.Context) error {
|
|
var user viewmodel.User
|
|
if err := ctx.Bind(&user); err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
authUser, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
if !authorization.CanCreateUser(authUser, user) {
|
|
return routeutils.ResponseAPIAuthorizationError(ctx)
|
|
}
|
|
|
|
if len(user.Profiles) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "profile is required", false)
|
|
}
|
|
|
|
if user.PhoneNumber == nil || len(*user.PhoneNumber) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "phonenumber is required", false)
|
|
}
|
|
|
|
if user.Email == nil || len(*user.Email) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "email is required", false)
|
|
}
|
|
|
|
if len(user.Pass) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "password is required", false)
|
|
}
|
|
|
|
pass, err := b64.StdEncoding.DecodeString(user.Pass)
|
|
if err != nil {
|
|
return routeutils.ResponseAPIAuthError(ctx, "Invalid password", false)
|
|
}
|
|
user.Pass = string(pass)
|
|
|
|
if passwordValidationErrors := validation.ValidatePassword(&user) ; len(passwordValidationErrors) > 0 {
|
|
return routeutils.ResponseAPICustomValidationError(ctx, "Password not strong enough", passwordValidationErrors)
|
|
}
|
|
|
|
if len(user.Name) == 0 && len(user.First) == 0 && len(user.Last) == 0 {
|
|
return routeutils.ResponseAPIAuthError(ctx, "name is required", false)
|
|
}
|
|
|
|
if len(user.First) != 0 && len(user.Last) != 0 {
|
|
user.Name = fmt.Sprintf("%s %s", user.First, user.Last)
|
|
}
|
|
|
|
user, err = c.svc.Users.Create(user, authUser)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, user)
|
|
}
|
|
|
|
func (c *controller) handleContactType(ctx echo.Context) error {
|
|
|
|
cache := cache.Instance(c.cfg)
|
|
cacheKey := ctx.Request().Method + ctx.Request().URL.EscapedPath() + ctx.Request().URL.RawQuery
|
|
resp := []viewmodel.ContactType{}
|
|
|
|
err := cache.GetStruct(cacheKey, &resp)
|
|
|
|
if err != nil {
|
|
if err != domain.ErrCacheMiss {
|
|
ctx.Logger().Errorf(domain.LogProblemGettingFromCache, err)
|
|
}
|
|
resp, err = c.svc.Users.GetContactType()
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
cache.SetStruct(cacheKey, resp)
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, resp)
|
|
}
|
|
|
|
func (c *controller) handleTokenInfo(ctx echo.Context) error {
|
|
user, err := auth.GetUserDetail(ctx, c.cfg)
|
|
if err != nil {
|
|
return routeutils.HandleAPIError(ctx, err)
|
|
}
|
|
|
|
return routeutils.ResponseAPIOK(ctx, user)
|
|
}
|