1337 lines
31 KiB
Go
1337 lines
31 KiB
Go
package controllers
|
|
|
|
import (
|
|
"math/rand"
|
|
"nearle/db"
|
|
"nearle/domain"
|
|
"nearle/models"
|
|
"nearle/utils"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
func Login(c *fiber.Ctx) error {
|
|
|
|
var user models.User
|
|
var info models.UserInfo
|
|
var uid int
|
|
var q1 string
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return err
|
|
}
|
|
|
|
if user.Authname != "" {
|
|
|
|
q1 = `SELECT a.userid from app_users a WHERE a.authname= '` + user.Authname + `' and a.configid=` + strconv.Itoa(user.Configid)
|
|
|
|
} else {
|
|
|
|
q1 = `SELECT a.userid from app_users a WHERE a.contactno= '` + user.Contactno + `' and a.configid=` + strconv.Itoa(user.Configid)
|
|
|
|
}
|
|
|
|
db.DB.Raw(q1).Find(&uid)
|
|
|
|
if uid != 0 {
|
|
|
|
user.Userid = uid
|
|
// cno := domain.GetTenantId(uid, "")
|
|
// domain.UpdatUser(user)
|
|
info = domain.Getuserbyid(uid)
|
|
|
|
} else {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "User not found",
|
|
})
|
|
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func TenantLogin(c *fiber.Ctx) error {
|
|
|
|
var user models.User
|
|
var info models.TenantUserInfo
|
|
var uid int
|
|
var q1 string
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return err
|
|
}
|
|
|
|
if user.Authname != "" {
|
|
|
|
q1 = `SELECT a.userid from app_users a WHERE a.authname= '` + user.Authname + `' and a.configid=` + strconv.Itoa(user.Configid)
|
|
|
|
} else {
|
|
|
|
q1 = `SELECT a.userid from app_users a WHERE a.contactno= '` + user.Contactno + `' and a.configid=` + strconv.Itoa(user.Configid)
|
|
|
|
}
|
|
|
|
db.DB.Raw(q1).Find(&uid)
|
|
|
|
if uid != 0 {
|
|
|
|
user.Userid = uid
|
|
// user.Tenantid = domain.GetTenantId(user.Contactno)
|
|
// domain.UpdatUser(user)
|
|
info = domain.GetTenantUserbyId(uid)
|
|
|
|
} else {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "User not found",
|
|
})
|
|
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
// func Partnerlogin(c *fiber.Ctx) error {
|
|
// var user models.User
|
|
// var info models.UserInfo
|
|
// var uid int
|
|
// var q1 string
|
|
|
|
// if err := c.BodyParser(&user); err != nil {
|
|
// return err
|
|
// }
|
|
|
|
// if user.Authname != "" {
|
|
// q1 = `SELECT a.userid FROM app_users a
|
|
// WHERE a.authname = '` + user.Authname + `'
|
|
// AND a.configid = ` + strconv.Itoa(user.Configid)
|
|
// } else {
|
|
// q1 = `SELECT a.userid FROM app_users a
|
|
// WHERE a.contactno = '` + user.Contactno + `'
|
|
// AND a.configid = ` + strconv.Itoa(user.Configid)
|
|
// }
|
|
|
|
// db.DB.Raw(q1).Scan(&uid)
|
|
|
|
// if uid != 0 {
|
|
// user.Userid = uid
|
|
// user.Pin = rand.Intn(6000) + 1000
|
|
|
|
// if user.Userfcmtoken != "" {
|
|
// log.Println("Updating FCM Token for UID:", uid, "Token:", user.Userfcmtoken)
|
|
// result := db.DB.Exec(`UPDATE app_users SET userfcmtoken = ? WHERE userid = ?`, user.Userfcmtoken, uid)
|
|
// if result.Error != nil {
|
|
// log.Println("Error updating FCM token:", result.Error)
|
|
// } else {
|
|
// log.Println("FCM token updated successfully")
|
|
// }
|
|
// }
|
|
|
|
// domain.UpdatUser(user)
|
|
|
|
// info = domain.GetPartnerUserbyid(uid)
|
|
|
|
// if user.Configid == 5 && user.Authname != "" {
|
|
// config := domain.GetAppconfig(user.Configid)
|
|
|
|
// err := domain.SendLoginNotification(info.Userfcmtoken, config.Fcmkey, info.Pin)
|
|
// if err != nil {
|
|
// log.Println("FCM send error:", err)
|
|
|
|
// }
|
|
// }
|
|
// } else {
|
|
// return c.JSON(fiber.Map{
|
|
// "status": false,
|
|
// "code": http.StatusConflict,
|
|
// "message": "User not found",
|
|
// })
|
|
// }
|
|
|
|
// return c.JSON(fiber.Map{
|
|
// "code": http.StatusOK,
|
|
// "message": "Success",
|
|
// "status": true,
|
|
// "details": info,
|
|
// })
|
|
// }
|
|
|
|
func Partnerlogin(c *fiber.Ctx) error {
|
|
var user models.User
|
|
var info models.UserInfo
|
|
var uid int
|
|
var q1 string
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return err
|
|
}
|
|
|
|
if user.Authname != "" {
|
|
q1 = `SELECT a.userid FROM app_users a
|
|
WHERE a.authname = '` + user.Authname + `'
|
|
AND a.configid = ` + strconv.Itoa(user.Configid)
|
|
} else {
|
|
q1 = `SELECT a.userid FROM app_users a
|
|
WHERE a.contactno = '` + user.Contactno + `'
|
|
AND a.configid = ` + strconv.Itoa(user.Configid)
|
|
}
|
|
|
|
db.DB.Raw(q1).Scan(&uid)
|
|
|
|
if uid != 0 {
|
|
user.Userid = uid
|
|
user.Pin = rand.Intn(6000) + 1000
|
|
|
|
if user.Userfcmtoken != "" {
|
|
utils.Logger.Infow("Updating FCM Token", "uid", uid, "token", user.Userfcmtoken)
|
|
result := db.DB.Exec(`UPDATE app_users SET userfcmtoken = ? WHERE userid = ?`, user.Userfcmtoken, uid)
|
|
if result.Error != nil {
|
|
utils.Logger.Errorw("Error updating FCM token", "error", result.Error)
|
|
} else {
|
|
utils.Logger.Infow("FCM token updated successfully")
|
|
}
|
|
}
|
|
|
|
domain.UpdatUser(user)
|
|
|
|
info = domain.GetPartnerUserbyid(uid)
|
|
|
|
if user.Configid == 5 && user.Authname != "" {
|
|
config := domain.GetAppconfig(user.Configid)
|
|
|
|
err := domain.SendLoginNotification(info.Userfcmtoken, config.Fcmkey, info.Pin)
|
|
if err != nil {
|
|
utils.Logger.Errorw("FCM send error", "error", err)
|
|
|
|
}
|
|
}
|
|
} else {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "User not found",
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func Riderlogin(c *fiber.Ctx) error {
|
|
|
|
var user models.User
|
|
var info models.RiderInfo
|
|
var uid int
|
|
var q1 string
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return err
|
|
}
|
|
|
|
if user.Authname != "" {
|
|
|
|
q1 = `SELECT a.userid from app_users a WHERE a.authname= '` + user.Authname + `' and a.configid=` + strconv.Itoa(user.Configid)
|
|
|
|
} else {
|
|
|
|
q1 = `SELECT a.userid from app_users a WHERE a.contactno= '` + user.Contactno + `' and a.configid=` + strconv.Itoa(user.Configid)
|
|
|
|
}
|
|
|
|
db.DB.Raw(q1).Find(&uid)
|
|
|
|
if uid != 0 {
|
|
|
|
user.Userid = uid
|
|
user.Pin = rand.Intn(6000) + 1000
|
|
domain.UpdatUser(user)
|
|
info = domain.GetRiderUserbyid(uid)
|
|
|
|
if user.Configid == 5 && user.Authname != "" {
|
|
|
|
config := domain.GetAppconfig(user.Configid)
|
|
domain.SendLoginNotification(info.Userfcmtoken, config.Fcmkey, info.Pin)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "User not found",
|
|
})
|
|
|
|
}
|
|
|
|
utils.Logger.Debugw("Rider Login Query", "query", q1)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": info,
|
|
})
|
|
|
|
}
|
|
|
|
func Riderloginv2(c *fiber.Ctx) error {
|
|
var user models.User
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 400,
|
|
"message": "Invalid request body",
|
|
})
|
|
}
|
|
|
|
var uid int
|
|
|
|
if user.Contactno != "" {
|
|
uid = domain.GetUserIDByContact(user.Contactno, user.Configid)
|
|
}
|
|
|
|
if uid == 0 && user.Authname != "" {
|
|
uid = domain.GetUserIDByAuth(user.Authname, user.Configid)
|
|
}
|
|
|
|
if uid == 0 {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 404,
|
|
"message": "User not found",
|
|
})
|
|
}
|
|
|
|
status := domain.GetUserStatus(uid)
|
|
if strings.ToLower(status) != "active" {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 403,
|
|
"message": "User is inactive. Contact administrator.",
|
|
})
|
|
}
|
|
|
|
storedPin := domain.GetStoredPin(uid)
|
|
authmode := domain.GetAuthMode(uid)
|
|
|
|
if authmode == 1 {
|
|
// Update FCM Token
|
|
if user.Userfcmtoken != "" {
|
|
_ = domain.UpdateUserFcmToken(uid, user.Userfcmtoken)
|
|
}
|
|
|
|
info := domain.GetRiderUserbyid(uid)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 200,
|
|
"message": "Login successful",
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
if storedPin == 0 {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 400,
|
|
"message": "PIN not set for this user. Please set a PIN before logging in.",
|
|
"userid": uid,
|
|
"authmode": authmode,
|
|
})
|
|
}
|
|
|
|
if user.Pin == 0 {
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 200,
|
|
"message": "User verified. Please enter your PIN.",
|
|
"userid": uid,
|
|
"authmode": authmode,
|
|
})
|
|
}
|
|
|
|
if storedPin != user.Pin {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 401,
|
|
"message": "Invalid PIN",
|
|
"authmode": authmode,
|
|
})
|
|
}
|
|
|
|
if user.Userfcmtoken != "" {
|
|
if err := domain.UpdateUserFcmToken(uid, user.Userfcmtoken); err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 500,
|
|
"message": "Failed to update FCM token",
|
|
})
|
|
}
|
|
}
|
|
|
|
info := domain.GetRiderUserbyid(uid)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 200,
|
|
"message": "Login successful",
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func AdminLogin(c *fiber.Ctx) error {
|
|
var user models.User
|
|
var uid int
|
|
var q1 string
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return err
|
|
}
|
|
|
|
if user.Authname != "" {
|
|
q1 = `SELECT a.userid FROM app_users a WHERE a.authname = '` + user.Authname + `' AND a.password = '` + user.Password + `' AND a.configid = ` + strconv.Itoa(user.Configid)
|
|
}
|
|
|
|
db.DB.Raw(q1).Scan(&uid)
|
|
|
|
if uid == 0 {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "User not found",
|
|
})
|
|
}
|
|
|
|
if user.Userfcmtoken != "" {
|
|
updateQuery := `UPDATE app_users SET userfcmtoken = ? WHERE userid = ?`
|
|
if err := db.DB.Exec(updateQuery, user.Userfcmtoken, uid).Error; err != nil {
|
|
utils.Logger.Errorw("Failed to update FCM token", "error", err)
|
|
}
|
|
}
|
|
|
|
user = domain.GetAdminUserbyid(uid)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": user,
|
|
})
|
|
}
|
|
|
|
func AdminConsoleLogin(c *fiber.Ctx) error {
|
|
|
|
var user models.User
|
|
var uid int
|
|
var status, dbPassword string
|
|
var query string
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"status": false,
|
|
"message": "Invalid request body",
|
|
})
|
|
}
|
|
|
|
if strings.TrimSpace(user.Authname) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"code": 400,
|
|
"status": false,
|
|
"message": "authname is required",
|
|
})
|
|
}
|
|
|
|
query = `
|
|
SELECT userid, password, status
|
|
FROM app_users
|
|
WHERE authname = ? AND configid = ?
|
|
`
|
|
db.DB.Raw(query, user.Authname, 9).Row().Scan(&uid, &dbPassword, &status)
|
|
|
|
if uid == 0 {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 409,
|
|
"message": "Invalid Email",
|
|
})
|
|
}
|
|
|
|
if strings.EqualFold(status, "InActive") {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 403,
|
|
"message": "Inactive Account. Contact admin.",
|
|
})
|
|
}
|
|
|
|
if strings.TrimSpace(dbPassword) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 409,
|
|
"message": "Please setup a password.",
|
|
"details": fiber.Map{
|
|
"userid": uid,
|
|
"setup": true,
|
|
},
|
|
})
|
|
}
|
|
|
|
if strings.TrimSpace(user.Password) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 401,
|
|
"message": "Password is required",
|
|
"userid": uid,
|
|
})
|
|
}
|
|
|
|
if user.Password != dbPassword {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 401,
|
|
"message": "Incorrect password",
|
|
})
|
|
}
|
|
|
|
if user.Userfcmtoken != "" {
|
|
_ = db.DB.Exec(
|
|
`UPDATE app_users SET userfcmtoken = ? WHERE userid = ?`,
|
|
user.Userfcmtoken, uid,
|
|
)
|
|
}
|
|
|
|
user = domain.GetAdminUserbyid(uid)
|
|
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 200,
|
|
"message": "Login successful",
|
|
"details": user,
|
|
})
|
|
}
|
|
|
|
func CustomerLogin(c *fiber.Ctx) error {
|
|
|
|
var data models.Customer
|
|
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return err
|
|
}
|
|
|
|
q1 := `select a.customerid,a.authmode,a.configid,a.deviceid,a.devicetype,a.customertoken,a.firstname,a.lastname,
|
|
a.contactno,a.profileimage,a.address,a.suburb,a.city,a.state,a.landmark,a.doorno,a.postcode,
|
|
a.latitude,a.longitude,a.applocationid,a.status,a.profileimage, a.dialcode, a.deviceid, a.devicetype, a.authmode,
|
|
a.configid, a.customertoken, a.intro, b.tenantid , c.qrmode, b.locationid
|
|
from customers a
|
|
INNER JOIN tenantcustomers b ON a.customerid=b.customerid
|
|
LEFT JOIN app_location c ON a.applocationid=c.applocationid
|
|
where a.configid=2 and a.contactno= '` + data.Contactno + `' `
|
|
|
|
utils.Logger.Debugw("Customer Login Query", "query", q1)
|
|
|
|
db.DB.Raw(q1).Find(&data)
|
|
|
|
if data.Customerid == 0 {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "Account not found",
|
|
})
|
|
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": data,
|
|
})
|
|
}
|
|
|
|
func BasicRoute(c *fiber.Ctx) error {
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": "Hello Customer Route",
|
|
})
|
|
}
|
|
|
|
func CreateUser(c *fiber.Ctx) error {
|
|
|
|
var user models.User
|
|
var info models.UserInfo
|
|
|
|
// 🔹 Parse request body
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return c.Status(http.StatusBadRequest).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusBadRequest,
|
|
"message": "Invalid request body",
|
|
})
|
|
}
|
|
|
|
// 🔹 Validate mandatory fields
|
|
if user.Configid == 0 {
|
|
return c.Status(http.StatusBadRequest).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusBadRequest,
|
|
"message": "configid is required",
|
|
})
|
|
}
|
|
|
|
// 🔹 Check duplicate user (contactno / emailid + configid)
|
|
exists, err := domain.CheckUserExists(user.Contactno, user.Email, user.Configid)
|
|
if err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Database error",
|
|
})
|
|
}
|
|
|
|
if exists {
|
|
return c.Status(http.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "User already exists with this contact number or email",
|
|
})
|
|
}
|
|
|
|
// 🔹 Start transaction
|
|
tx := db.DB.Begin()
|
|
|
|
if err := tx.Table("app_users").Create(&user).Error; err != nil {
|
|
tx.Rollback()
|
|
return c.Status(http.StatusConflict).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "Failed to create user",
|
|
})
|
|
}
|
|
|
|
if err := tx.Commit().Error; err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Transaction failed",
|
|
})
|
|
}
|
|
|
|
// 🔹 Fetch created user info
|
|
info = domain.Getuserbyid(user.Userid)
|
|
|
|
return c.Status(http.StatusCreated).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": http.StatusCreated,
|
|
"message": "Success",
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func GetUserInfo(c *fiber.Ctx) error {
|
|
uid, _ := strconv.Atoi(c.Query("userid"))
|
|
|
|
user := domain.Getuserbyid(uid)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusCreated,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": user,
|
|
})
|
|
}
|
|
func GetAllUsers(c *fiber.Ctx) error {
|
|
roleID, _ := strconv.Atoi(c.Query("roleid", "0"))
|
|
configID, _ := strconv.Atoi(c.Query("configid", "0"))
|
|
tenantID, _ := strconv.Atoi(c.Query("tenantid", "0"))
|
|
pageno, _ := strconv.Atoi(c.Query("pageno", "1"))
|
|
pagesize, _ := strconv.Atoi(c.Query("pagesize", "10"))
|
|
status := c.Query("status", "") // 👈 added
|
|
keyword := c.Query("keyword", "")
|
|
|
|
users := domain.GetAllUsers(roleID, configID, tenantID, pageno, pagesize, status, keyword)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": users,
|
|
})
|
|
}
|
|
|
|
func DeleteUser(c *fiber.Ctx) error {
|
|
type Request struct {
|
|
Userid int `json:"userid"`
|
|
}
|
|
|
|
var req Request
|
|
|
|
if err := c.BodyParser(&req); err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusBadRequest,
|
|
"message": "Invalid request body",
|
|
})
|
|
}
|
|
|
|
if req.Userid == 0 {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusBadRequest,
|
|
"message": "Missing userid",
|
|
})
|
|
}
|
|
|
|
err := db.DB.Table("app_users").Where("userid = ?", req.Userid).Delete(nil).Error
|
|
if err != nil {
|
|
return c.JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{
|
|
"status": true,
|
|
"code": http.StatusOK,
|
|
"message": "User deleted successfully",
|
|
})
|
|
}
|
|
|
|
func TenantWebLogin(c *fiber.Ctx) error {
|
|
utils.Logger.Infow("Starting TenantWebLogin")
|
|
|
|
var user models.User
|
|
var info models.TenantUserInfo
|
|
var uid, roleid int
|
|
var status, dbPassword string
|
|
var query string
|
|
|
|
// Parse request body
|
|
if err := c.BodyParser(&user); err != nil {
|
|
utils.Logger.Errorw("Error parsing body", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"status": false,
|
|
"message": "Invalid request body",
|
|
})
|
|
}
|
|
|
|
// Check login method: authname or contactno
|
|
if user.Authname != "" {
|
|
query = `
|
|
SELECT userid, password, status, roleid
|
|
FROM app_users
|
|
WHERE authname = ? AND configid = ?
|
|
`
|
|
db.DB.Raw(query, user.Authname, user.Configid).Row().Scan(&uid, &dbPassword, &status, &roleid)
|
|
} else if user.Contactno != "" {
|
|
query = `
|
|
SELECT userid, password, status, roleid
|
|
FROM app_users
|
|
WHERE contactno = ? AND configid = ?
|
|
`
|
|
db.DB.Raw(query, user.Contactno, user.Configid).Row().Scan(&uid, &dbPassword, &status, &roleid)
|
|
} else {
|
|
utils.Logger.Errorw("Missing authname or contactno")
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"code": 400,
|
|
"status": false,
|
|
"message": "authname or contactno required",
|
|
})
|
|
}
|
|
|
|
tenantFormExists := true
|
|
|
|
if uid == 0 {
|
|
utils.Logger.Infow("Invalid Email at TenantWebLogin", "email", user.Authname)
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 409,
|
|
"message": "Invalid Email",
|
|
"tenantform": tenantFormExists,
|
|
})
|
|
}
|
|
|
|
// Check if user is inactive
|
|
if status == "InActive" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 403,
|
|
"message": "Inactive Account. Contact admin.",
|
|
})
|
|
}
|
|
|
|
// Compare roleid in request vs DB
|
|
if user.Roleid != roleid {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 403,
|
|
"message": "Unauthorized email.",
|
|
})
|
|
}
|
|
|
|
// Check if password is not set
|
|
if strings.TrimSpace(dbPassword) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 409,
|
|
"message": "Please setup a password.",
|
|
"tenantform": tenantFormExists,
|
|
"details": fiber.Map{
|
|
"userid": uid,
|
|
"setup": true,
|
|
},
|
|
})
|
|
}
|
|
|
|
// Check if password is provided in request
|
|
if strings.TrimSpace(user.Password) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 401,
|
|
"message": "Password is required",
|
|
"tenantform": tenantFormExists,
|
|
})
|
|
}
|
|
|
|
// Validate password
|
|
if user.Password != dbPassword {
|
|
utils.Logger.Infow("Incorrect password attempt", "uid", uid)
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 401,
|
|
"message": "Incorrect password",
|
|
"tenantform": tenantFormExists,
|
|
})
|
|
}
|
|
|
|
user.Userid = uid
|
|
|
|
// Update FCM token if provided
|
|
if user.Userfcmtoken != "" {
|
|
updateQuery := `
|
|
UPDATE app_users
|
|
SET userfcmtoken = ?
|
|
WHERE userid = ?
|
|
`
|
|
if err := db.DB.Exec(updateQuery, user.Userfcmtoken, uid).Error; err != nil {
|
|
utils.Logger.Errorw("Error updating userfcmtoken", "error", err)
|
|
} else {
|
|
utils.Logger.Infow("Updated userfcmtoken", "userid", uid)
|
|
}
|
|
}
|
|
|
|
info = domain.GetTenantUserbyId(uid)
|
|
|
|
utils.Logger.Infow("Tenant found", "tenant", info.Tenantname)
|
|
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 200,
|
|
"message": "Login successful",
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func AppLogin(c *fiber.Ctx) error {
|
|
utils.Logger.Infow("Starting TenantWebLogin")
|
|
|
|
var user models.User
|
|
var info models.TenantUserInfo
|
|
var uid int
|
|
var status, dbPassword string
|
|
var query string
|
|
|
|
// Parse request body
|
|
if err := c.BodyParser(&user); err != nil {
|
|
utils.Logger.Errorw("Error parsing body", "error", err)
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"status": false,
|
|
"message": "Invalid request body",
|
|
})
|
|
}
|
|
|
|
// Check login method: authname or contactno
|
|
if user.Authname != "" {
|
|
query = `
|
|
SELECT userid, password, status
|
|
FROM app_users
|
|
WHERE authname = ? AND configid = ?
|
|
`
|
|
db.DB.Raw(query, user.Authname, user.Configid).Row().Scan(&uid, &dbPassword, &status)
|
|
} else if user.Contactno != "" {
|
|
query = `
|
|
SELECT userid, password, status
|
|
FROM app_users
|
|
WHERE contactno = ? AND configid = ?
|
|
`
|
|
db.DB.Raw(query, user.Contactno, user.Configid).Row().Scan(&uid, &dbPassword, &status)
|
|
} else {
|
|
utils.Logger.Errorw("Missing authname or contactno")
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"code": 400,
|
|
"status": false,
|
|
"message": "authname or contactno required",
|
|
})
|
|
}
|
|
|
|
tenantFormExists := true
|
|
|
|
if uid == 0 {
|
|
utils.Logger.Infow("Invalid Email at TenantWebLogin", "email", user.Authname)
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 409,
|
|
"message": "Invalid Email",
|
|
"tenantform": tenantFormExists,
|
|
})
|
|
}
|
|
|
|
// Check if user is inactive
|
|
if status == "InActive" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 403,
|
|
"message": "Inactive Account. Contact admin.",
|
|
})
|
|
}
|
|
|
|
// Check if password is not set
|
|
if strings.TrimSpace(dbPassword) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 409,
|
|
"message": "Please setup a password.",
|
|
"tenantform": tenantFormExists,
|
|
"details": fiber.Map{
|
|
"userid": uid,
|
|
"setup": true,
|
|
},
|
|
})
|
|
}
|
|
|
|
// Check if password is provided in request
|
|
if strings.TrimSpace(user.Password) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 401,
|
|
"message": "Password is required",
|
|
"tenantform": tenantFormExists,
|
|
})
|
|
}
|
|
|
|
// Validate password
|
|
if user.Password != dbPassword {
|
|
utils.Logger.Infow("Incorrect password attempt", "uid", uid)
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 401,
|
|
"message": "Incorrect password",
|
|
"tenantform": tenantFormExists,
|
|
})
|
|
}
|
|
|
|
user.Userid = uid
|
|
|
|
// Update FCM token if provided
|
|
if user.Userfcmtoken != "" {
|
|
updateQuery := `
|
|
UPDATE app_users
|
|
SET userfcmtoken = ?
|
|
WHERE userid = ?
|
|
`
|
|
if err := db.DB.Exec(updateQuery, user.Userfcmtoken, uid).Error; err != nil {
|
|
utils.Logger.Errorw("Error updating userfcmtoken", "error", err)
|
|
} else {
|
|
utils.Logger.Infow("Updated userfcmtoken", "userid", uid)
|
|
}
|
|
}
|
|
|
|
info = domain.GetTenantUserbyId(uid)
|
|
|
|
utils.Logger.Infow("Tenant found", "tenant", info.Tenantname)
|
|
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 200,
|
|
"message": "Login successful",
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func CreateUserV2(c *fiber.Ctx) error {
|
|
var user models.User
|
|
var info models.UserInfo
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"message": "Invalid request body",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
tx := db.DB.Begin()
|
|
|
|
user.Status = "InActive"
|
|
|
|
// Insert into app_users
|
|
if err := tx.Table("app_users").Create(&user).Error; err != nil {
|
|
tx.Rollback()
|
|
return c.Status(fiber.StatusConflict).JSON(fiber.Map{
|
|
"code": 409,
|
|
"message": "Failed to create user",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
// Insert into tenantstaffs
|
|
staff := models.Tenantstaffs{
|
|
Tenantid: user.Tenantid,
|
|
Moduleid: 2,
|
|
Locationid: user.Locationid,
|
|
Userid: user.Userid,
|
|
Status: "InActive",
|
|
}
|
|
|
|
if err := tx.Table("tenantstaffs").Create(&staff).Error; err != nil {
|
|
tx.Rollback()
|
|
return c.Status(fiber.StatusConflict).JSON(fiber.Map{
|
|
"code": 409,
|
|
"message": "Failed to create tenant staff",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
// Insert into app_userpools
|
|
pool := models.AppUserpools{
|
|
Userid: user.Userid,
|
|
Partnerid: user.Partnerid,
|
|
Onduty: 1,
|
|
Latitude: "",
|
|
Longitude: "",
|
|
Status: "idle",
|
|
}
|
|
|
|
if err := tx.Table("app_userpools").Create(&pool).Error; err != nil {
|
|
tx.Rollback()
|
|
return c.Status(fiber.StatusConflict).JSON(fiber.Map{
|
|
"code": 409,
|
|
"message": "Failed to create user pool",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
// Commit transaction
|
|
if err := tx.Commit().Error; err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": 500,
|
|
"message": "Transaction commit failed",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
// Fetch user info
|
|
info = domain.Getuserbyid(user.Userid)
|
|
|
|
return c.Status(fiber.StatusCreated).JSON(fiber.Map{
|
|
"code": 201,
|
|
"message": "User created successfully",
|
|
"status": true,
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func UpdateUserV2(c *fiber.Ctx) error {
|
|
var userInput map[string]interface{}
|
|
|
|
if err := c.BodyParser(&userInput); err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"message": "Invalid request body",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
userID, ok := userInput["userid"]
|
|
if !ok || userID == nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"message": "Missing userid",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
tx := db.DB.Begin()
|
|
|
|
// Update only fields provided for app_users
|
|
if err := tx.Table("app_users").Where("userid = ?", userID).Updates(userInput).Error; err != nil {
|
|
tx.Rollback()
|
|
return c.Status(fiber.StatusConflict).JSON(fiber.Map{
|
|
"code": 409,
|
|
"message": "Failed to update user",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
// Filter relevant fields for tenantstaffs update
|
|
staffFields := map[string]interface{}{}
|
|
if tenantid, ok := userInput["tenantid"]; ok {
|
|
staffFields["tenantid"] = tenantid
|
|
}
|
|
if locationid, ok := userInput["locationid"]; ok {
|
|
staffFields["locationid"] = locationid
|
|
}
|
|
if status, ok := userInput["status"]; ok {
|
|
staffFields["status"] = status
|
|
}
|
|
|
|
if len(staffFields) > 0 {
|
|
if err := tx.Table("tenantstaffs").Where("userid = ?", userID).Updates(staffFields).Error; err != nil {
|
|
tx.Rollback()
|
|
return c.Status(fiber.StatusConflict).JSON(fiber.Map{
|
|
"code": 409,
|
|
"message": "Failed to update tenant staff",
|
|
"status": false,
|
|
})
|
|
}
|
|
}
|
|
|
|
if err := tx.Commit().Error; err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
|
|
"code": 500,
|
|
"message": "Transaction commit failed",
|
|
"status": false,
|
|
})
|
|
}
|
|
|
|
info := domain.Getuserbyid(int(userID.(float64))) // type assert if coming from JSON
|
|
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"code": 200,
|
|
"message": "User updated successfully",
|
|
"status": true,
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func TenantWebLoginv2(c *fiber.Ctx) error {
|
|
utils.Logger.Infow("Unified login started")
|
|
|
|
var user models.User
|
|
var info models.TenantUserInfo
|
|
var uid = c.Locals("uid").(int)
|
|
var dbPassword = c.Locals("password").(string)
|
|
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
|
|
"code": 400,
|
|
"status": false,
|
|
"message": "Invalid request body",
|
|
})
|
|
}
|
|
|
|
tenantFormExists := true
|
|
|
|
// Check if password is not set
|
|
if strings.TrimSpace(dbPassword) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 409,
|
|
"message": "Please setup a password.",
|
|
"tenantform": tenantFormExists,
|
|
"details": fiber.Map{
|
|
"userid": uid,
|
|
"setup": true,
|
|
},
|
|
})
|
|
}
|
|
|
|
if strings.TrimSpace(user.Password) == "" {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 401,
|
|
"message": "Password is required",
|
|
"tenantform": tenantFormExists,
|
|
})
|
|
}
|
|
|
|
if user.Password != dbPassword {
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": 401,
|
|
"message": "Incorrect password",
|
|
"tenantform": tenantFormExists,
|
|
})
|
|
}
|
|
|
|
user.Userid = uid
|
|
|
|
if user.Userfcmtoken != "" {
|
|
updateQuery := `UPDATE app_users SET userfcmtoken = ? WHERE userid = ?`
|
|
if err := db.DB.Exec(updateQuery, user.Userfcmtoken, uid).Error; err != nil {
|
|
utils.Logger.Errorw("Error updating userfcmtoken", "error", err)
|
|
}
|
|
}
|
|
|
|
info = domain.GetTenantUserbyId(uid)
|
|
|
|
return c.Status(fiber.StatusOK).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": 200,
|
|
"message": "Login successful",
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func CreateConsoleUser(c *fiber.Ctx) error {
|
|
|
|
var user models.ConsoleUser
|
|
var info models.UserInfo
|
|
|
|
// 🔹 Parse request body
|
|
if err := c.BodyParser(&user); err != nil {
|
|
return c.Status(http.StatusBadRequest).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusBadRequest,
|
|
"message": "Invalid request body",
|
|
})
|
|
}
|
|
|
|
// 🔹 Validation
|
|
if user.Configid == 0 {
|
|
return c.Status(http.StatusBadRequest).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusBadRequest,
|
|
"message": "configid is required",
|
|
})
|
|
}
|
|
|
|
// if len(user.Applocationids) == 0 {
|
|
// return c.Status(http.StatusBadRequest).JSON(fiber.Map{
|
|
// "status": false,
|
|
// "code": http.StatusBadRequest,
|
|
// "message": "at least one applocationid is required",
|
|
// })
|
|
// }
|
|
|
|
// 🔹 Duplicate user check
|
|
exists, err := domain.CheckUserExists(user.Contactno, user.Email, user.Configid)
|
|
if err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Database error",
|
|
})
|
|
}
|
|
|
|
if exists {
|
|
return c.Status(http.StatusConflict).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "User already exists",
|
|
})
|
|
}
|
|
|
|
// 🔹 Start transaction
|
|
tx := db.DB.Begin()
|
|
|
|
// 🔹 Create user
|
|
if err := tx.Table("app_users").Create(&user).Error; err != nil {
|
|
tx.Rollback()
|
|
return c.Status(http.StatusConflict).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusConflict,
|
|
"message": "Failed to create user",
|
|
})
|
|
}
|
|
|
|
// 🔹 Assign MULTIPLE location access
|
|
// for _, locID := range user.Applocationids {
|
|
// locationConfig := models.AppLocationConfig{
|
|
// Applocationid: locID,
|
|
// Configid: user.Configid,
|
|
// Userid: user.Userid,
|
|
// Partnerid: 0,
|
|
// Notify: "true",
|
|
// Status: "Active",
|
|
// }
|
|
|
|
// if err := tx.Table("app_locationconfig").Create(&locationConfig).Error; err != nil {
|
|
// tx.Rollback()
|
|
// return c.Status(http.StatusConflict).JSON(fiber.Map{
|
|
// "status": false,
|
|
// "code": http.StatusConflict,
|
|
// "message": "Failed to assign location access",
|
|
// })
|
|
// }
|
|
// }
|
|
|
|
// 🔹 Commit transaction
|
|
if err := tx.Commit().Error; err != nil {
|
|
return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
|
|
"status": false,
|
|
"code": http.StatusInternalServerError,
|
|
"message": "Transaction failed",
|
|
})
|
|
}
|
|
|
|
// 🔹 Fetch created user info
|
|
info = domain.Getuserbyid(user.Userid)
|
|
|
|
return c.Status(http.StatusCreated).JSON(fiber.Map{
|
|
"status": true,
|
|
"code": http.StatusCreated,
|
|
"message": "User created with multiple location access",
|
|
"details": info,
|
|
})
|
|
}
|
|
|
|
func GetAllUsersv2(c *fiber.Ctx) error {
|
|
roleID, _ := strconv.Atoi(c.Query("roleid", "0"))
|
|
configID, _ := strconv.Atoi(c.Query("configid", "0"))
|
|
tenantID, _ := strconv.Atoi(c.Query("tenantid", "0"))
|
|
pageno, _ := strconv.Atoi(c.Query("pageno", "1"))
|
|
pagesize, _ := strconv.Atoi(c.Query("pagesize", "10"))
|
|
keyword := c.Query("keyword", "")
|
|
|
|
users := domain.GetAllUsersv2(roleID, configID, tenantID, pageno, pagesize, keyword)
|
|
|
|
return c.JSON(fiber.Map{
|
|
"code": http.StatusOK,
|
|
"message": "Success",
|
|
"status": true,
|
|
"details": users,
|
|
})
|
|
}
|