senaduka/old-svijetlastrana
1
0
Fork 0
Code Issues Pull Requests 5 Actions Packages Projects Releases Wiki Activity

initial commit 2

Browse Source
This commit is contained in:
Senad Uka
2018-04-25 13:16:36 +02:00
parent c1520d169c
commit 99c10b75fb
167 changed files with 25057 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
application/applicationservice/applicationservice.go Normal file
View File

@@ -0,0 +1,43 @@
package applicationservice
import (
"sync"
"bitbucket.org/nemt/nemt-portal-api/application/entitymapping"
"bitbucket.org/nemt/nemt-portal-api/application/notificationservice"
"bitbucket.org/nemt/nemt-portal-api/domain/service"
"bitbucket.org/nemt/nemt-portal-api/infra/config"
)
var (
instance *Service
once sync.Once
)
// Service holds the domain service repositories
type Service struct {
Users *userService
Rides *rideService
Visits *visitService
Provider *providerService
Notification *notificationService
Profile *profileService
Organization *organizationService
}
// New returns a new domain Service instance
func New(svc *service.Service, mapper *entitymapping.Mapper, notification *notificationservice.Service, cfg *config.Config) *Service {
once.Do(func() {
instance = &Service{
Users: newUserService(svc, mapper),
Rides: newRideService(svc, mapper),
Visits: newVisitService(svc, mapper),
Provider: newProviderService(svc, mapper),
Notification: newNotificationService(svc, mapper, notification, cfg),
Profile: newProfileService(svc, mapper),
Organization: newOrganizationService(svc, mapper),
}
})
return instance
}

640
application/applicationservice/notification.go Normal file
View File

