This commit is contained in:
TsMask
2023-08-15 11:18:21 +08:00
253 changed files with 20123 additions and 241 deletions

View File

@@ -785,6 +785,21 @@ func XormCheckLoginUser(name, password, cryptArgo string) (bool, *User, error) {
return true, user, nil
}
func XormIsExistUser(accid string) (bool, error) {
log.Info("XormIsExistUser processing... ")
exist, err := xEngine.Table("user").
Where("account_id=?", accid).
Exist()
if err != nil {
log.Error("Failed to exist user:", err)
return false, err
}
return exist, nil
}
func XormGetConfigValue(moduleName, configTag string) (string, error) {
var value string
_, err := xEngine.Table("config").
@@ -1456,15 +1471,14 @@ type permission struct {
Object string `json:"object"`
}
func IsPermissionDeny(token, method, dbname, tbname string) (bool, error) {
log.Info("IsPermissionDeny processing... ")
func IsPermissionAllowed(token, method, dbname, tbname string) (bool, error) {
log.Info("IsPermissionAllowed processing... ")
exist, err := xEngine.Table("permission").
Join("INNER", "role_permission", "permission.permission_name = role_permission.p_name").
Join("INNER", "user_role", "role_permission.r_name = user_role.r_name").
Join("INNER", "session", "user_role.u_name = session.account_id and session.access_token=?", token).
Where("method in ('*',?) and element in ('*',?) and object in ('*',?)", method, dbname, tbname).
//Where("method=? and element=?", method, dbname).
Exist()
if err != nil {
return false, err

View File

@@ -30,6 +30,9 @@ var (
GoVer string
)
var (
DefaultUriPrefix = "/api/rest"
)
var (
ErrParamsNotAdapted = errors.New("the number of params is not adapted")

View File

@@ -4,6 +4,7 @@ import (
"net/http"
"ems.agt/lib/log"
"ems.agt/lib/services"
)
func LoggerTraceMiddleware(next http.Handler) http.Handler {
@@ -25,6 +26,10 @@ func LoggerTraceMiddleware(next http.Handler) http.Handler {
//r.Body = ioutil.NopCloser(bytes.NewReader(body))
//log.Trace("Body:", string(body))
// Call the next handler, which can be another middleware in the chain, or the final handler.
if r.Method == "OPTIONS" {
services.ResponseStatusOK201Accepted(w)
return
}
next.ServeHTTP(w, r)
})
}

View File

@@ -10,7 +10,6 @@ import (
"ems.agt/features/dbrest"
"ems.agt/features/file"
"ems.agt/features/fm"
"ems.agt/features/maintenance"
"ems.agt/features/mml"
"ems.agt/features/nbi"
"ems.agt/features/pm"
@@ -32,60 +31,29 @@ type Router struct {
var routers []Router
// var (
// commonUriPattern = config.UriPrefix + "/{apiCategory}/{apiVersion}/elementType/{elementTypeValue}/objectType/{objectTypeValue}"
// getUriPattern = config.UriPrefix + "/resourceManagement/{apiVersion}/elementType/{elementTypeValue}/objectType/{objectTypeValue}"
// getStatePattern = config.UriPrefix + "/systemManagement/{apiVersion}/elementType/{elementTypeValue}/objectType/systemState"
// // // database management rest pattern discard
// // XormGetDataUri = config.UriPrefix + "/databaseManagement/{apiVersion}/elementType/{databaseName}/objectType/{tableName}"
// // XormSelectDataUri = config.UriPrefix + "/databaseManagement/{apiVersion}/select/{databaseName}/{tableName}"
// // XormInsertDataUri = config.UriPrefix + "/databaseManagement/{apiVersion}/insert/{databaseName}/{tableName}"
// // XormUpdateDataUri = config.UriPrefix + "/databaseManagement/{apiVersion}/update/{databaseName}/{tableName}"
// // XormDeleteDataUri = config.UriPrefix + "/databaseManagement/{apiVersion}/delete/{databaseName}/{tableName}"
// // XormCommonUri = config.UriPrefix + "/databaseManagement/{apiVersion}/{databaseName}/{tableName}"
// // alarm management
// postAlarmPattern = config.UriPrefix + "/faultManagement/{apiVersion}/elementType/{elementTypeValue}/objectType/alarms"
// // performance management
// postPerformancePattern = config.UriPrefix + "/performanceManagement/{apiVersion}/elementType/{elementTypeValue}/objectType/kpiReport/{index}"
// measureTaskUri = config.UriPrefix + "/performanceManagement/{apiVersion}/elementType/{elementTypeValue}/objectType/measureTask"
// measureReportUri = config.UriPrefix + "/performanceManagement/{apiVersion}/elementType/{elementTypeValue}/objectType/measureReport"
// // parameter config management
// paramConfigUri = config.UriPrefix + "/systemManagement/{apiVersion}/elementType/{elementTypeValue}/objectType/config/{paraName}"
// // NE info
// UriNeInfo = config.UriPrefix + "/systemManagement/{apiVersion}/elementType/{elementTypeValue}/objectType/neInfo"
// )
func init() {
Register("POST", security.UriOauthToken, security.LoginFromOMC, nil)
Register("POST", security.UriOauthHandshake, security.HandshakeFromOMC, nil)
Register("DELETE", security.UriOauthToken, security.LogoutFromOMC, nil)
Register("OPTIONS", security.UriOauthToken, OptionsProc, nil)
Register("OPTIONS", security.UriOauthHandshake, OptionsProc, nil)
Register("POST", security.CustomUriOauthToken, security.LoginFromOMC, nil)
Register("DELETE", security.CustomUriOauthToken, security.LogoutFromOMC, nil)
Register("POST", security.CustomUriOauthHandshake, security.HandshakeFromOMC, nil)
// System state
Register("GET", state.UriSysState, state.GetStateFromNF, nil)
Register("OPTIONS", state.UriSysState, OptionsProc, nil)
Register("GET", state.UriSysState2, state.GetStateFromNF, nil)
Register("OPTIONS", state.UriSysState, OptionsProc, nil)
Register("OPTIONS", state.UriSysState2, OptionsProc, nil)
Register("GET", state.UriSysInfoAll, state.GetAllSysinfoFromNF, nil)
Register("GET", state.UriSysInfoOne, state.GetOneSysinfoFromNF, nil)
Register("OPTIONS", state.UriSysInfoAll, OptionsProc, nil)
Register("OPTIONS", state.UriSysInfoOne, OptionsProc, nil)
Register("GET", state.UriLicenseInfoAll, state.GetAllLicenseInfoFromNF, nil)
Register("GET", state.UriLicenseInfoOne, state.GetOneLicenseInfoFromNF, nil)
Register("OPTIONS", state.UriLicenseInfoAll, OptionsProc, nil)
Register("OPTIONS", state.UriLicenseInfoOne, OptionsProc, nil)
Register("GET", state.CustomUriSysState, state.GetStateFromNF, nil)
Register("GET", state.CustomUriSysState2, state.GetStateFromNF, nil)
Register("GET", state.CustomUriSysInfoAll, state.GetAllSysinfoFromNF, nil)
Register("GET", state.CustomUriSysInfoOne, state.GetOneSysinfoFromNF, nil)
Register("GET", state.CustomUriLicenseInfoAll, state.GetAllLicenseInfoFromNF, nil)
Register("GET", state.CustomUriLicenseInfoOne, state.GetOneLicenseInfoFromNF, nil)
// database management
Register("GET", dbrest.XormGetDataUri, dbrest.DatabaseGetData, nil)
@@ -93,38 +61,42 @@ func init() {
Register("POST", dbrest.XormInsertDataUri, dbrest.DatabaseInsertData, nil)
Register("PUT", dbrest.XormUpdateDataUri, dbrest.DatabaseUpdateData, nil)
Register("DELETE", dbrest.XormDeleteDataUri, dbrest.DatabaseDeleteData, nil)
// corss orgin domain
Register("OPTIONS", dbrest.XormGetDataUri, OptionsProc, nil)
Register("OPTIONS", dbrest.XormSelectDataUri, OptionsProc, nil)
Register("OPTIONS", dbrest.XormInsertDataUri, OptionsProc, nil)
Register("OPTIONS", dbrest.XormUpdateDataUri, OptionsProc, nil)
Register("OPTIONS", dbrest.XormDeleteDataUri, OptionsProc, nil)
Register("GET", dbrest.CustomXormGetDataUri, dbrest.DatabaseGetData, nil)
Register("GET", dbrest.CustomXormSelectDataUri, dbrest.DatabaseGetData, nil)
Register("POST", dbrest.CustomXormInsertDataUri, dbrest.DatabaseInsertData, nil)
Register("PUT", dbrest.CustomXormUpdateDataUri, dbrest.DatabaseUpdateData, nil)
Register("DELETE", dbrest.CustomXormDeleteDataUri, dbrest.DatabaseDeleteData, nil)
Register("GET", dbrest.XormCommonUri, dbrest.DatabaseGetData, nil)
Register("POST", dbrest.XormCommonUri, dbrest.DatabaseInsertData, nil)
Register("PUT", dbrest.XormCommonUri, dbrest.DatabaseUpdateData, nil)
Register("DELETE", dbrest.XormCommonUri, dbrest.DatabaseDeleteData, nil)
Register("GET", dbrest.CustomXormCommonUri, dbrest.DatabaseGetData, nil)
Register("POST", dbrest.CustomXormCommonUri, dbrest.DatabaseInsertData, nil)
Register("PUT", dbrest.CustomXormCommonUri, dbrest.DatabaseUpdateData, nil)
Register("DELETE", dbrest.CustomXormCommonUri, dbrest.DatabaseDeleteData, nil)
Register("GET", dbrest.XormExtDataUri, dbrest.ExtDatabaseGetData, nil)
Register("POST", dbrest.XormExtDataUri, dbrest.ExtDatabaseInsertData, nil)
Register("PUT", dbrest.XormExtDataUri, dbrest.ExtDatabaseUpdateData, nil)
Register("DELETE", dbrest.XormExtDataUri, dbrest.ExtDatabaseDeleteData, nil)
// corss orgin domain
Register("OPTIONS", dbrest.XormInsertDataUri, OptionsProc, nil)
Register("OPTIONS", dbrest.XormUpdateDataUri, OptionsProc, nil)
Register("OPTIONS", dbrest.XormDeleteDataUri, OptionsProc, nil)
Register("OPTIONS", dbrest.XormCommonUri, OptionsProc, nil)
Register("GET", dbrest.CustomXormExtDataUri, dbrest.ExtDatabaseGetData, nil)
Register("POST", dbrest.CustomXormExtDataUri, dbrest.ExtDatabaseInsertData, nil)
Register("PUT", dbrest.CustomXormExtDataUri, dbrest.ExtDatabaseUpdateData, nil)
Register("DELETE", dbrest.CustomXormExtDataUri, dbrest.ExtDatabaseDeleteData, nil)
// alarm restful Register
Register("POST", fm.UriAlarms, fm.PostAlarmFromNF, nil)
Register("Get", fm.UriAlarms, fm.GetAlarmFromNF, nil)
Register("OPTIONS", fm.UriAlarms, OptionsProc, nil)
Register("POST", fm.CustomUriAlarms, fm.PostAlarmFromNF, nil)
Register("Get", fm.CustomUriAlarms, fm.GetAlarmFromNF, nil)
// performance restful Register
Register("POST", pm.PostPerformancePattern, pm.PostKPIReportFromNF, nil)
Register("POST", pm.PerformanceUri, pm.PostKPIReportFromNF, nil)
Register("POST", pm.MeasureTaskUri, pm.PostMeasureTaskToNF, nil)
Register("PUT", pm.MeasureTaskUri, pm.PutMeasureTaskToNF, nil)
Register("DELETE", pm.MeasureTaskUri, pm.DeleteMeasureTaskToNF, nil)
@@ -134,7 +106,15 @@ func init() {
Register("POST", pm.MeasurementUri, pm.PostMeasurementFromNF, nil)
Register("GET", pm.MeasurementUri, pm.GetMeasurementFromNF, nil)
Register("OPTIONS", pm.MeasureTaskUri, OptionsProc, nil)
Register("POST", pm.CustomPerformanceUri, pm.PostKPIReportFromNF, nil)
Register("POST", pm.CustomMeasureTaskUri, pm.PostMeasureTaskToNF, nil)
Register("PUT", pm.CustomMeasureTaskUri, pm.PutMeasureTaskToNF, nil)
Register("DELETE", pm.CustomMeasureTaskUri, pm.DeleteMeasureTaskToNF, nil)
Register("PATCH", pm.CustomMeasureTaskUri, pm.PatchMeasureTaskToNF, nil)
Register("POST", pm.CustomMeasureReportUri, pm.PostMeasureReportFromNF, nil)
Register("POST", pm.CustomMeasurementUri, pm.PostMeasurementFromNF, nil)
Register("GET", pm.CustomMeasurementUri, pm.GetMeasurementFromNF, nil)
// parameter config management
Register("GET", cm.ParamConfigUri, cm.GetParamConfigFromNF, nil)
@@ -142,88 +122,105 @@ func init() {
Register("PUT", cm.ParamConfigUri, cm.PutParamConfigToNF, nil)
Register("DELETE", cm.ParamConfigUri, cm.DeleteParamConfigToNF, nil)
Register("OPTIONS", cm.ParamConfigUri, OptionsProc, nil)
Register("GET", cm.CustomParamConfigUri, cm.GetParamConfigFromNF, nil)
Register("POST", cm.CustomParamConfigUri, cm.PostParamConfigToNF, nil)
Register("PUT", cm.CustomParamConfigUri, cm.PutParamConfigToNF, nil)
Register("DELETE", cm.CustomParamConfigUri, cm.DeleteParamConfigToNF, nil)
// Get/Create/Modify/Delete NE info
Register("GET", cm.UriNeInfo, cm.GetNeInfo, nil)
Register("POST", cm.UriNeInfo, cm.PostNeInfo, nil)
Register("PUT", cm.UriNeInfo, cm.PutNeInfo, nil)
Register("DELETE", cm.UriNeInfo, cm.DeleteNeInfo, nil)
Register("OPTIONS", cm.UriNeInfo, OptionsProc, nil)
// Get/Create/Modify/Delete NE info
Register("GET", cm.CustomUriNeInfo, cm.GetNeInfo, nil)
Register("POST", cm.CustomUriNeInfo, cm.PostNeInfo, nil)
Register("PUT", cm.CustomUriNeInfo, cm.PutNeInfo, nil)
Register("DELETE", cm.CustomUriNeInfo, cm.DeleteNeInfo, nil)
// Post MML command to NF
Register("POST", mml.UriMML, mml.PostMMLToNF, nil)
Register("OPTIONS", mml.UriMML, OptionsProc, nil)
Register("POST", mml.UriOmMmlExt, mml.PostMMLToOMC, nil)
Register("OPTIONS", mml.UriOmMmlExt, OptionsProc, nil)
Register("POST", mml.CustomUriMML, mml.PostMMLToNF, nil)
Register("POST", mml.CustomUriOmMmlExt, mml.PostMMLToOMC, nil)
// Northbound Get NRM
Register("GET", nbi.GetNRMUri, nbi.NBIGetNRMFromNF, nil)
Register("GET", nbi.CustomGetNRMUri, nbi.NBIGetNRMFromNF, nil)
// Import/Export NF CM
Register("GET", cm.NeCmUri, cm.ExportCmFromNF, nil)
Register("POST", cm.NeCmUri, cm.ImportCmToNF, nil)
Register("OPTIONS", cm.NeCmUri, OptionsProc, nil)
Register("GET", cm.UriNeCmFile, cm.DownloadNeBackupFile, nil)
Register("DELETE", cm.UriNeCmFile, cm.DeleteNeBackupFile, nil)
Register("OPTIONS", cm.UriNeCmFile, OptionsProc, nil)
Register("GET", cm.CustomNeCmUri, cm.ExportCmFromNF, nil)
Register("POST", cm.CustomNeCmUri, cm.ImportCmToNF, nil)
Register("GET", cm.CustomUriNeCmFile, cm.DownloadNeBackupFile, nil)
Register("DELETE", cm.CustomUriNeCmFile, cm.DeleteNeBackupFile, nil)
// Software management
Register("GET", cm.UriSoftware, cm.DownloadSoftwareFile, nil)
Register("POST", cm.UriSoftware, cm.UploadSoftwareFile, nil)
Register("DELETE", cm.UriSoftware, cm.DeleteSoftwareFile, nil)
Register("OPTIONS", cm.UriSoftware, OptionsProc, nil)
Register("POST", cm.UriSoftwareNE, cm.DistributeSoftwareToNF, nil)
Register("PUT", cm.UriSoftwareNE, cm.ActiveSoftwareToNF, nil)
Register("PATCH", cm.UriSoftwareNE, cm.RollBackSoftwareToNF, nil)
Register("OPTIONS", cm.UriSoftwareNE, OptionsProc, nil)
Register("GET", cm.CustomUriSoftware, cm.DownloadSoftwareFile, nil)
Register("POST", cm.CustomUriSoftware, cm.UploadSoftwareFile, nil)
Register("DELETE", cm.CustomUriSoftware, cm.DeleteSoftwareFile, nil)
Register("POST", cm.CustomUriSoftwareNE, cm.DistributeSoftwareToNF, nil)
Register("PUT", cm.CustomUriSoftwareNE, cm.ActiveSoftwareToNF, nil)
Register("PATCH", cm.CustomUriSoftwareNE, cm.RollBackSoftwareToNF, nil)
// License management
Register("GET", cm.LicenseUri, cm.ExportCmFromNF, nil)
Register("POST", cm.LicenseUri, cm.ImportCmToNF, nil)
Register("DELETE", cm.LicenseUri, cm.ImportCmToNF, nil)
Register("OPTIONS", cm.LicenseUri, OptionsProc, nil)
Register("POST", cm.NeLicenseUri, cm.ExportCmFromNF, nil)
Register("PUT", cm.NeLicenseUri, cm.ImportCmToNF, nil)
Register("PATCH", cm.NeLicenseUri, cm.ImportCmToNF, nil)
Register("OPTIONS", cm.NeLicenseUri, OptionsProc, nil)
Register("POST", cm.CustomNeLicenseUri, cm.ExportCmFromNF, nil)
Register("PUT", cm.CustomNeLicenseUri, cm.ImportCmToNF, nil)
Register("PATCH", cm.CustomNeLicenseUri, cm.ImportCmToNF, nil)
// Trace management
Register("POST", trace.UriTraceTask, trace.PostTraceTaskToNF, nil)
Register("PUT", trace.UriTraceTask, trace.PutTraceTaskToNF, nil)
Register("DELETE", trace.UriTraceTask, trace.DeleteTraceTaskToNF, nil)
Register("OPTIONS", trace.UriTraceTask, OptionsProc, nil)
Register("POST", trace.CustomUriTraceTask, trace.PostTraceTaskToNF, nil)
Register("PUT", trace.CustomUriTraceTask, trace.PutTraceTaskToNF, nil)
Register("DELETE", trace.CustomUriTraceTask, trace.DeleteTraceTaskToNF, nil)
// file management
Register("POST", file.UriFile, file.UploadFile, nil)
Register("GET", file.UriFile, file.DownloadFile, nil)
Register("DELETE", file.UriFile, file.DeleteFile, nil)
Register("OPTIONS", file.UriFile, OptionsProc, nil)
Register("POST", file.CustomUriFile, file.UploadFile, nil)
Register("GET", file.CustomUriFile, file.DownloadFile, nil)
Register("DELETE", file.CustomUriFile, file.DeleteFile, nil)
// AAAA
Register("GET", aaaa.UriAAAASSO, aaaa.GetSSOFromAAAA, nil)
// 系统维护
Register("GET", maintenance.Uri, maintenance.List, nil)
Register("GET", maintenance.UriPref, maintenance.Pref, nil)
Register("GET", maintenance.UriPrefLog, maintenance.PrefLog, nil)
Register("GET", maintenance.UriSqlClient, maintenance.SqlClient, nil)
Register("GET", maintenance.UriTop, maintenance.Top, nil)
Register("PATCH", maintenance.UriTop, maintenance.TopOps, nil)
// AAAA
Register("GET", aaaa.CustomUriAAAASSO, aaaa.GetSSOFromAAAA, nil)
}
// To resolv rest POST/PUT/DELETE/PATCH cross domain
func OptionsProc(w http.ResponseWriter, r *http.Request) {
services.ResponseStatusOK200Null(w)
services.ResponseStatusOK204NoContent(w)
}
func NewRouter() *mux.Router {

View File

@@ -6,7 +6,6 @@ import (
"errors"
"fmt"
"io"
"io/ioutil"
"mime/multipart"
"os"
"path/filepath"
@@ -288,7 +287,7 @@ func CheckNorthboundValidRequest(w http.ResponseWriter, r *http.Request) (string
// check media type(content type) only support "application/json"
// response 415-1
if !IsJsonContentType(r) {
log.Error("Invalid Content-Type")
log.Error("invalid Content-Type")
ResponseUnsupportedMediaType415(w)
return token, err
}
@@ -297,14 +296,14 @@ func CheckNorthboundValidRequest(w http.ResponseWriter, r *http.Request) (string
// 401-1 response
token, ret = oauth.IsCarriedToken(r)
if ret == false {
log.Error("AccessToken is not carried")
log.Error("accessToken is not carried")
ResponseUnauthorized401AccessTokenNotCarried(w)
return token, err
}
// 401-2 response
if dborm.XormExistValidToken(token, config.GetExpiresFromConfig()) == false {
log.Error("AccessToken fails or does not exist")
log.Error("accessToken fails or does not exist")
ResponseUnauthorized401AccessTokenNotExist(w)
return token, err
}
@@ -385,14 +384,14 @@ func CheckCommonValidRequest(w http.ResponseWriter, r *http.Request) (string, er
// 401-1 response
token, ret = oauth.IsCarriedToken(r)
if ret == false {
log.Error("AccessToken is not carried")
log.Error("accessToken is not carried")
ResponseUnauthorized401AccessTokenNotCarried(w)
return token, err
}
// 401-2 response
if dborm.XormExistValidToken(token, config.GetExpiresFromConfig()) == false {
log.Error("AccessToken fails or does not exist")
log.Error("accessToken fails or does not exist")
ResponseUnauthorized401AccessTokenNotExist(w)
return token, err
}
@@ -417,6 +416,20 @@ func CheckCommonValidRequest(w http.ResponseWriter, r *http.Request) (string, er
return token, nil
}
func CheckUserPermission(token, method, dbname, tbname string) (bool, error) {
if config.GetYamlConfig().OMC.RBACMode == true {
exist, err := dborm.IsPermissionAllowed(token, method, dbname, tbname)
if err != nil {
return false, err
}
if !exist {
return false, nil
}
}
return true, nil
}
func IsLocalhost(host string) bool {
if strings.Contains(host, "127.0.0.1") || strings.Contains(host, "::1") {
return true
@@ -455,7 +468,7 @@ func CheckFrontValidRequest(w http.ResponseWriter, r *http.Request) (string, err
if config.GetYamlConfig().Auth.Token && IsLocalhost(r.RemoteAddr) == false {
token, ret = oauth.IsCarriedToken(r)
if ret == false {
err = errors.New("AccessToken is not carried")
err = errors.New("accessToken is not carried")
log.Error(err)
ResponseUnauthorized401AccessTokenNotCarried(w)
return token, err
@@ -463,7 +476,7 @@ func CheckFrontValidRequest(w http.ResponseWriter, r *http.Request) (string, err
// 401-2 response
if dborm.XormExistValidToken(token, config.GetExpiresFromConfig()) == false {
err = errors.New("AccessToken fails or does not exist")
err = errors.New("accessToken fails or does not exist")
log.Error(err)
ResponseUnauthorized401AccessTokenNotExist(w)
return token, err
@@ -480,17 +493,6 @@ func CheckFrontValidRequest(w http.ResponseWriter, r *http.Request) (string, err
}
/*
// response 403 Forbidden, permissions deny
// todo...
plist := globalSession.GetPermissionFromSession(token)
log.Debug("permission list:", plist)
if len(plist) == 0 || plist[0] == false {
log.Debug("User permission deny")
ResponseForbidden403NotPermission(w)
return
}
*/
vars := mux.Vars(r)
apiVer := vars["apiVersion"]
if apiVer != global.ApiVersionV1 {
@@ -514,7 +516,7 @@ func CheckExtValidRequest(w http.ResponseWriter, r *http.Request) (string, error
if config.GetYamlConfig().Auth.Token {
token, ret = oauth.IsCarriedToken(r)
if ret == false {
err = errors.New("AccessToken is not carried")
err = errors.New("accessToken is not carried")
log.Error(err)
ResponseUnauthorized401AccessTokenNotCarried(w)
return token, err
@@ -522,7 +524,7 @@ func CheckExtValidRequest(w http.ResponseWriter, r *http.Request) (string, error
// 401-2 response
if dborm.XormExistValidToken(token, config.GetExpiresFromConfig()) == false {
err = errors.New("AccessToken fails or does not exist")
err = errors.New("accessToken fails or does not exist")
log.Error(err)
ResponseUnauthorized401AccessTokenNotExist(w)
return token, err
@@ -541,7 +543,7 @@ func CheckExtValidRequest(w http.ResponseWriter, r *http.Request) (string, error
vars := mux.Vars(r)
apiVer := vars["apiVersion"]
if apiVer != global.ApiVersionV1 {
err = errors.New("Uri is invalid")
err = errors.New("uri is invalid")
log.Error(err)
ResponseNotFound404UriNotExist(w, r)
return token, err
@@ -568,11 +570,22 @@ func ResponseStatusOK204NoContent(w http.ResponseWriter) {
ResponseWithJson(w, http.StatusNoContent, "")
}
func ResponseRedirect(w http.ResponseWriter, redirectUrl string) {
func ResponseStatusOK201Accepted(w http.ResponseWriter) {
ResponseWithJson(w, http.StatusAccepted, "")
}
type SSORedirect struct {
User string `json:"user"`
Token string `json:"token"`
}
func ResponseRedirect(w http.ResponseWriter, redirectUrl, user, token string) {
w.Header().Set("Cache-Control", "must-revalidate, no-store")
w.Header().Set("Content-Type", " text/html;charset=UTF-8")
w.Header().Set("Location", redirectUrl) //跳转地址设置
w.WriteHeader(http.StatusTemporaryRedirect) //重定向!
w.Header().Set("Location", redirectUrl) //跳转地址设置
//w.WriteHeader(http.StatusTemporaryRedirect) //重定向!
ssoRedirect := &SSORedirect{user, token}
ResponseWithJson(w, http.StatusTemporaryRedirect, *ssoRedirect)
}
func ResponseBadRequest400RmUIDsIsInvalid(w http.ResponseWriter, rmUIDs []string) {
@@ -594,13 +607,13 @@ func ResponseBadRequest400DuplicateAlarmId(w http.ResponseWriter, AlarmIds strin
}
func ResponseBadRequest400IncorrectLogin(w http.ResponseWriter) {
errorMessage := ErrorMessage{"4", "Incorrect username and password"}
errorMessage := ErrorMessage{"4", "incorrect username and password"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusBadRequest, errorResponse)
}
func ResponseBadRequest400WrongParamValue(w http.ResponseWriter) {
errorMessage := ErrorMessage{"5", "Wrong parameter value"}
errorMessage := ErrorMessage{"5", "wrong parameter value"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusBadRequest, errorResponse)
}
@@ -612,43 +625,43 @@ func ResponseBadRequest400CMCALoginError(w http.ResponseWriter) {
}
func ResponseBadRequest400InvalidJson(w http.ResponseWriter) {
errorMessage := ErrorMessage{"7", "Invalid json format"}
errorMessage := ErrorMessage{"7", "invalid json format"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusUnauthorized, errorResponse)
}
func ResponseUnauthorized401AccessTokenNotCarried(w http.ResponseWriter) {
errorMessage := ErrorMessage{"1", "AccessToken is not carried"}
errorMessage := ErrorMessage{"1", "accessToken is not carried"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusUnauthorized, errorResponse)
}
func ResponseUnauthorized401AccessTokenNotExist(w http.ResponseWriter) {
errorMessage := ErrorMessage{"2", "AccessToken fails or does not exist"}
errorMessage := ErrorMessage{"2", "accessToken fails or does not exist"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusUnauthorized, errorResponse)
}
func ResponseForbidden403NotPermission(w http.ResponseWriter) {
errorMessage := ErrorMessage{"1", "Do not have the operation permissions"}
errorMessage := ErrorMessage{"1", "do not have the operation permissions"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusForbidden, errorResponse)
}
func ResponseForbidden403MultiLoginNotAllowed(w http.ResponseWriter) {
errorMessage := ErrorMessage{"2", "Multiple logins are not allowed"}
errorMessage := ErrorMessage{"2", "multiple logins are not allowed"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusForbidden, errorResponse)
}
func ResponseNotFound404UriNotExist(w http.ResponseWriter, r *http.Request) {
errorMessage := ErrorMessage{"1", "The requested URI does not exist"}
errorMessage := ErrorMessage{"1", "the requested URI does not exist"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotFound, errorResponse)
}
func ResponseNotFound404UriNotExistExt(w http.ResponseWriter) {
errorMessage := ErrorMessage{"1", "The requested URI does not exist"}
errorMessage := ErrorMessage{"1", "the requested URI does not exist"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotFound, errorResponse)
}
@@ -670,37 +683,41 @@ func ResponseNotFound404PMNotExist(w http.ResponseWriter, rmUIDs []string) {
}
func ResponseNotFound404AlarmNotExist(w http.ResponseWriter, AlarmIds []string) {
errorMessage := ErrorMessage{"4", "AlarmIds does not exist: " + strings.Join(AlarmIds, ",")}
errorMessage := ErrorMessage{"4", "alarmIds does not exist: " + strings.Join(AlarmIds, ",")}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotFound, errorResponse)
}
func ResponseNotFound404GetSubscriptionNotExist(w http.ResponseWriter, SubIds []string) {
errorMessage := ErrorMessage{"5", "Subscription id does not exist: " + strings.Join(SubIds, ",")}
errorMessage := ErrorMessage{"5", "subscription id does not exist: " + strings.Join(SubIds, ",")}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotFound, errorResponse)
}
func ResponseNotFound404DeleteSubscriptionNotExist(w http.ResponseWriter, SubIds []string) {
errorMessage := ErrorMessage{"6", "Subscription id does not exist: " + strings.Join(SubIds, ",")}
errorMessage := ErrorMessage{"6", "subscription id does not exist: " + strings.Join(SubIds, ",")}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotFound, errorResponse)
}
func ResponseNotFound404GetAlarmSubscriptionNotExist(w http.ResponseWriter, SubIds []string) {
errorMessage := ErrorMessage{"7", "Subscription id does not exist: " + strings.Join(SubIds, ",")}
errorMessage := ErrorMessage{"7", "subscription id does not exist: " + strings.Join(SubIds, ",")}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotFound, errorResponse)
}
func ResponseNotFound404DeleteAlarmSubscriptionNotExist(w http.ResponseWriter, SubIds []string) {
errorMessage := ErrorMessage{"8", "Subscription id does not exist: " + strings.Join(SubIds, ",")}
errorMessage := ErrorMessage{"8", "subscription id does not exist: " + strings.Join(SubIds, ",")}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotFound, errorResponse)
}
func ResponseMethodNotAllowed405(w http.ResponseWriter, r *http.Request) {
errorMessage := ErrorMessage{"1", "Method not allowed"}
if r.Method == "OPTIONS" {
ResponseStatusOK204NoContent(w)
return
}
errorMessage := ErrorMessage{"1", "method not allowed"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusMethodNotAllowed, errorResponse)
}
@@ -710,79 +727,79 @@ func CustomResponseMethodNotAllowed405Handler() http.Handler {
}
func ResponseNotAcceptable406MissingParam(w http.ResponseWriter) {
errorMessage := ErrorMessage{"1", "Missing parameter: rmUIDs"}
errorMessage := ErrorMessage{"1", "missing parameter: rmUIDs"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotAcceptable, errorResponse)
}
func ResponseNotAcceptable406ParamError(w http.ResponseWriter, errorParamsName []string) {
errorMessage := ErrorMessage{"2", "Parameter name error: " + strings.Join(errorParamsName, ",")}
errorMessage := ErrorMessage{"2", "parameter name error: " + strings.Join(errorParamsName, ",")}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotAcceptable, errorResponse)
}
func ResponseNotAcceptable406QuerySQLError(w http.ResponseWriter) {
errorMessage := ErrorMessage{"3", "Wrong or non-query SQL statement"}
errorMessage := ErrorMessage{"3", "wrong or non-query SQL statement"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusNotAcceptable, errorResponse)
}
func ResponseRequestEntityTooLarge413SubscriptionExceed(w http.ResponseWriter, num int) {
errorMessage := ErrorMessage{"1", "The number of subscriptions greater than " + strconv.Itoa(num)}
errorMessage := ErrorMessage{"1", "the number of subscriptions greater than " + strconv.Itoa(num)}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusRequestEntityTooLarge, errorResponse)
}
func ResponseRequestEntityTooLarge413BodyToLarge(w http.ResponseWriter) {
errorMessage := ErrorMessage{"2", "The request entity too large"}
errorMessage := ErrorMessage{"2", "the request entity too large"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusRequestEntityTooLarge, errorResponse)
}
func ResponseRequestURITooLong414NRMNumExceed(w http.ResponseWriter, num int) {
errorMessage := ErrorMessage{"1", "The number of NRM rmUIDs greater than " + strconv.Itoa(num)}
errorMessage := ErrorMessage{"1", "the number of NRM rmUIDs greater than " + strconv.Itoa(num)}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusRequestURITooLong, errorResponse)
}
func ResponseRequestURITooLong414AlarmNumExceed(w http.ResponseWriter, num int) {
errorMessage := ErrorMessage{"2", "The number of alarmIds greater than " + strconv.Itoa(num)}
errorMessage := ErrorMessage{"2", "the number of alarmIds greater than " + strconv.Itoa(num)}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusRequestURITooLong, errorResponse)
}
func ResponseRequestURITooLong414PMNumExceed(w http.ResponseWriter, num int) {
errorMessage := ErrorMessage{"3", "The number of PM rmUIDs greater than " + strconv.Itoa(num)}
errorMessage := ErrorMessage{"3", "the number of PM rmUIDs greater than " + strconv.Itoa(num)}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusRequestURITooLong, errorResponse)
}
func ResponseRequestURITooLong414UriTooLong(w http.ResponseWriter) {
errorMessage := ErrorMessage{"3", "Request URI too long"}
errorMessage := ErrorMessage{"3", "request URI too long"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusRequestURITooLong, errorResponse)
}
func ResponseUnsupportedMediaType415(w http.ResponseWriter) {
errorMessage := ErrorMessage{"1", "Unsupported media type"}
errorMessage := ErrorMessage{"1", "unsupported media type"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusUnsupportedMediaType, errorResponse)
}
func ResponseInternalServerError500NFConnectRefused(w http.ResponseWriter) {
errorMessage := ErrorMessage{"1", "Internal server error, NF connnect refused"}
errorMessage := ErrorMessage{"1", "internal server error, NF connnect refused"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusInternalServerError, errorResponse)
}
func ResponseInternalServerError500DatabaseOperationFailed(w http.ResponseWriter) {
errorMessage := ErrorMessage{"2", "Internal server error, database opration failed"}
errorMessage := ErrorMessage{"2", "internal server error, database opration failed"}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusInternalServerError, errorResponse)
}
func ResponseInternalServerError500ProcessError(w http.ResponseWriter, err error) {
em := fmt.Sprintf("Internal server error: %v", err)
em := fmt.Sprintf("internal server error: %v", err)
errorMessage := ErrorMessage{"3", em}
errorResponse := ErrorResponse{errorMessage}
ResponseWithJson(w, http.StatusInternalServerError, errorResponse)
@@ -919,7 +936,7 @@ func ResponseFile(w http.ResponseWriter, code int, filePath string) {
func ResponseFileWithNameAndMD5(w http.ResponseWriter, code int, fileName, path, md5Sum string) {
filePath := path + "/" + fileName
fileBytes, err := ioutil.ReadFile(filePath)
fileBytes, err := os.ReadFile(filePath)
if err != nil {
log.Error("Failed to ReadFile:", err)
ResponseInternalServerError500ProcessError(w, err)