@@ -0,0 +1,640 @@
package applicationservice
import (
"fmt"
"net/http"
"reflect"
"strings"
"sync"
"time"
"github.com/pquerna/ffjson/ffjson"
"bitbucket.org/nemt/nemt-portal-api/application/entitymapping"
"bitbucket.org/nemt/nemt-portal-api/application/notificationservice"
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
"bitbucket.org/nemt/nemt-portal-api/domain/service"
"bitbucket.org/nemt/nemt-portal-api/infra/config"
"github.com/gorilla/websocket"
"google.golang.org/api/googleapi/transport"
urlshortener "google.golang.org/api/urlshortener/v1"
gomail "gopkg.in/gomail.v2"
redis "gopkg.in/redis.v5"
)
const (
NotificationTypeEmail = "email"
NOtificationTypeSMS = "sms"
NotificationTypeAPP = "app"
StatusPending = "pending"
StatusAccepted = "accepted"
StatusArrived = "arrived"
StatusPickedUp = "pickedUp"
StatusDroppedOff = "droppedOff"
StatusCanceled = "canceled"
StatusScheduled = "scheduled"
StatusWillCall = "willCall"
hourMinuteAMPM = "03:04 PM"
)
// providerService holds methods to provider application service
type notificationService struct {
svc *service.Service
mapEntity *entitymapping.Mapper
notification *notificationservice.Service
cfg *config.Config
store *Store
pubSub *redis.PubSub
redisConn *redis.Client
}
// newProviderService returns a providerService instance
func newNotificationService(svc *service.Service, mapper *entitymapping.Mapper, notification *notificationservice.Service, cfg *config.Config) *notificationService {
redisClient := redis.NewFailoverClient(&redis.FailoverOptions{
MasterName: "master01",
SentinelAddrs: []string{fmt.Sprintf("%s:%v", cfg.Cache.Server, cfg.Cache.Port)},
Password: cfg.Cache.Pass,
DB: cfg.Cache.DB,
})
pubSub, err := redisClient.Subscribe()
if err != nil {
panic(err)
}
return &notificationService{
svc: svc,
mapEntity: mapper,
notification: notification,
cfg: cfg,
redisConn: redisClient,
store: &Store{
Users: make(map[string]*UserNotification),
redisClient: redisClient,
pubSub: pubSub,
},
pubSub: pubSub,
}
}
func (s *notificationService) secondsToMinutes(inSeconds int64) string {
minutes := inSeconds / 60
seconds := inSeconds % 60
str := fmt.Sprintf("%v minutes", minutes)
if seconds > 0 {
str += fmt.Sprintf(" %v seconds", seconds)
}
return str
}
func (s *notificationService) getReadyURLShortened(ride viewmodel.Ride) (string, error) {
const (
url = "https://portal.bcbsinstitute.com/#/ride/%s/%s/ready"
)
svc, err := urlshortener.New(&http.Client{
Transport: &transport.APIKey{Key: s.cfg.GoogleShortener.APIKey},
})
if err != nil {
return "", err
}
userURL := fmt.Sprintf(url, ride.UUID, ride.User.ID)
shortURL, err := svc.Url.Insert(&urlshortener.Url{
Kind: "urlshortener#url", // Not really needed
LongUrl: userURL,
}).Do()
if err != nil {
return "", err
}
return shortURL.Id, nil
}
func (s *notificationService) getURLShortened(ride viewmodel.Ride) (string, error) {
const (
url = "https://portal.bcbsinstitute.com/#/ride/%s/%s"
)
svc, err := urlshortener.New(&http.Client{
Transport: &transport.APIKey{Key: s.cfg.GoogleShortener.APIKey},
})
if err != nil {
return "", err
}
userURL := fmt.Sprintf(url, ride.UUID, ride.User.ID)
shortURL, err := svc.Url.Insert(&urlshortener.Url{
Kind: "urlshortener#url", // Not really needed
LongUrl: userURL,
}).Do()
if err != nil {
return "", err
}
return shortURL.Id, nil
}
func (s *notificationService) SendNotification(state string, ride viewmodel.Ride, lyftRide viewmodel.RideRequest) error {
notifications := make([]viewmodel.Notification, 0)
url, err := s.getURLShortened(ride)
if err != nil {
fmt.Println("Error to short url: ", err)
}
loc, _ := time.LoadLocation("America/Chicago")
switch state {
case StatusWillCall:
visitTime := ride.VisitDate.In(loc).Format(hourMinuteAMPM)
visitDate := ride.VisitDate.In(loc).Format("01/02/2006")
messageMemberSMS := fmt.Sprintf(MessageSMSWillCallMember, visitTime, ride.Route.Destination.Name, visitDate)
messageMemberSMS += "\n\n" + MessageSMSReplyOrCancel
messageMemberEmail := fmt.Sprintf(MessageEmailWillCallMember, visitTime, ride.Route.Destination.Name, visitDate)
//messageMemberApp := fmt.Sprintf(MessageAppPendingMember, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
urlReady, err := s.getReadyURLShortened(ride)
if err != nil {
fmt.Println(err)
}
messageMemberSMS += "\n" + fmt.Sprintf(MessageSMSIAmReadyOrClick, ride.Route.Destination.Name, urlReady)
messageMemberEmail += "\n" + fmt.Sprintf(MessageEmailIAmReadyOrClick, ride.Route.Destination.Name, urlReady)
messageDispatcherSMS := fmt.Sprintf(MessageSMSWillCallDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate)
messageDispatcherSMS += "\n\n" + MessageSMSReplyOrCancel
messageDispatcherEmail := fmt.Sprintf(MessageEmailWillCallDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate)
//messageDispatcherApp := fmt.Sprintf(MessageAppPendingDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
notifications = append(notifications, s.GetNotification(ride, "sms", MessageSMSWillCallMemberTitle, messageMemberSMS, false, ""))
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSWillCallDispatcherTitle, ride.User.Name), messageDispatcherSMS, true, ""))
notifications = append(notifications, s.GetNotification(ride, "email", MessageEmailWillCallMemberTitle, messageMemberEmail, false, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailWillCallDispatcherTitle, ride.User.Name), messageDispatcherEmail, true, ""))
notifications = append(notifications, s.GetNotification(ride, "app", "Ride Scheduled "+strings.ToLower(ride.TripType.Value), fmt.Sprintf(MessageAppWillCallMemberTitle, ride.Status.Value, ride.Route.Destination.Address), false, "ride"))
notifications = append(notifications, s.GetNotification(ride, "app", "Ride Scheduled "+strings.ToLower(ride.TripType.Value), fmt.Sprintf(MessageAppWillCallDispatcherTitle, ride.Status.Value, ride.Route.Destination.Address), true, "ride"))
case StatusScheduled:
dateFormat := ride.PickupTime.In(loc).Format("01/02/2006 03:04 PM")
visitTime := ride.VisitDate.In(loc).Format(hourMinuteAMPM)
pickupTime := ride.PickupTime.In(loc).Format(hourMinuteAMPM)
visitDate := ride.VisitDate.In(loc).Format("01/02/2006")
if ride.TripType.Key == "from_visit" && lyftRide.ReturnTime != nil {
dateFormat = lyftRide.ReturnTime.In(loc).Format("01/02/2006 03:04 PM")
pickupTime = lyftRide.ReturnTime.In(loc).Format(hourMinuteAMPM)
}
messageMemberSMS := fmt.Sprintf(MessageSMSScheduledMember, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
messageMemberSMS += "\n\n" + MessageSMSReplyOrCancel
messageMemberEmail := fmt.Sprintf(MessageEmailScheduledMember, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
//messageMemberApp := fmt.Sprintf(MessageAppPendingMember, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
messageDispatcherSMS := fmt.Sprintf(MessageSMSScheduledDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
messageDispatcherSMS += "\n\n" + MessageSMSReplyOrCancel
messageDispatcherEmail := fmt.Sprintf(MessageEmailScheduledDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
//messageDispatcherApp := fmt.Sprintf(MessageAppPendingDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSScheduledMemberTitle, dateFormat), messageMemberSMS, false, ""))
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSScheduledDispatcherTitle, ride.User.Name, dateFormat), messageDispatcherSMS, true, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailScheduledMemberTitle, dateFormat), messageMemberEmail, false, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailScheduledDispatcherTitle, ride.User.Name, dateFormat), messageDispatcherEmail, true, ""))
// if ride.TripType.Key == "to_visit" {
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+strings.ToLower(ride.TripType.Value), ride.Status.Value), fmt.Sprintf(MessageAppScheduledMemberTitle, pickupTime, ride.Route.Origin.Name), false, "ride"))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+strings.ToLower(ride.TripType.Value), ride.Status.Value), fmt.Sprintf(MessageAppScheduledDispatcherTitle, pickupTime, ride.Route.Origin.Name), true, "ride"))
// } else if ride.TripType.Key == "from_visit" {
// notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("Ride %s "+strings.ToLower(ride.TripType.Value), StatusScheduled), fmt.Sprintf(MessageAppScheduledMemberTitle, pickupTime, ride.Route.Destination.Name), false, "ride"))
// notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("Ride %s "+strings.ToLower(ride.TripType.Value), StatusScheduled), fmt.Sprintf(MessageAppScheduledDispatcherTitle, pickupTime, ride.Route.Destination.Name), true, "ride"))
// }
case StatusPending:
dateFormat := ride.PickupTime.In(loc).Format("01/02/2006 03:04 PM")
visitTime := ride.VisitDate.In(loc).Format(hourMinuteAMPM)
pickupTime := ride.PickupTime.In(loc).Format(hourMinuteAMPM)
visitDate := ride.VisitDate.In(loc).Format("01/02/2006")
messageMemberSMS := fmt.Sprintf(MessageSMSPendingMember, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
messageMemberSMS += "\n\n" + MessageSMSReplyOrCancel
messageMemberEmail := fmt.Sprintf(MessageEmailPendingMember, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
//messageMemberApp := fmt.Sprintf(MessageAppPendingMember, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
messageDispatcherSMS := fmt.Sprintf(MessageSMSPendingDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
messageDispatcherSMS += "\n\n" + MessageSMSReplyOrCancel
messageDispatcherEmail := fmt.Sprintf(MessageEmailPendingDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
//messageDispatcherApp := fmt.Sprintf(MessageAppPendingDispatcher, ride.User.Name, visitTime, ride.Route.Destination.Name, visitDate, ride.Route.Origin.Address, pickupTime)
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSPendingMemberTitle, dateFormat), messageMemberSMS, false, ""))
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSPendingDispatcherTitle, ride.User.Name, dateFormat), messageDispatcherSMS, true, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailPendingMemberTitle, dateFormat), messageMemberEmail, false, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailPendingDispatcherTitle, ride.User.Name, dateFormat), messageDispatcherEmail, true, ""))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+ride.TripType.Value, ride.Status.Value), fmt.Sprintf(MessageAppPendingMemberTitle, pickupTime, ride.Route.Origin.Name), false, "ride"))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+ride.TripType.Value, ride.Status.Value), fmt.Sprintf(MessageAppPendingDispatcherTitle, pickupTime, ride.Route.Origin.Name), true, "ride"))
case StatusAccepted:
pickupTime := ride.PickupTime.In(loc).Format(hourMinuteAMPM)
messageMemberSMS := fmt.Sprintf(MessageSMSAcceptedMember, lyftRide.Driver.FirstName, ride.Route.Origin.Address, pickupTime, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
messageMemberSMS += "\n\n" + MessageSMSReplyOrCancel
messageMemberEmail := fmt.Sprintf(MessageEmailAcceptedMember, lyftRide.Driver.FirstName, ride.Route.Origin.Address, pickupTime, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
//messageMemberApp := fmt.Sprintf(MessageAppAcceptedMember, lyftRide.Driver.FirstName, ride.Route.Origin.Address, visitTime, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
messageDispatcherSMS := fmt.Sprintf(MessageSMSAcceptedDispatcher, lyftRide.Driver.FirstName, ride.Route.Origin.Address, pickupTime, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
messageDispatcherSMS += "\n\n" + MessageSMSReplyOrCancel
messageDispatcherEmail := fmt.Sprintf(MessageEmailAcceptedDispatcher, lyftRide.Driver.FirstName, ride.Route.Origin.Address, pickupTime, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
//messageDispatcherApp := fmt.Sprintf(MessageAppAcceptedDispatcher, lyftRide.Driver.FirstName, ride.Route.Origin.Address, visitTime, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
notifications = append(notifications, s.GetNotification(ride, "sms", MessageSMSAcceptedMemberTitle, messageMemberSMS, false, ""))
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSAcceptedDispatcherTitle, ride.User.Name), messageDispatcherSMS, true, ""))
notifications = append(notifications, s.GetNotification(ride, "email", MessageEmailAcceptedMemberTitle, messageMemberEmail, false, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailAcceptedDispatcherTitle, ride.User.Name), messageDispatcherEmail, true, ""))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+ride.TripType.Value, ride.Status.Value), fmt.Sprintf(MessageAppAcceptedMemberTitle, s.secondsToMinutes(*lyftRide.Origin.ETASeconds), ride.Route.Origin.Name), false, "ride"))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+ride.TripType.Value, ride.Status.Value), fmt.Sprintf(MessageAppAcceptedDispatcherTitle, s.secondsToMinutes(*lyftRide.Origin.ETASeconds), ride.Route.Origin.Name), true, "ride"))
case StatusArrived:
messageMemberSMS := fmt.Sprintf(MessageSMSArrivedMember, ride.Route.Origin.Address, lyftRide.Driver.FirstName, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
messageMemberSMS += "\n\n" + MessageSMSReplyOrCancel
messageMemberEmail := fmt.Sprintf(MessageEmailArrivedMember, ride.Route.Origin.Address, lyftRide.Driver.FirstName, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
//messageMemberApp := fmt.Sprintf(MessageAppArrivedMember, ride.Route.Origin.Address, lyftRide.Driver.FirstName, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
messageDispatcherSMS := fmt.Sprintf(MessageSMSArrivedDispatcher, ride.Route.Origin.Address, lyftRide.Driver.FirstName, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
messageDispatcherSMS += "\n\n" + MessageSMSReplyOrCancel
messageDispatcherEmail := fmt.Sprintf(MessageEmailArrivedDispatcher, ride.Route.Origin.Address, lyftRide.Driver.FirstName, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
//messageDispatcherApp := fmt.Sprintf(MessageAppArrivedDispatcher, ride.Route.Origin.Address, lyftRide.Driver.FirstName, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate, url)
notifications = append(notifications, s.GetNotification(ride, "sms", MessageSMSArrivedMemberTitle, messageMemberSMS, false, ""))
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSArrivedDispatcherTitle, ride.User.Name), messageDispatcherSMS, true, ""))
notifications = append(notifications, s.GetNotification(ride, "email", MessageEmailArrivedMemberTitle, messageMemberEmail, false, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailArrivedDispatcherTitle, ride.User.Name), messageDispatcherEmail, true, ""))
notifications = append(notifications, s.GetNotification(ride, "app", "Your ride is HERE", fmt.Sprintf(MessageAppArrivedMemberTitle, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate), false, "ride"))
notifications = append(notifications, s.GetNotification(ride, "app", "Waiting for member", fmt.Sprintf(MessageAppArrivedDispatcherTitle, lyftRide.Vehicle.Color, lyftRide.Vehicle.Make, lyftRide.Vehicle.Model, lyftRide.Vehicle.LicensePlate), true, "ride"))
case StatusPickedUp:
dateFormat := time.Now().In(loc).Format("01/02/2006 03:04 PM")
visitTime := ride.VisitDate.In(loc).Format(hourMinuteAMPM)
pickupTime := lyftRide.Pickup.Time.In(loc).Format(hourMinuteAMPM)
messageDispatcherSMS := fmt.Sprintf(MessageSMSPickedUpDispatcher, ride.User.Name, ride.Route.Origin.Address, dateFormat, url, visitTime, s.secondsToMinutes(*lyftRide.Destination.ETASeconds))
messageDispatcherSMS += "\n\n" + MessageSMSReplyOrCancel
messageDispatcherEmail := fmt.Sprintf(MessageEmailPickedUpDispatcher, ride.User.Name, ride.Route.Origin.Address, dateFormat, url, visitTime, s.secondsToMinutes(*lyftRide.Destination.ETASeconds))
//messageDispatcherApp := fmt.Sprintf(MessageAppPickedUpDispatcher, ride.User.Name, ride.Route.Origin.Address, dateFormat, url, visitTime, s.secondsToMinutes(*lyftRide.Destination.ETASeconds))
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSPickedUpDispatcherTitle, ride.User.Name), messageDispatcherSMS, true, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailPickedUpDispatcherTitle, ride.User.Name), messageDispatcherEmail, true, ""))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+ride.TripType.Value, ride.Status.Value), fmt.Sprintf(MessageAppPickedUpDispatcherTitle, pickupTime), true, "ride"))
case StatusDroppedOff:
dateFormat := time.Now().In(loc).Format("01/02/2006 03:04 PM")
dropOffTime := lyftRide.DropOff.Time.In(loc).Format(hourMinuteAMPM)
// messageMemberSMS := MessageSMSDroppedOffMember
// messageMemberEmail := MessageEmailDroppedOffMember
// if ride.Visit.TripType.Key == "roundtrip_call" && ride.TripType.Key == "to_visit" {
// entityRide, err := s.svc.Rides.GetByUUID(ride.UUID)
// if err != nil {
// fmt.Println(err)
// }
// var nextRide entity.Ride
// for _, r := range entityRide.Visit.Rides {
// fmt.Println("Ride Tryp Type: ", r.TripType.Key)
// if r.TripType.Key == "from_visit_call" {
// nextRide = r
// }
// }
// fmt.Println("NextRide Found: ", nextRide.UUID)
// if nextRide.UUID != "" {
// urlReady, err := s.getReadyURLShortened(nextRide)
// if err != nil {
// fmt.Println(err)
// }
// messageMemberSMS += "\n" + fmt.Sprintf(MessageSMSIAmReadyOrClick, nextRide.Route.Destination.Name, urlReady)
// messageMemberEmail += "\n" + fmt.Sprintf(MessageEmailIAmReadyOrClick, nextRide.Route.Destination.Name, urlReady)
// }
// }
// fmt.Println("SMS Message: ", messageMemberSMS)
messageDispatcherSMS := fmt.Sprintf(MessageSMSDroppedOffDispatcher, ride.User.Name, ride.Route.Destination.Name, dateFormat, url, ride.Visit.ExternalID)
messageDispatcherEmail := fmt.Sprintf(MessageEmailDroppedOffDispatcher, ride.User.Name, ride.Route.Destination.Name, dateFormat, url, ride.Visit.ExternalID)
//messageDispatcherApp := fmt.Sprintf(MessageAppDroppedOffDispatcher, ride.User.Name, ride.Route.Destination.Name, dateFormat, url, ride.Visit.ExternalID)
//notifications = append(notifications, s.GetNotification(ride, "sms", MessageSMSDroppedOffMemberTitle, messageMemberSMS, false, ""))
notifications = append(notifications, s.GetNotification(ride, "sms", fmt.Sprintf(MessageSMSDroppedOffDispatcherTitle, ride.User.Name), messageDispatcherSMS, true, ""))
//notifications = append(notifications, s.GetNotification(ride, "email", MessageEmailDroppedOffMemberTitle, messageMemberEmail, false, ""))
notifications = append(notifications, s.GetNotification(ride, "email", fmt.Sprintf(MessageEmailDroppedOffDispatcherTitle, ride.User.Name), messageDispatcherEmail, true, ""))
//notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf(MessageAppDroppedOffMemberTitle, ride.Route.Destination.Name), fmt.Sprintf(MessageAppDroppedOffMemberTitle, ride.Route.Destination.Name), false, "ride"))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+ride.TripType.Value, ride.Status.Value), fmt.Sprintf(MessageAppDroppedOffDispatcherTitle, dropOffTime), true, "ride"))
case StatusCanceled:
visitTime := ride.VisitDate.Format(hourMinuteAMPM)
visitDate := ride.VisitDate.Format("01/02/2006")
var messageMemberSMS string
var messageMemberSMSTitle string
var messageMemberEmail string
var messageMemberEmailTitle string
//var messageMemberApp string
var messageMemberAppTitle string
var messageDispatcherSMS string
var messageDispatcherSMSTitle string
var messageDispatcherEmail string
var messageDispatcherEmailTitle string
//var messageDispatcherApp string
var messageDispatcherAppTitle string
if lyftRide.CanceledBy == "driver" {
messageMemberSMS = fmt.Sprintf(MessageSMSCanceledByDriverMember, visitTime, ride.Visit.ExternalID)
messageMemberSMSTitle = MessageSMSCanceledByDriverMemberTitle
messageMemberEmail = fmt.Sprintf(MessageEmailCanceledByDriverMember, visitTime, ride.Visit.ExternalID)
messageMemberEmailTitle = MessageEmailCanceledByDriverMemberTitle
//messageMemberApp = fmt.Sprintf(MessageAppCanceledByDriverMember, visitTime, ride.Visit.ExternalID)
messageMemberAppTitle = MessageAppCanceledByDriverMemberTitle
messageDispatcherSMS = fmt.Sprintf(MessageSMSCanceledByDriverDispatcher, visitTime, ride.Visit.ExternalID)
messageDispatcherSMSTitle = fmt.Sprintf(MessageSMSCanceledByDriverDispatcherTitle, ride.User.Name)
messageDispatcherEmail = fmt.Sprintf(MessageEmailCanceledByDriverDispatcher, visitTime, ride.Visit.ExternalID)
messageDispatcherEmailTitle = fmt.Sprintf(MessageEmailCanceledByDriverDispatcherTitle, ride.User.Name)
//messageDispatcherApp = fmt.Sprintf(MessageAppCanceledByDriverDispatcher, visitTime, ride.Visit.ExternalID)
messageDispatcherAppTitle = MessageAppCanceledByDriverDispatcherTitle
} else if lyftRide.CanceledBy == "no_drivers_available" {
messageMemberSMS = fmt.Sprintf(MessageSMSCanceledNoDriverMember, visitTime, ride.Route.Destination.Name, visitDate)
messageMemberSMSTitle = MessageSMSCanceledNoDriverMemberTitle
messageMemberEmail = fmt.Sprintf(MessageEmailCanceledNoDriverMember, visitTime, ride.Route.Destination.Name, visitDate)
messageMemberEmailTitle = MessageEmailCanceledNoDriverMemberTitle
//messageMemberApp = fmt.Sprintf(MessageAppCanceledNoDriverMember, visitTime, ride.Route.Destination.Name, visitDate)
messageMemberAppTitle = MessageAppCanceledNoDriverMemberTitle
messageDispatcherSMS = fmt.Sprintf(MessageSMSCanceledNoDriverDispatcher, visitTime, ride.Route.Destination.Name, visitDate, ride.Visit.ExternalID)
messageDispatcherSMSTitle = fmt.Sprintf(MessageSMSCanceledNoDriverDispatcherTitle, ride.User.Name)
messageDispatcherEmail = fmt.Sprintf(MessageEmailCanceledNoDriverDispatcher, visitTime, ride.Route.Destination.Name, visitDate, ride.Visit.ExternalID)
messageDispatcherEmailTitle = fmt.Sprintf(MessageEmailCanceledNoDriverDispatcherTitle, ride.User.Name)
//messageDispatcherApp = fmt.Sprintf(MessageAppCanceledNoDriverDispatcher, visitTime, ride.Route.Destination.Name, visitDate, ride.Visit.ExternalID)
messageDispatcherAppTitle = MessageAppCanceledNoDriverDispatcherTitle
} else {
messageMemberSMS = fmt.Sprintf(MessageSMSCanceledMember, visitTime, ride.Visit.ExternalID)
messageMemberSMSTitle = MessageSMSCanceledMemberTitle
messageMemberEmail = fmt.Sprintf(MessageEmailCanceledMember, visitTime, ride.Visit.ExternalID)
messageMemberEmailTitle = MessageEmailCanceledMemberTitle
//messageMemberApp = fmt.Sprintf(MessageAppCanceledMember, visitTime, ride.Visit.ExternalID)
messageMemberAppTitle = MessageAppCanceledMemberTitle
messageDispatcherSMS = fmt.Sprintf(MessageSMSCanceledDispatcher, visitTime, ride.Visit.ExternalID)
messageDispatcherSMSTitle = fmt.Sprintf(MessageSMSCanceledDispatcherTitle, ride.User.Name)
messageDispatcherEmail = fmt.Sprintf(MessageEmailCanceledDispatcher, visitTime, ride.Visit.ExternalID)
messageDispatcherEmailTitle = fmt.Sprintf(MessageEmailCanceledDispatcherTitle, ride.User.Name)
//messageDispatcherApp = fmt.Sprintf(MessageAppCanceledDispatcher, visitTime, ride.Visit.ExternalID)
messageDispatcherAppTitle = MessageAppCanceledDispatcherTitle //fmt.Sprintf(MessageAppCanceledDispatcherTitle, ride.User.Name)
}
notifications = append(notifications, s.GetNotification(ride, "sms", messageMemberSMSTitle, messageMemberSMS, false, ""))
notifications = append(notifications, s.GetNotification(ride, "sms", messageDispatcherSMSTitle, messageDispatcherSMS, true, ""))
notifications = append(notifications, s.GetNotification(ride, "email", messageMemberEmailTitle, messageMemberEmail, false, ""))
notifications = append(notifications, s.GetNotification(ride, "email", messageDispatcherEmailTitle, messageDispatcherEmail, true, ""))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+ride.TripType.Value, ride.Status.Value), messageMemberAppTitle, false, "ride"))
notifications = append(notifications, s.GetNotification(ride, "app", fmt.Sprintf("%s | "+ride.TripType.Value, ride.Status.Value), messageDispatcherAppTitle, true, "ride"))
}
notifications, err = s.SendNotifications(notifications)
if err != nil {
fmt.Println("Error to notify")
return err
}
return nil
}
func (s *notificationService) GetNotification(ride viewmodel.Ride, notificationType string, subject string, message string, isDispatcher bool, messageType string) viewmodel.Notification {
retVal := viewmodel.Notification{
Type: notificationType,
Message: message,
Subject: subject,
Ride: ride,
User: ride.User,
CreatedUser: ride.CreatedUser,
Read: false,
MessageType: messageType,
}
if isDispatcher {
retVal.User = ride.CreatedUser
retVal.CreatedUser = ride.User
}
switch notificationType {
case NotificationTypeEmail:
if isDispatcher {
retVal.To = *ride.CreatedUser.Email
} else {
retVal.To = *ride.User.Email
}
case NOtificationTypeSMS:
if isDispatcher {
retVal.To = *ride.CreatedUser.PhoneNumber
} else {
retVal.To = *ride.User.PhoneNumber
}
case NotificationTypeAPP:
if isDispatcher {
retVal.To = ride.CreatedUser.ID
} else {
retVal.To = ride.User.ID
}
}
return retVal
}
func (s *notificationService) SendMessage(message viewmodel.Message) error {
bMessage, err := ffjson.Marshal(message)
if err != nil {
return err
}
return s.store.redisClient.Publish(message.DeliveryID, string(bMessage)).Err()
}
func (s *notificationService) GetByUserUUIDAndReadStatus(user viewmodel.User, contactType string, isRead bool) ([]viewmodel.Notification, error) {
n, err := s.svc.Notification.GetByUserUUIDAndReadStatus(user.ID, contactType, isRead)
if err != nil {
return nil, err
}
authUser, err := s.svc.Users.GetByUUID(user.ID, "")
if err != nil {
return nil, err
}
if !isRead {
for i, _ := range n {
r, err := s.svc.Rides.GetByID(n[i].Ride.ID, authUser)
if err != nil {
return nil, err
}
n[i].Ride = r
}
}
return s.mapEntity.Notification.ToNotificationModelSlice(n), nil
}
func (s *notificationService) Subscribe(user viewmodel.User, conn *websocket.Conn) (*UserNotification, error) {
return s.store.Subscribe(user, conn)
}
func (s *notificationService) DeliverMessage() {
for {
v, _ := s.pubSub.Receive()
switch t := v.(type) {
case *redis.Message:
var m viewmodel.Message
ffjson.Unmarshal([]byte(t.Payload), &m)
s.store.FindAndDeliver(m)
case error:
fmt.Println("Error to delivery messages: ", t.Error())
return
default:
if t != nil {
fmt.Println("Unknown Event: ", t)
fmt.Println("Type: ", reflect.TypeOf(t))
}
}
}
}
//FindAndDeliver will send a message to an open channel
func (s *Store) FindAndDeliver(m viewmodel.Message) {
if s.Users[m.DeliveryID] != nil {
if s.Users[m.DeliveryID].ID != "" {
if len(s.Users[m.DeliveryID].Conn) > 0 {
for i, _ := range s.Users[m.DeliveryID].Conn {
if s.Users[m.DeliveryID].Conn[i] != nil {
if err := s.Users[m.DeliveryID].Conn[i].WriteJSON(m); err != nil {
s.Users[m.DeliveryID].Conn[i] = nil
}
}
}
}
return
}
}
}
//Subscribe add the user to a subscription
func (s *Store) Subscribe(user viewmodel.User, conn *websocket.Conn) (*UserNotification, error) {
u := s.Users[user.ID]
if u == nil {
u := &UserNotification{
ID: user.ID,
Conn: []*websocket.Conn{conn},
User: user,
}
s.Users[u.ID] = u
} else {
u.Conn = append(u.Conn, conn)
s.Users[u.ID] = u
}
err := s.pubSub.Subscribe(user.ID)
if err != nil {
return nil, err
}
s.Lock()
defer s.Unlock()
return u, nil
}
func (s *notificationService) ReadStatus(notificationUUID string, isRead bool) error {
return s.svc.Notification.ReadStatus(notificationUUID, isRead)
}
// SendNotifications will send all the notifications to email or SMS
func (s *notificationService) SendNotifications(notifications []viewmodel.Notification) ([]viewmodel.Notification, error) {
if len(notifications) > 0 {
retVal := make([]viewmodel.Notification, 0)
for _, n := range notifications {
if n.To != "" {
notification := s.mapEntity.Notification.ToNotificationEntity(n)
notification, err := s.svc.Notification.Create(notification)
if err != nil {
return nil, err
}
switch n.Type {
case NOtificationTypeSMS:
if n.From == "" {
if err := s.notification.Twilio.SendSMS(s.cfg.Twilio.Sender, n.To, n.Message); err != nil {
fmt.Println("Error to send SMS: ", err.Error())
}
if err := s.notification.Twilio.SendSMS(s.cfg.Twilio.Sender, "+17083038497", n.Message); err != nil {
fmt.Println("Error to send SMS: ", err.Error())
}
} else {
if err := s.notification.Twilio.SendSMS(n.From, n.To, n.Message); err != nil {
fmt.Println("Error to send SMS: ", err.Error())
}
if err := s.notification.Twilio.SendSMS(n.From, "+17083038497", n.Message); err != nil {
fmt.Println("Error to send SMS: ", err.Error())
}
}
case NotificationTypeEmail:
m := gomail.NewMessage()
m.SetHeader("From", s.cfg.Email.Sender)
m.SetHeader("To", n.To)
m.SetHeader("Subject", n.Subject)
m.SetBody("text/plain", n.Message)
d := gomail.NewDialer(s.cfg.Email.Server, s.cfg.Email.Port, s.cfg.Email.User, s.cfg.Email.Pass)
if err := d.DialAndSend(m); err != nil {
fmt.Println("Error to send Email: ", err.Error())
}
m = gomail.NewMessage()
m.SetHeader("From", s.cfg.Email.Sender)
m.SetHeader("To", "nemt@brighterdevelopment.com")
m.SetHeader("Subject", n.Subject)
m.SetBody("text/plain", n.Message)
if err := d.DialAndSend(m); err != nil {
fmt.Println("Error to send Email: ", err.Error())
}
case NotificationTypeAPP:
m := viewmodel.Message{
DeliveryID: n.To,
NotificationID: notification.UUID,
CreateDate: notification.Created,
Read: notification.Read,
Content: viewmodel.MessageContent{
Type: n.MessageType,
Subject: n.Subject,
Content: n.Message,
Payload: n.Ride,
},
}
if err := s.SendMessage(m); err != nil {
fmt.Println("Error to send notification to the users: ", err.Error())
}
}
retVal = append(retVal, s.mapEntity.Notification.ToNotificationModel(notification))
}
}
return retVal, nil
}
return notifications, nil
}
type UserNotification struct {
ID string
Conn []*websocket.Conn
User viewmodel.User
}
type Store struct {
Users map[string]*UserNotification
redisClient *redis.Client
pubSub *redis.PubSub
sync.Mutex
}

131
application/applicationservice/notificationmessage.go Normal file
View File

@@ -0,0 +1,131 @@
package applicationservice
const (
MessageSMSIAmReadyOrClick = "When you ready to go back to %s, click on the following link:\n %s\n or reply this message with I AM READY"
MessageEmailIAmReadyOrClick = "When you are ready to go back to %s, click on the following link:\n %s"
MessageSMSReplyOrCancel = "Reply CANCEL RIDE to cancel or DRIVER to contact driver"
MessageSMSPendingMember = "A ride has been scheduled for your %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageSMSPendingMemberTitle = "Ride Pending for %s"
MessageSMSPendingDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageSMSPendingDispatcherTitle = "Ride Pending for %s on %s"
MessageEmailPendingMember = "A ride has been scheduled for your %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageEmailPendingMemberTitle = "Ride Pending for %s"
MessageEmailPendingDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageEmailPendingDispatcherTitle = "Ride Pending for %s on %s"
MessageAppPendingMember = "A ride has been scheduled for your %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageAppPendingMemberTitle = "Pickup: %s | %s"
MessageAppPendingDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageAppPendingDispatcherTitle = "Pickup: %s | %s"
MessageSMSWillCallMember = "A ride has been scheduled for your %s visit to %s on %s."
MessageSMSWillCallMemberTitle = "Ride Pending for %s"
MessageSMSWillCallDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s."
MessageSMSWillCallDispatcherTitle = "Ride Pending for %s"
MessageEmailWillCallMember = "A ride has been scheduled for your %s visit to %s on %s."
MessageEmailWillCallMemberTitle = "Ride Pending for %s"
MessageEmailWillCallDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s."
MessageEmailWillCallDispatcherTitle = "Ride Pending for %s"
MessageAppWillCallMember = "A ride has been scheduled for your %s visit to %s on %s."
MessageAppWillCallMemberTitle = "Pickup: %s | %s"
MessageAppWillCallDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s."
MessageAppWillCallDispatcherTitle = "Pickup: %s | %s"
MessageSMSScheduledMember = "A ride has been scheduled for your %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageSMSScheduledMemberTitle = "Ride Scheduled for %s"
MessageSMSScheduledDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageSMSScheduledDispatcherTitle = "Ride Scheduled for %s on %s"
MessageEmailScheduledMember = "A ride has been scheduled for your %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageEmailScheduledMemberTitle = "Ride Scheduled for %s"
MessageEmailScheduledDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageEmailScheduledDispatcherTitle = "Ride Scheduled for %s on %s"
MessageAppScheduledMember = "A ride has been scheduled for your %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageAppScheduledMemberTitle = "Pickup: %s | %s"
MessageAppScheduledDispatcher = "A ride has been scheduled for %s's %s visit to %s on %s.\n\nThe driver will arrive at %s by %s."
MessageAppScheduledDispatcherTitle = "Pickup: %s | %s"
MessageSMSAcceptedMember = "Your driver, %s, is on the way to %s and will arrive by %s in a %s %s %s (%s).\n\nView Ride %s"
MessageSMSAcceptedMemberTitle = "Your Ride is on the way !"
MessageSMSAcceptedDispatcher = "A driver, %s, is on the way to %s and will arrive by %s in a %s %s %s (%s).\n\nView Ride %s"
MessageSMSAcceptedDispatcherTitle = "Ride Accepted for %s"
MessageEmailAcceptedMember = "Your driver, %s, is on the way to %s and will arrive by %s in a %s %s %s (%s).\n\nView Ride %s"
MessageEmailAcceptedMemberTitle = "Your Ride is on the way !"
MessageEmailAcceptedDispatcher = "A driver, %s, is on the way to %s and will arrive by %s in a %s %s %s (%s).\n\nView Ride %s"
MessageEmailAcceptedDispatcherTitle = "Ride Accepted for %s"
MessageAppAcceptedMember = "Your driver, %s, is on the way to %s and will arrive by %s in a %s %s %s (%s).\n\nView Ride %s"
MessageAppAcceptedMemberTitle = "ETA: %s at %s"
MessageAppAcceptedDispatcher = "A driver, %s, is on the way to %s and will arrive by %s in a %s %s %s (%s).\n\nView Ride %s"
MessageAppAcceptedDispatcherTitle = "ETA: %s at %s"
MessageSMSArrivedMember = "Your ride has arrived at %s.\n\nPlease look for %s in a %s %s %s (%s).\n\nView Ride %s"
MessageSMSArrivedMemberTitle = "Your Ride is HERE !"
MessageSMSArrivedDispatcher = "Vehicle has arrived at %s.\n\nPlease tell member to look for %s in a %s %s %s (%s).\n\nView Ride %s"
MessageSMSArrivedDispatcherTitle = "Ride Arrived for %s"
MessageEmailArrivedMember = "Your ride has arrived at %s.\n\nPlease look for %s in a %s %s %s (%s).\n\nView Ride %s"
MessageEmailArrivedMemberTitle = "Your Ride is HERE !"
MessageEmailArrivedDispatcher = "Vehicle has arrived at %s.\n\nPlease tell member to look for %s in a %s %s %s (%s).\n\nView Ride %s"
MessageEmailArrivedDispatcherTitle = "Ride Arrived for %s"
MessageAppArrivedMember = "Your ride has arrived at %s.\n\nPlease look for %s in a %s %s %s (%s).\n\nView Ride %s"
MessageAppArrivedMemberTitle = "Look for %s %s %s (%s)"
MessageAppArrivedDispatcher = "Vehicle has arrived at %s.\n\nPlease tell member to look for %s in a %s %s %s (%s).\n\nView Ride %s"
MessageAppArrivedDispatcherTitle = "Look for %s %s %s (%s)"
MessageSMSPickedUpDispatcher = "Member %s was picked up at %s at %s.\n\nView Ride %s\n\nVISIT: %s\n\nESTIMATED ARRIVAL: %s"
MessageSMSPickedUpDispatcherTitle = "%s is in Transit"
MessageEmailPickedUpDispatcher = "Member %s was picked up at %s at %s.\n\nView Ride %s\n\nVISIT: %s\n\nESTIMATED ARRIVAL: %s"
MessageEmailPickedUpDispatcherTitle = "%s is in Transit"
MessageAppPickedUpDispatcher = "Member %s was picked up at %s at %s.\n\nView Ride %s\n\nVISIT: %s\n\nESTIMATED ARRIVAL: %s"
MessageAppPickedUpDispatcherTitle = "Actual Pickup Time: %s"
MessageSMSDroppedOffDispatcher = "Member %s was dropped off at %s at ACTUAL %s.\n\nView Ride %s\n\nVISIT: %s"
MessageSMSDroppedOffDispatcherTitle = "%s has arrived"
MessageEmailDroppedOffDispatcher = "Member %s was dropped off at %s at ACTUAL %s.\n\nView Ride %s\n\nVISIT: %s"
MessageEmailDroppedOffDispatcherTitle = "%s has arrived"
MessageAppDroppedOffDispatcher = "Member %s was dropped off at %s at ACTUAL %s.\n\nView Ride %s\n\nVISIT: %s"
MessageAppDroppedOffDispatcherTitle = "Arrival Time: %s"
MessageSMSDroppedOffMember = "Your ride has been ended, Thank you."
MessageSMSDroppedOffMemberTitle = "Ride Ended"
MessageEmailDroppedOffMember = "Your ride has been ended, Thank you."
MessageEmailDroppedOffMemberTitle = "Ride Ended"
MessageAppDroppedOffMember = "Your ride has been ended, Thank you."
MessageAppDroppedOffMemberTitle = "Arrived to %s"
MessageSMSCanceledByDriverMember = "Your scheduled ride has been CANCELLED by your assigned driver.\n\nWe will schedule a NEW ride for your %s visit and notify you when your NEW driver has been assigned.\n\nVISIT: %s"
MessageSMSCanceledByDriverMemberTitle = "Your Ride has been Canceled"
MessageSMSCanceledByDriverDispatcher = "The member's scheduled ride has been CANCELLED by the assigned driver.\n\nWe will schedule a NEW ride for your %s visit and notify you when your NEW driver has been assigned.\n\nVISIT: %s"
MessageSMSCanceledByDriverDispatcherTitle = "Ride for %s Canceled"
MessageEmailCanceledByDriverMember = "Your scheduled ride has been CANCELLED by your assigned driver.\n\nWe will schedule a NEW ride for your %s visit and notify you when your NEW driver has been assigned.\n\nVISIT: %s"
MessageEmailCanceledByDriverMemberTitle = "Your Ride has been Canceled"
MessageEmailCanceledByDriverDispatcher = "The member's scheduled ride has been CANCELLED by the assigned driver.\n\nWe will schedule a NEW ride for your %s visit and notify you when your NEW driver has been assigned.\n\nVISIT: %s"
MessageEmailCanceledByDriverDispatcherTitle = "Ride for %s Canceled"
MessageAppCanceledByDriverMember = "Your scheduled ride has been CANCELLED by your assigned driver.\n\nWe will schedule a NEW ride for your %s visit and notify you when your NEW driver has been assigned.\n\nVISIT: %s"
MessageAppCanceledByDriverMemberTitle = "Canceled by Driver"
MessageAppCanceledByDriverDispatcher = "The member's scheduled ride has been CANCELLED by the assigned driver.\n\nWe will schedule a NEW ride for your %s visit and notify you when your NEW driver has been assigned.\n\nVISIT: %s"
MessageAppCanceledByDriverDispatcherTitle = "Canceled by Driver"
MessageSMSCanceledNoDriverMember = "Your scheduled ride for your %s visit to %s on %s has been CANCELLED because no drivers are currently available in your area.\n\nYour medical provider will contact you shortly to arrange alternative transportation or reschedule your visit."
MessageSMSCanceledNoDriverMemberTitle = "Your Ride has been Canceled"
MessageSMSCanceledNoDriverDispatcher = "The member's ride to a %s visit to %s on %s has been CANCELLED because no drivers are currently available near the pickup area.\n\nPlease contact member to arrange alternative transportation or reschedule member visit.\n\nVISIT: %s"
MessageSMSCanceledNoDriverDispatcherTitle = "Ride for %s Canceled"
MessageEmailCanceledNoDriverMember = "Your scheduled ride for your %s visit to %s on %s has been CANCELLED because no drivers are currently available in your area.\n\nYour medical provider will contact you shortly to arrange alternative transportation or reschedule your visit."
MessageEmailCanceledNoDriverMemberTitle = "Your Ride has been Canceled"
MessageEmailCanceledNoDriverDispatcher = "The member's ride to a %s visit to %s on %s has been CANCELLED because no drivers are currently available near the pickup area.\n\nPlease contact member to arrange alternative transportation or reschedule member visit.\n\nVISIT: %s"
MessageEmailCanceledNoDriverDispatcherTitle = "Ride for %s Canceled"
MessageAppCanceledNoDriverMember = "Your scheduled ride for your %s visit to %s on %s has been CANCELLED because no drivers are currently available in your area.\n\nYour medical provider will contact you shortly to arrange alternative transportation or reschedule your visit."
MessageAppCanceledNoDriverMemberTitle = "No drivers available"
MessageAppCanceledNoDriverDispatcher = "The member's ride to a %s visit to %s on %s has been CANCELLED because no drivers are currently available near the pickup area.\n\nPlease contact member to arrange alternative transportation or reschedule member visit.\n\nVISIT: %s"
MessageAppCanceledNoDriverDispatcherTitle = "No drivers available"
MessageSMSCanceledMember = "Your scheduled ride has been CANCELLED by our transportation partner, Lyft, because of a technical problem with their system.\n\nWe will attempt to schedule a NEW ride for your %s visit and notify you when your NEW ride has been scheduled.\n\nVISIT: %s"
MessageSMSCanceledMemberTitle = "Your Ride has been Canceled"
MessageSMSCanceledDispatcher = "The member's scheduled ride has been CANCELLED by our transportation partner, Lyft, because of a technical problem with their system.\n\nWe will attempt to schedule a NEW ride for member's %s visit and notify you when a NEW scheduled has been scheduled.\n\nVISIT: %s"
MessageSMSCanceledDispatcherTitle = "Ride for %s Canceled"
MessageEmailCanceledMember = "Your scheduled ride has been CANCELLED by our transportation partner, Lyft, because of a technical problem with their system.\n\nWe will attempt to schedule a NEW ride for your %s visit and notify you when your NEW ride has been scheduled.\n\nVISIT: %s"
MessageEmailCanceledMemberTitle = "Your Ride has been Canceled"
MessageEmailCanceledDispatcher = "The member's scheduled ride has been CANCELLED by our transportation partner, Lyft, because of a technical problem with their system.\n\nWe will attempt to schedule a NEW ride for member's %s visit and notify you when a NEW scheduled has been scheduled.\n\nVISIT: %s"
MessageEmailCanceledDispatcherTitle = "Ride for %s Canceled"
MessageAppCanceledMember = "Your scheduled ride has been CANCELLED by our transportation partner, Lyft, because of a technical problem with their system.\n\nWe will attempt to schedule a NEW ride for your %s visit and notify you when your NEW ride has been scheduled.\n\nVISIT: %s"
MessageAppCanceledMemberTitle = "Canceled by Member"
MessageAppCanceledDispatcher = "The member's scheduled ride has been CANCELLED by our transportation partner, Lyft, because of a technical problem with their system.\n\nWe will attempt to schedule a NEW ride for member's %s visit and notify you when a NEW scheduled has been scheduled.\n\nVISIT: %s"
MessageAppCanceledDispatcherTitle = "Canceled by Member"
)

230
application/applicationservice/organization.go Normal file
View File

@@ -0,0 +1,230 @@
package applicationservice
import (
"fmt"
"strconv"
"strings"
"bitbucket.org/nemt/nemt-portal-api/application/entitymapping"
"bitbucket.org/nemt/nemt-portal-api/application/third/npd/npdmodel"
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
"bitbucket.org/nemt/nemt-portal-api/domain/entity"
"bitbucket.org/nemt/nemt-portal-api/domain/service"
"github.com/pquerna/ffjson/ffjson"
)
// providerService holds methods to provider application service
type organizationService struct {
svc *service.Service
mapEntity *entitymapping.Mapper
}
// newProviderService returns a providerService instance
func newOrganizationService(svc *service.Service, mapper *entitymapping.Mapper) *organizationService {
return &organizationService{
svc: svc,
mapEntity: mapper,
}
}
func (s *organizationService) GetAllTypes() ([]viewmodel.OrganizationType, error) {
result, err := s.svc.Organization.GetAllTypes()
if err != nil {
return nil, err
}
return s.mapEntity.Organization.ToOrganizationTypeModelSlice(result), nil
}
func (s *organizationService) GetByType(organizationTypeKey string) ([]viewmodel.Organization, error) {
result, err := s.svc.Organization.GetByType(organizationTypeKey)
if err != nil {
return nil, err
}
return s.mapEntity.Organization.ToOrganizationModelSlice(result), nil
}
func (s *organizationService) GetByUUID(organizationUUID string) (viewmodel.Organization, error) {
result, err := s.svc.Organization.GetByUUID(organizationUUID)
if err != nil {
return viewmodel.Organization{}, err
}
return s.mapEntity.Organization.ToOrganizationModel(result), nil
}
func (s *organizationService) GetByName(name string, searchType string) ([]viewmodel.Organization, error) {
result, err := s.svc.Organization.GetByName(name, searchType)
if err != nil {
return nil, err
}
return s.mapEntity.Organization.ToOrganizationModelSlice(result), nil
}
func (s *organizationService) SetParentOrganization(organizationUUID string, parentOrganizationUUID string) (viewmodel.Organization, error) {
child, err := s.svc.Organization.GetByUUID(organizationUUID)
if err != nil {
return viewmodel.Organization{}, err
}
parent, err := s.svc.Organization.GetByUUID(parentOrganizationUUID)
if err != nil {
return viewmodel.Organization{}, err
}
if err := s.svc.Organization.SetParentOrganization(child.ID, parent.ID); err != nil {
return viewmodel.Organization{}, err
}
return s.GetByUUID(organizationUUID)
}
func (s *organizationService) InactivateOrganizationAddress(organizationUUID string, address viewmodel.OrganizationAddress) error {
entityAddress := s.mapEntity.Organization.ToOrganizationAddressEntity(address)
entityAddress.Organization = &entity.Organization{
UUID: organizationUUID,
}
user, err := s.svc.Users.GetByUUID(address.UpdatedUser.ID, "")
if err != nil {
return err
}
entityAddress.UpdatedUser = user
if err := s.svc.Organization.InactivateOrganizationAddress(entityAddress); err != nil {
return err
} else {
return nil
}
}
func (s *organizationService) SetOrganizationAddress(organizationUUID string, address viewmodel.OrganizationAddress) (viewmodel.OrganizationAddress, error) {
entityAddress := s.mapEntity.Organization.ToOrganizationAddressEntity(address)
entityAddress.Organization = &entity.Organization{
UUID: organizationUUID,
}
user, err := s.svc.Users.GetByUUID(address.CreatedUser.ID, "")
if err != nil {
return viewmodel.OrganizationAddress{}, err
}
entityAddress.CreatedUser = user
entityAddress.UpdatedUser = user
entityAddress, err = s.svc.Organization.SetOrganizationAddress(entityAddress)
if err != nil {
return viewmodel.OrganizationAddress{}, err
}
return s.mapEntity.Organization.ToOrganizationAddressModel(entityAddress), nil
}
func (s *organizationService) InactivateOrganizationContact(organizationUUID string, contact viewmodel.OrganizationContact) error {
entityContact := s.mapEntity.Organization.ToOrganizationContactEntity(contact)
entityContact.Organization = &entity.Organization{
UUID: organizationUUID,
}
user, err := s.svc.Users.GetByUUID(contact.CreatedUser.ID, "")
if err != nil {
return err
}
entityContact.UpdatedUser = user
if err := s.svc.Organization.InactivateOrganizationContact(entityContact); err != nil {
return err
} else {
return nil
}
}
func (s *organizationService) SetOrganizationContact(organizationUUID string, contact viewmodel.OrganizationContact) (viewmodel.OrganizationContact, error) {
entityContact := s.mapEntity.Organization.ToOrganizationContactEntity(contact)
entityContact.Organization = &entity.Organization{
UUID: organizationUUID,
}
user, err := s.svc.Users.GetByUUID(contact.CreatedUser.ID, "")
if err != nil {
return viewmodel.OrganizationContact{}, err
}
entityContact.CreatedUser = user
entityContact.UpdatedUser = user
entityContact, err = s.svc.Organization.SetOrganizationContact(entityContact)
if err != nil {
return viewmodel.OrganizationContact{}, err
}
return s.mapEntity.Organization.ToOrganizationContactModel(entityContact), nil
}
func (s *organizationService) AddOrganization(organization viewmodel.Organization, user viewmodel.User) (viewmodel.Organization, error) {
enOrg := s.mapEntity.Organization.ToOrganizationEntity(organization)
enUser := s.mapEntity.User.ToUserEntity(user)
author, err := s.svc.Users.GetByUUID(organization.Author.ID, "")
if err != nil {
return viewmodel.Organization{}, nil
}
enOrg.Author = author
enOrg.LastEditor = enOrg.Author
if organization.Reference != nil {
switch organization.Type.Key {
case "provider":
var provider npdmodel.ProviderResponse
bProvider, err := ffjson.Marshal(organization.Reference)
if err != nil {
fmt.Println("Error to marshal provider")
return viewmodel.Organization{}, nil
}
if err := ffjson.Unmarshal(bProvider, &provider); err != nil {
fmt.Println("Error to convert provider")
return viewmodel.Organization{}, nil
}
eProviders, err := s.svc.Provider.Save(s.mapEntity.Provider.ToProviderEntitySlice([]npdmodel.ProviderResponse{provider}), enUser)
if err != nil {
fmt.Println("Error to save provider")
return viewmodel.Organization{}, nil
}
respProvider := eProviders[0]
enOrg.ReferenceID = respProvider.ProviderID
lat, _ := strconv.ParseFloat(provider.Latitude, 64)
long, _ := strconv.ParseFloat(provider.Longitude, 64)
address := entity.OrganizationAddress{
InternalID: provider.MukID,
Name: "Main Address",
Address: fmt.Sprintf("%s %s - %s, %s (%s)", provider.StreetName1, provider.StreetName2, provider.CityName, provider.State, provider.ZipCode),
Latitude: lat,
Longitude: long,
CreatedUser: enOrg.Author,
UpdatedUser: enOrg.LastEditor,
}
enOrg.Addresses = append(enOrg.Addresses, address)
fmt.Println("Phone Number: ", provider.PhoneNumber)
if provider.PhoneNumber != "" {
formattedPhone := "+1" + strings.Replace(provider.PhoneNumber, "-", "", -1)
contact := entity.OrganizationContact{
Type: entity.ContactType{
Key: "phone",
},
Contact: formattedPhone,
Name: "Main Phone",
CreatedUser: enOrg.Author,
UpdatedUser: enOrg.LastEditor,
}
enOrg.Contacts = append(enOrg.Contacts, contact)
}
}
}
enOrg, err = s.svc.Organization.AddOrganization(enOrg)
if err != nil {
return viewmodel.Organization{}, nil
}
return s.GetByUUID(enOrg.UUID)
}

58
application/applicationservice/profile.go Normal file
View File

@@ -0,0 +1,58 @@
package applicationservice
import (
"bitbucket.org/nemt/nemt-portal-api/application/entitymapping"
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
"bitbucket.org/nemt/nemt-portal-api/domain/service"
)
// providerService holds methods to provider application service
type profileService struct {
svc *service.Service
mapEntity *entitymapping.Mapper
}
// newProviderService returns a providerService instance
func newProfileService(svc *service.Service, mapper *entitymapping.Mapper) *profileService {
return &profileService{
svc: svc,
mapEntity: mapper,
}
}
func (s *profileService) GetAll() ([]viewmodel.Profile, error) {
result, err := s.svc.Profile.GetAll()
if err != nil {
return nil, err
}
return s.mapEntity.Profile.ToProfileModelSlice(result), nil
}
func (s *profileService) GetByKey(key string) (viewmodel.Profile, error) {
result, err := s.svc.Profile.GetByKey(key)
if err != nil {
return viewmodel.Profile{}, err
}
return s.mapEntity.Profile.ToProfileModel(result), nil
}
func (s *profileService) GetVisibles(visible bool) ([]viewmodel.Profile, error) {
result, err := s.svc.Profile.GetVisibles(visible)
if err != nil {
return nil, err
}
return s.mapEntity.Profile.ToProfileModelSlice(result), nil
}
func (s *profileService) GetByOrganizationType(organizationTypeKey string) ([]viewmodel.Profile, error) {
orgType, err := s.svc.Organization.GetTypeByKey(organizationTypeKey)
if err != nil {
return nil, err
}
result, err := s.svc.Profile.GetByOrganizationType(orgType.ID)
if err != nil {
return nil, err
}
return s.mapEntity.Profile.ToProfileModelSlice(result), nil
}

50
application/applicationservice/provider.go Normal file
View File

@@ -0,0 +1,50 @@
package applicationservice
import (
"bitbucket.org/nemt/nemt-portal-api/application/entitymapping"
"bitbucket.org/nemt/nemt-portal-api/application/third/npd/npdmodel"
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
"bitbucket.org/nemt/nemt-portal-api/domain/service"
)
// providerService holds methods to provider application service
type providerService struct {
svc *service.Service
mapEntity *entitymapping.Mapper
}
// newProviderService returns a providerService instance
func newProviderService(svc *service.Service, mapper *entitymapping.Mapper) *providerService {
return &providerService{
svc: svc,
mapEntity: mapper,
}
}
func (s *providerService) Save(providers []npdmodel.ProviderResponse, user viewmodel.User) ([]viewmodel.ProviderResp, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
entities := s.mapEntity.Provider.ToProviderEntitySlice(providers)
result, err := s.svc.Provider.Save(entities, eUser)
if err != nil {
return nil, err
}
return s.mapEntity.Provider.ToProviderRespModelSlice(result), nil
}
func (s *providerService) GetAll(user viewmodel.User) ([]viewmodel.ProviderResp, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
providers, err := s.svc.Provider.GetAll(eUser)
if err != nil {
return nil, err
}
return s.mapEntity.Provider.ToProviderRespModelSlice(providers), nil
}
func (s *providerService) Get(query string, lat float64, long float64, distance int64, planCode string, productID string, mukID string, internalID string, sort string, user viewmodel.User) ([]viewmodel.ProviderResp, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
providers, err := s.svc.Provider.Get(query, lat, long, distance, planCode, productID, mukID, internalID, sort, eUser)
if err != nil {
return nil, err
}
return s.mapEntity.Provider.ToProviderRespModelSlice(providers), nil
}

420
application/applicationservice/ride.go Normal file
View File

@@ -0,0 +1,420 @@
package applicationservice
import (
"time"
"bitbucket.org/nemt/nemt-portal-api/application/entitymapping"
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
"bitbucket.org/nemt/nemt-portal-api/domain/entity"
"bitbucket.org/nemt/nemt-portal-api/domain/service"
"bitbucket.org/nemt/nemt-portal-api/infra/errors"
)
// rideService holds methods to user application service
type rideService struct {
svc *service.Service
mapEntity *entitymapping.Mapper
}
// newUserService returns a userService instance
func newRideService(svc *service.Service, mapper *entitymapping.Mapper) *rideService {
return &rideService{
svc: svc,
mapEntity: mapper,
}
}
func (s *rideService) UpdateNewRide(ride viewmodel.Ride, lyftRide viewmodel.RideRequest, user viewmodel.User) (viewmodel.Ride, error) {
webhookModel := viewmodel.WebhookResponse{
Ride: ride,
Event: lyftRide,
}
webhook := s.mapEntity.Ride.ToWebhookEntity(webhookModel)
eUser := s.mapEntity.User.ToUserEntity(user)
oldRide, err := s.svc.Rides.GetByUUID(ride.UUID, eUser)
if err != nil {
return viewmodel.Ride{}, err
}
requestMS := (oldRide.PickupTime.UnixNano() / int64(time.Millisecond))
generateDate := time.Now()
generateMS := (generateDate.UnixNano() / int64(time.Millisecond))
if webhook.Ride.RequestDate == nil {
webhook.Ride.RequestDate = oldRide.PickupTime
}
if webhook.Ride.RequestMiliseconds == nil {
webhook.Ride.RequestMiliseconds = &requestMS
}
if webhook.Ride.GenerateDate == nil {
webhook.Ride.GenerateDate = &generateDate
}
if webhook.Ride.GenerateMiliseconds == nil {
webhook.Ride.GenerateMiliseconds = &generateMS
}
switch webhook.Ride.Status.Key {
case "scheduled":
webhook.Ride.Route.ETA = oldRide.PickupTime.UnixNano() / int64(time.Second)
case "accepted":
if lyftRide.Origin.ETASeconds != nil {
webhook.Ride.Route.ETA = *lyftRide.Origin.ETASeconds
} else {
webhook.Ride.Route.ETA = 0
}
case "arrived", "pickedUp":
if lyftRide.Destination.ETASeconds != nil {
webhook.Ride.Route.ETA = *lyftRide.Destination.ETASeconds
} else {
webhook.Ride.Route.ETA = 0
}
case "droppedOff":
webhook.Ride.Route.ETA = 0
}
webhook.Ride.Route.Duration = int64(time.Now().Sub(*oldRide.PickupTime).Seconds())
webhook.Ride.InternalID = lyftRide.RideID
webhook.Ride.ID = oldRide.ID
webhook.Ride.UUID = oldRide.UUID
webhook.Ride.Driver.ID = oldRide.Driver.ID
webhook.Ride.Passenger.ID = oldRide.Passenger.ID
webhook.Ride.Route.ID = oldRide.Route.ID
webhook.Ride.Type.ID = oldRide.Type.ID
webhook.Ride.User = oldRide.User
webhook.Ride.CreatedUser = oldRide.CreatedUser
webhook.Ride.Vehicle.ID = oldRide.Vehicle.ID
webhook.Ride.Visit = oldRide.Visit
webhook.Ride.VisitDate = oldRide.VisitDate
webhook.Ride.VisitTime = oldRide.VisitTime
//webhook.Ride.PickupTime = oldRide.PickupTime
entityRide, err := s.svc.Rides.Update(webhook)
if err != nil {
return viewmodel.Ride{}, err
}
return s.mapEntity.Ride.ToRideModel(entityRide), nil
}
func (s *rideService) Update(ride viewmodel.WebhookResponse) (viewmodel.Ride, error) {
webhook := s.mapEntity.Ride.ToWebhookEntity(ride)
oldRide, err := s.svc.Rides.GetByInternalID(ride.Event.RideID)
if err != nil {
oldRide, err = s.svc.Rides.GetByInternalPassengerID(*ride.Event.Passenger.UserID)
if err != nil {
return viewmodel.Ride{}, err
}
}
requestMS := (oldRide.PickupTime.UnixNano() / int64(time.Millisecond))
generateDate := time.Now()
generateMS := (generateDate.UnixNano() / int64(time.Millisecond))
if webhook.Ride.RequestDate == nil {
webhook.Ride.RequestDate = oldRide.PickupTime
}
if webhook.Ride.RequestMiliseconds == nil {
webhook.Ride.RequestMiliseconds = &requestMS
}
if webhook.Ride.GenerateDate == nil {
webhook.Ride.GenerateDate = &generateDate
}
if webhook.Ride.GenerateMiliseconds == nil {
webhook.Ride.GenerateMiliseconds = &generateMS
}
switch webhook.Ride.Status.Key {
case "scheduled":
webhook.Ride.Route.ETA = oldRide.PickupTime.UnixNano() / int64(time.Second)
case "accepted":
if ride.Event.Origin.ETASeconds != nil {
webhook.Ride.Route.ETA = *ride.Event.Origin.ETASeconds
} else {
webhook.Ride.Route.ETA = 0
}
case "arrived", "pickedUp":
if ride.Event.Destination.ETASeconds != nil {
webhook.Ride.Route.ETA = *ride.Event.Destination.ETASeconds
} else {
webhook.Ride.Route.ETA = 0
}
case "droppedOff":
webhook.Ride.Route.ETA = 0
}
webhook.Ride.Route.Duration = int64(time.Now().Sub(*oldRide.PickupTime).Seconds())
webhook.Ride.InternalID = ride.Event.RideID
webhook.Ride.ID = oldRide.ID
webhook.Ride.UUID = oldRide.UUID
webhook.Ride.Driver.ID = oldRide.Driver.ID
webhook.Ride.Passenger.ID = oldRide.Passenger.ID
webhook.Ride.Route.ID = oldRide.Route.ID
webhook.Ride.Type.ID = oldRide.Type.ID
webhook.Ride.User = oldRide.User
webhook.Ride.CreatedUser = oldRide.CreatedUser
webhook.Ride.Vehicle.ID = oldRide.Vehicle.ID
webhook.Ride.Visit = oldRide.Visit
webhook.Ride.VisitDate = oldRide.VisitDate
webhook.Ride.VisitTime = oldRide.VisitTime
webhook.Ride.PickupTime = oldRide.PickupTime
entityRide, err := s.svc.Rides.Update(webhook)
if err != nil {
return viewmodel.Ride{}, err
}
return s.mapEntity.Ride.ToRideModel(entityRide), nil
}
// Save a new ride
func (s *rideService) Save(ride viewmodel.RideRequest) (viewmodel.Ride, error) {
rideEntity := s.mapEntity.Ride.ToRideEntity(ride)
if ride.Visit.UUID == "" {
visit := entity.Visit{}
visit.User = rideEntity.User
visit.Pickup = rideEntity.Route.Origin
visit.Notes = &rideEntity.Note
visit.PickupDatetime = *rideEntity.PickupTime
visit.VisitDatetime = *rideEntity.VisitTime
visit.CreatedUser.UUID = ride.CreateUserUUID
visit.ExternalID = ride.VisitExternalID
visit.TripType = rideEntity.Visit.TripType
visit.ReturnDate = ride.ReturnTime
address, _ := s.svc.Users.GetAddressByUUID(rideEntity.Route.Destination.ID)
createdUser, err := s.svc.Users.GetByUUID(ride.CreateUserUUID, "")
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
if address.ID > 0 {
visit.DestinationAddressID = address.ID
provider, err := s.svc.Provider.GetByMukID(address.InternalID, createdUser)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
visit.Provider = provider
} else {
provider, err := s.svc.Provider.GetByMukID(rideEntity.Route.Destination.ID, createdUser)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
visit.Provider = provider
}
visit, err = s.svc.Visits.Create(visit)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
rideEntity.Visit = visit
} else {
user, err := s.svc.Users.GetByUUID(ride.CreateUserUUID, "")
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
visit, err := s.svc.Visits.GetByUUID(ride.Visit.UUID, user)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
rideEntity.Visit = visit
}
retVal, err := s.svc.Rides.Save(rideEntity)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
return s.mapEntity.Ride.ToRideModel(retVal), err
}
// GetAll returns a list of users
func (s *rideService) GetAll(user viewmodel.User) ([]viewmodel.Ride, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
retVal, err := s.svc.Rides.GetAll(eUser)
if err != nil {
return nil, errors.Wrap(err)
}
return s.mapEntity.Ride.ToRideModelSlice(retVal), err
}
// GetByUUID returns a specific Ride
func (s *rideService) GetByUUID(uuid string, user viewmodel.User) (viewmodel.Ride, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
retVal, err := s.svc.Rides.GetByUUID(uuid, eUser)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
if retVal.Visit.ID > 0 {
retVal.Visit, err = s.svc.Visits.GetByID(retVal.Visit.ID, eUser)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
}
return s.mapEntity.Ride.ToRideModel(retVal), err
}
func (s *rideService) GetByVisitUUID(visitUUID string, user viewmodel.User) ([]viewmodel.Ride, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
retVal, err := s.svc.Rides.GetByVisitUUID(visitUUID, eUser)
if err != nil {
return nil, errors.Wrap(err)
}
visit, err := s.svc.Visits.GetByUUID(visitUUID, eUser)
if err != nil {
return nil, errors.Wrap(err)
}
for i, _ := range retVal {
retVal[i].Visit = visit
}
return s.mapEntity.Ride.ToRideModelSlice(retVal), err
}
func (s *rideService) GetByVisitUUIDAndTripType(visitUUID string, tripTypeKey string, user viewmodel.User) (viewmodel.Ride, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
retVal, err := s.svc.Rides.GetByVisitUUIDAndTripType(visitUUID, tripTypeKey, eUser)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
visit, err := s.svc.Visits.GetByUUID(visitUUID, eUser)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
retVal.Visit = visit
return s.mapEntity.Ride.ToRideModel(retVal), err
}
// GetByUUID returns a specific Ride
func (s *rideService) GetByUUIDAndUserUUID(uuid string, user_uuid string) (viewmodel.Ride, error) {
retVal, err := s.svc.Rides.GetByUUIDAndUserUUID(uuid, user_uuid)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
if retVal.Visit.ID > 0 {
user, err := s.svc.Users.GetByID(retVal.CreatedUser.ID)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
retVal.Visit, err = s.svc.Visits.GetByID(retVal.Visit.ID, user)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
}
return s.mapEntity.Ride.ToRideModel(retVal), err
}
// GetByInternalID returns a specific Ride
func (s *rideService) GetByInternalID(internalID string) (viewmodel.Ride, error) {
retVal, err := s.svc.Rides.GetByInternalID(internalID)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
if retVal.Visit.ID > 0 {
user, err := s.svc.Users.GetByID(retVal.CreatedUser.ID)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
retVal.Visit, err = s.svc.Visits.GetByID(retVal.Visit.ID, user)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
}
return s.mapEntity.Ride.ToRideModel(retVal), err
}
// GetByUserID returns a list of rides for an user
func (s *rideService) GetByUserID(userID int64, user viewmodel.User) ([]viewmodel.Ride, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
retVal, err := s.svc.Rides.GetByUserID(userID, eUser)
if err != nil {
return []viewmodel.Ride{}, errors.Wrap(err)
}
return s.mapEntity.Ride.ToRideModelSlice(retVal), err
}
// UpdateStatus change the status of the ride
func (s *rideService) UpdateStatus(rideUUID string, status string) error {
err := s.svc.Rides.UpdateStatus(rideUUID, status)
if err != nil {
return errors.Wrap(err)
}
return nil
}
// GetByUserID returns a list of rides for an user
func (s *rideService) GetByUserUUID(userUUID string, user viewmodel.User) ([]viewmodel.Ride, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
retVal, err := s.svc.Rides.GetByUserUUID(userUUID, eUser)
if err != nil {
return []viewmodel.Ride{}, errors.Wrap(err)
}
return s.mapEntity.Ride.ToRideModelSlice(retVal), err
}
func (s *rideService) GetLastRideByPhoneNumber(phoneNumber string, notificationType string, status string) (viewmodel.Ride, error) {
// if notificationType == ""{
// notificationType = "message"
// }
if status == "" {
status = "sms"
}
notification, err := s.svc.Notification.GetLastNotificationFromPhoneNumber(notificationType, phoneNumber, status)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
user, err := s.svc.Users.GetByID(notification.CreatedUser.ID)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
retVal, err := s.svc.Rides.GetByID(notification.Ride.ID, user)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
if retVal.Visit.ID > 0 {
retVal.Visit, err = s.svc.Visits.GetByID(retVal.Visit.ID, user)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
}
return s.mapEntity.Ride.ToRideModel(retVal), err
}
func (s *rideService) GetLastRideByDriversNumber(phoneNumber string) (viewmodel.Ride, error) {
retVal, err := s.svc.Rides.GetLastRideByDriversNumber(phoneNumber)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
if retVal.Visit.ID > 0 {
user, err := s.svc.Users.GetByID(retVal.CreatedUser.ID)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
retVal.Visit, err = s.svc.Visits.GetByID(retVal.Visit.ID, user)
if err != nil {
return viewmodel.Ride{}, errors.Wrap(err)
}
}
return s.mapEntity.Ride.ToRideModel(retVal), err
}

149
application/applicationservice/user.go Normal file
View File

@@ -0,0 +1,149 @@
package applicationservice
import (
"bitbucket.org/nemt/nemt-portal-api/application/entitymapping"
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
"bitbucket.org/nemt/nemt-portal-api/domain/entity"
"bitbucket.org/nemt/nemt-portal-api/domain/service"
"bitbucket.org/nemt/nemt-portal-api/infra/errors"
)
// userService holds methods to user application service
type userService struct {
svc *service.Service
mapEntity *entitymapping.Mapper
}
// newUserService returns a userService instance
func newUserService(svc *service.Service, mapper *entitymapping.Mapper) *userService {
return &userService{
svc: svc,
mapEntity: mapper,
}
}
// GetAll returns a list of users
func (s *userService) GetAll(quantity int64, page int64) (retVal []viewmodel.User, err error) {
users, err := s.svc.Users.GetAll()
if err != nil {
return retVal, errors.Wrap(err)
}
return s.mapEntity.User.ToUserModelSlice(users), nil
}
// GetByID returns a specific user by its ID
func (s *userService) GetByID(id int64) (retVal viewmodel.User, err error) {
user, err := s.svc.Users.GetByID(id)
if err != nil {
return retVal, errors.Wrap(err)
}
return s.mapEntity.User.ToUserModel(user), nil
}
// GetByID returns a specific user by its ID
func (s *userService) GetByUUID(uuid string, profile string) (retVal viewmodel.User, err error) {
user, err := s.svc.Users.GetByUUID(uuid, profile)
if err != nil {
return retVal, errors.Wrap(err)
}
return s.mapEntity.User.ToUserModel(user), nil
}
// Login returns a specific user by email and pass
func (s *userService) FullLogin(loginType string, key string, pass string, profile string) (retVal viewmodel.User, err error) {
user, err := s.svc.Users.FullLogin(loginType, key, pass, profile)
if err != nil {
return retVal, errors.Wrap(err)
}
return s.mapEntity.User.ToUserModel(user), nil
}
// Login returns a specific user by email and pass
func (s *userService) Login(email string, pass string) (retVal viewmodel.User, err error) {
user, err := s.svc.Users.Login(email, pass)
if err != nil {
return retVal, errors.Wrap(err)
}
return s.mapEntity.User.ToUserModel(user), nil
}
func (s *userService) Create(user viewmodel.User) (retVal viewmodel.User, err error) {
entity := s.mapEntity.User.ToUserEntity(user)
for i, _ := range entity.Organizations {
entity.Organizations[i], err = s.svc.Organization.GetByUUID(entity.Organizations[i].UUID)
if err != nil {
return retVal, err
}
}
entity, err = s.svc.Users.Create(entity)
if err != nil {
return retVal, errors.Wrap(err)
}
return s.mapEntity.User.ToUserModel(entity), nil
}
func (s *userService) CreateBulk(users []viewmodel.User) (retVal []viewmodel.User, err error) {
entities := s.mapEntity.User.ToUserEntitySlice(users)
organizations := make([]entity.Organization, 0)
for i, _ := range entities {
if i == 0 {
for o, _ := range entities[i].Organizations {
org, err := s.svc.Organization.GetByUUID(entities[i].Organizations[o].UUID)
if err != nil {
return nil, err
}
organizations = append(organizations, org)
}
}
entities[i].Organizations = organizations
}
entities, err = s.svc.Users.CreateBulk(entities)
if err != nil {
return nil, errors.Wrap(err)
}
return s.mapEntity.User.ToUserModelSlice(entities), nil
}
// GetUsersByProfile returns a list of users by profile
func (s *userService) GetUsersByProfile(profile string) (retVal []viewmodel.User, err error) {
users, err := s.svc.Users.GetUsersByProfile(profile)
if err != nil {
return retVal, errors.Wrap(err)
}
list := s.mapEntity.User.ToUserModelSlice(users)
return list, nil
}
func (s *userService) RemoveAddress(addressUUID string) error {
return s.svc.Users.RemoveAddress(addressUUID)
}
func (s *userService) SaveAddress(address viewmodel.Address) (retVal viewmodel.Address, err error) {
entity := s.mapEntity.Address.ToAddressEntity(address)
entity, err = s.svc.Users.SaveAddress(entity)
if err != nil {
return retVal, errors.Wrap(err)
}
return s.mapEntity.Address.ToAddressModel(entity), err
}
func (s *userService) GetContactType() (retVal []viewmodel.ContactType, err error) {
entity, err := s.svc.Users.GetContactType()
if err != nil {
return retVal, errors.Wrap(err)
}
return s.mapEntity.User.ToContactTypeModelSlice(entity), nil
}

38
application/applicationservice/util.go Normal file
View File

@@ -0,0 +1,38 @@
package applicationservice
import (
"math"
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
)
// getTakeSkipPaging return the take and skip from page number and item quantity
func getTakeSkipPaging(quantity int64, page int64) (take int64, skip int64) {
if page < 1 {
page = 1
}
if quantity < 1 {
quantity = 10
} else if quantity > 1000 {
quantity = 1000
}
take = quantity // itens per page
skip = (page - 1) * quantity
return take, skip
}
// buildPaginatedResult returns a paginatedResult instance
func buildPaginatedResult(list interface{}, skip int64, take int64, totalRecords int64) viewmodel.PaginatedResult {
return viewmodel.PaginatedResult{
List: list,
Pagination: viewmodel.ReturnPagination{
CurrentPage: (skip / take) + 1,
RecordsPerPage: take,
TotalRecords: totalRecords,
TotalPages: int64(math.Ceil(float64(totalRecords) / float64(take))),
},
}
}

55
application/applicationservice/visit.go Normal file
View File

@@ -0,0 +1,55 @@
package applicationservice
import (
"bitbucket.org/nemt/nemt-portal-api/application/entitymapping"
"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
"bitbucket.org/nemt/nemt-portal-api/domain/service"
"bitbucket.org/nemt/nemt-portal-api/infra/errors"
)
// rideService holds methods to user application service
type visitService struct {
svc *service.Service
mapEntity *entitymapping.Mapper
}
// newUserService returns a userService instance
func newVisitService(svc *service.Service, mapper *entitymapping.Mapper) *visitService {
return &visitService{
svc: svc,
mapEntity: mapper,
}
}
// Save a new ride
func (s *visitService) Create(visit viewmodel.Visit) (viewmodel.Visit, error) {
entity := s.mapEntity.Visit.ToVisitEntity(visit)
retVal, err := s.svc.Visits.Create(entity)
if err != nil {
return viewmodel.Visit{}, errors.Wrap(err)
}
return s.mapEntity.Visit.ToVisitModel(retVal), err
}
// Save a new ride
func (s *visitService) GetAll(user viewmodel.User) ([]viewmodel.Visit, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
retVal, err := s.svc.Visits.GetAll(eUser)
if err != nil {
return nil, errors.Wrap(err)
}
return s.mapEntity.Visit.ToVisitModelSlice(retVal), err
}
// Save a new ride
func (s *visitService) GetByUUID(visitUUID string, user viewmodel.User) (viewmodel.Visit, error) {
eUser := s.mapEntity.User.ToUserEntity(user)
retVal, err := s.svc.Visits.GetByUUID(visitUUID, eUser)
if err != nil {
return viewmodel.Visit{}, errors.Wrap(err)
}
return s.mapEntity.Visit.ToVisitModel(retVal), err
}