func (h *TenantHandler) AddUsersToTenant(TenantID, Name string, users, SecurityLevel string) TenantUsers {
bytes, err := client.Go("ignore", "com.duosoftware.tenant", "users").GetOne().ByUniqueKey(TenantID).Ok()
var t TenantUsers
if err == "" {
err := json.Unmarshal(bytes, &t)
if err != nil {
term.Write("No Users yet assigied "+t.TenantID, term.Debug)
//t=TenantUsers{}
t = TenantUsers{TenantID, []string{}}
t.TenantID = TenantID
} else {
for _, element := range t.Users {
if element == users {
return t
}
}
}
h.AddTenantForUsers(TenantMinimum{TenantID, Name}, users)
t.Users = append(t.Users, users)
var Activ TenantAutherized
Activ = TenantAutherized{}
id := common.GetHash(users + "-" + TenantID)
Activ.Autherized = true
Activ.ID = id
Activ.TenantID = TenantID
Activ.SecurityLevel = SecurityLevel
Activ.UserID = users
client.Go("ignore", "com.duosoftware.tenant", "authorized").StoreObject().WithKeyField("ID").AndStoreOne(Activ).Ok()
client.Go("ignore", "com.duosoftware.tenant", "users").StoreObject().WithKeyField("TenantID").AndStoreOne(t).Ok()
term.Write("Saved Tenant users"+t.TenantID, term.Debug)
return t
} else {
return t
}
}
func (h *TenantHandler) CreateTenant(t Tenant, user session.AuthCertificate, update bool) Tenant {
term.Write("CreateTenant saving user "+t.Name, term.Debug)
//client.c
bytes, err := client.Go("ignore", "com.duosoftware.tenant", "tenants").GetOne().ByUniqueKey(t.TenantID).Ok()
if err == "" {
var uList Tenant
err := json.Unmarshal(bytes, &uList)
if err != nil {
if t.TenantID == "" {
t.TenantID = common.GetGUID()
term.Write("Auto Gen TID "+t.TenantID+" New Tenant "+t.Name, term.Debug)
}
term.Write("Save Tenant saving Tenant "+t.Name+" New Tenant "+t.Name, term.Debug)
var inputParams map[string]string
inputParams = make(map[string]string)
inputParams["email"] = user.Email
inputParams["name"] = user.Name
inputParams["tenantID"] = t.TenantID
inputParams["tenantName"] = t.Name
h.AddUsersToTenant(t.TenantID, t.Name, user.UserID, "admin")
email.Send("ignore", "com.duosoftware.auth", "tenant", "tenant_creation", inputParams, user.Email)
client.Go("ignore", "com.duosoftware.tenant", "tenants").StoreObject().WithKeyField("TenantID").AndStoreOne(t).Ok()
} else {
if update {
term.Write("SaveUser saving Tenant "+t.TenantID+" Update user "+user.UserID, term.Debug)
client.Go("ignore", "com.duosoftware.tenant", "tenants").StoreObject().WithKeyField("TenantID").AndStoreOne(t).Ok()
}
}
} else {
term.Write("SaveUser saving Tenant fetech Error #"+err, term.Error)
}
return t
}
func (h *AuthHandler) AutherizeApp(Code, ApplicationID, AppSecret, UserID string) (bool, string) {
bytes, err := client.Go("ignore", "com.duosoftware.auth", "authcode").GetOne().ByUniqueKey(Code).Ok()
term.Write("AutherizeApp For ApplicationID "+ApplicationID+" Code "+Code+" Secret "+AppSecret+" Err "+err, term.Debug)
var uList AuthCode
err1 := json.Unmarshal(bytes, &uList)
term.Write(string(bytes[:]), term.Debug)
if err1 != nil {
var appH applib.Apphanler
application, err := appH.Get(ApplicationID, "ignorelib")
if err == "" {
if application.SecretKey == AppSecret && uList.UserID == UserID && Code == uList.Code {
var appAth AppAutherize
appAth.AppliccatioID = ApplicationID
appAth.AutherizeKey = ApplicationID + "-" + UserID
appAth.Name = application.Name
client.Go("ignore", "com.duosoftware.auth", "atherized").StoreObject().WithKeyField("AutherizeKey").AndStoreOne(appAth).Ok()
return true, ""
}
} else {
return false, err
}
} else {
return false, "Code invalid"
}
return false, "process error"
}
func (h *TenantHandler) AddTenantForUsers(Tenant TenantMinimum, UserID string) UserTenants {
bytes, err := client.Go("ignore", "com.duosoftware.tenant", "userstenantmappings").GetOne().ByUniqueKey(UserID).Ok()
var t UserTenants
//t.UserID
if err == "" {
err := json.Unmarshal(bytes, &t)
if err != nil {
term.Write("No Users yet assigied "+UserID, term.Debug)
t = UserTenants{UserID, []TenantMinimum{}}
t.UserID = UserID
} else {
for _, element := range t.TenantIDs {
if element.TenantID == Tenant.TenantID {
return t
}
}
}
t.TenantIDs = append(t.TenantIDs, Tenant)
client.Go("ignore", "com.duosoftware.tenant", "userstenantmappings").StoreObject().WithKeyField("UserID").AndStoreOne(t).Ok()
term.Write("Saved Tenant users"+UserID, term.Debug)
return t
} else {
return t
}
}
func (h *AuthHandler) SaveUser(u User, update bool) User {
term.Write("SaveUser saving user "+u.Name, term.Debug)
bytes, err := client.Go("ignore", "com.duosoftware.auth", "users").GetOne().ByUniqueKey(u.EmailAddress).Ok()
if err == "" {
var uList User
err := json.Unmarshal(bytes, &uList)
//if err == nil || bytes == nil {
if err != nil {
u.Active = false
u.UserID = common.GetGUID()
term.Write("SaveUser saving user "+u.Name+" New User "+u.UserID, term.Debug)
password := u.Password
u.Password = common.GetHash(u.Password)
u.ConfirmPassword = common.GetHash(u.ConfirmPassword)
var Activ ActivationEmail
Activ.GUUserID = u.EmailAddress
Activ.Token = common.RandText(10)
var inputParams map[string]string
inputParams = make(map[string]string)
inputParams["email"] = u.EmailAddress
inputParams["name"] = u.Name
inputParams["token"] = Activ.Token
inputParams["password"] = password
email.Send("ignore", "com.duosoftware.auth", "email", "user_activate", inputParams, u.EmailAddress)
term.Write("E Mail Sent", term.Debug)
client.Go("ignore", "com.duosoftware.auth", "activation").StoreObject().WithKeyField("Token").AndStoreOne(Activ).Ok()
term.Write("Activation stored", term.Debug)
client.Go("ignore", "com.duosoftware.auth", "users").StoreObject().WithKeyField("EmailAddress").AndStoreOne(u).Ok()
} else {
if update {
u.UserID = uList.UserID
u.Password = common.GetHash(u.Password)
u.ConfirmPassword = common.GetHash(u.Password)
term.Write("SaveUser saving user "+u.Name+" Update User "+u.UserID, term.Debug)
client.Go("ignore", "com.duosoftware.auth", "users").StoreObject().WithKeyField("EmailAddress").AndStoreOne(u).Ok()
}
}
//} else {
//term.Write("SaveUser saving user store Error #"+err.Error(), term.Error)
//}
} else {
term.Write("SaveUser saving user fetech Error #"+err, term.Error)
}
u.Password = "******"
u.ConfirmPassword = "******"
return u
}
func (h *AuthHandler) Login(email, password string) (User, string) {
term.Write("Login user email"+email, term.Debug)
term.Write(Config.UserName, term.Debug)
bytes, err := client.Go("ignore", "com.duosoftware.auth", "users").GetOne().ByUniqueKey(email).Ok()
var user User
if err == "" {
if bytes != nil {
var uList User
err := json.Unmarshal(bytes, &uList)
if err == nil {
if uList.Password == common.GetHash(password) && strings.ToLower(uList.EmailAddress) == strings.ToLower(email) {
return uList, ""
} else {
term.Write("password incorrect", term.Error)
}
} else {
if err != nil {
term.Write("Login user Error "+err.Error(), term.Error)
}
}
}
} else {
term.Write("Login user Error "+err, term.Error)
}
return user, "Error Validating user"
}
func GetSession(key, Domain string) (AuthCertificate, string) {
bytes, err := client.Go(key, "s.duosoftware.auth", "sessions").GetOne().ByUniqueKey(key).Ok()
term.Write("GetSession For SecurityToken "+key, term.Debug)
//term.Write("GetSession For SecurityToken "+string(bytes), term.Debug)
var c AuthCertificate
if err == "" {
if bytes != nil {
var uList AuthCertificate
err := json.Unmarshal(bytes, &uList)
if err == nil {
if Domain == "Nil" {
return uList, ""
} else {
if strings.ToLower(uList.Domain) != strings.ToLower(Domain) {
uList.Domain = strings.ToLower(Domain)
uList.SecurityToken = common.GetGUID()
AddSession(uList)
return uList, ""
} else {
return uList, ""
}
}
} else {
term.Write("GetSession Error "+err.Error(), term.Error)
}
}
} else {
term.Write("GetSession Error "+err, term.Error)
}
term.Write("GetSession No Session for SecurityToken "+key, term.Debug)
return c, "Error Session Not Found"
}
func (f *FileManager) Remove(request *messaging.FileRequest) messaging.FileResponse { // remove file from disk and database
fileResponse := messaging.FileResponse{}
var saveServerPath string = request.RootSavePath
file, err := ioutil.ReadFile(saveServerPath + request.FilePath + request.FileName)
if len(file) > 0 {
err = os.Remove(saveServerPath + request.FilePath + request.FileName)
}
if err == nil {
fileResponse.IsSuccess = true
fileResponse.Message = "Deletion of file successfully completed"
} else {
fileResponse.IsSuccess = true
fileResponse.Message = "Deletion of file Aborted"
}
obj := FileData{}
obj.Id = request.Parameters["id"]
obj.FileName = request.FileName
client.Go("token", request.Parameters["namespace"], request.Parameters["class"]).StoreObjectWithOperation("delete").WithKeyField("Id").AndStoreOne(obj).Ok()
fileResponse.IsSuccess = true
fileResponse.Message = "Deletion of file successfully completed"
return fileResponse
}
func (h *TenantHandler) AddUserToTenant(u session.AuthCertificate, users []InviteUsers) {
for _, user := range users {
var inputParams map[string]string
inputParams = make(map[string]string)
inputParams["email"] = user.Email
inputParams["name"] = user.Name
inputParams["userID"] = user.UserID
inputParams["tenantID"] = u.Domain
inputParams["FromName"] = u.Username
inputParams["FromID"] = u.UserID
inputParams["FromEmail"] = u.Email
req := InviteUserRequest{}
req.UserID = user.UserID
req.TenantID = u.Domain
req.RequestToken = common.RandText(10)
req.Name = user.Name
req.FromUserID = u.UserID
req.FromName = u.Name
req.FromEmail = u.Email
req.Email = user.Email
req.SecurityLevel = user.SecurityLevel
//h.AddUsersToTenant(t.TenantID, user.UserID, "admin")
client.Go("ignore", "com.duosoftware.tenant", "userrequest").StoreObject().WithKeyField("RequestToken").AndStoreOne(req).Ok()
email.Send("ignore", "com.duosoftware.auth", "tenant", "tenant_request", inputParams, user.Email)
}
}
func (h *AuthHandler) GetUser(email string) (User, string) {
term.Write("Login user email"+email, term.Debug)
term.Write(Config.UserName, term.Debug)
bytes, err := client.Go("ignore", "com.duosoftware.auth", "users").GetOne().ByUniqueKey(email).Ok()
var user User
if err == "" {
if bytes != nil {
var uList User
err := json.Unmarshal(bytes, &uList)
if err == nil {
uList.Password = "******"
uList.ConfirmPassword = "******"
return uList, ""
} else {
if err != nil {
term.Write("Login user Error "+err.Error(), term.Error)
}
}
}
} else {
term.Write("Login user Error "+err, term.Error)
}
return user, "Error Validating user"
}
func handleRequest(params martini.Params, res http.ResponseWriter, req *http.Request) { // res and req are injected by Martini
//start RabbitMQ Pusher
fmt.Println(params)
var requestBody1 messaging.ServiceRequest
rb, _ := ioutil.ReadAll(req.Body)
err := json.Unmarshal(rb, &requestBody1)
if err != nil {
fmt.Println("Error decoding from Json to Struct")
fmt.Println(err.Error())
} else {
publishToRabbitMQ(requestBody1.OperationCode, requestBody1)
if requestBody1.ScheduleTimeStamp != "" {
//Push to ObjectStore
tmp := ProcessObject{}
temp1 := requestBody1.RefID
temp2 := requestBody1.RefType
tmp.Id = (temp1 + temp2)
tmp.requestBody = requestBody1
client.Go("token", "schedule", "newobject").StoreObject().WithKeyField("Id").AndStoreOne(tmp).Ok()
}
}
}
func (h *AuthHandler) UserActivation(token string) bool {
//respond := ""
//check user from db
bytes, err := client.Go("ignore", "com.duosoftware.com", "activation").GetOne().ByUniqueKey(token).Ok()
if err == "" {
var uList ActivationEmail
err := json.Unmarshal(bytes, &uList)
if err == nil || bytes == nil {
//new user
if err != nil {
term.Write("Token Not Found", term.Debug)
return false
} else {
//uList[0].GUUserID
var u User
var inputParams map[string]string
inputParams = make(map[string]string)
inputParams["email"] = u.EmailAddress
inputParams["name"] = u.Name
//Change activation status to true and save
term.Write("Activate User "+u.Name+" Update User "+u.UserID, term.Debug)
email.Send("ignore", "com.duosoftware.auth", "email", "user_activated", inputParams, u.EmailAddress)
return true
}
}
} else {
term.Write("Activation Fail ", term.Debug)
return false
}
return false
}
func getEmailData(securityToken string, domain string, class string, templateId string) (email Emailtemplate) {
email = Emailtemplate{}
bytes, _ := client.Go(securityToken, domain, class).GetOne().ByUniqueKey(templateId).Ok()
email = Emailtemplate{}
var array map[string]interface{}
array = make(map[string]interface{})
_ = json.Unmarshal(bytes, &array)
for key, value := range array {
if key != "__osHeaders" {
if key == "Id" {
email.Id = value.(string)
continue
} else if key == "Subject" {
email.Subject = value.(string)
continue
} else if key == "Body" {
email.Body = value.(string)
continue
} else if key == "Signature" {
email.Signature = value.(string)
continue
} else if key == "Parameters" {
email.Parameters = getParameterMap(value.(string))
}
}
}
return email
}
//Activate user account using invitation mail send with token
//GET
//Url /UserActivation/sdfsdfwer23rsdff
//if user activation success method will return Success
func (serv RegistationService) UserActivation(token string) string {
respond := ""
//check user from db
bytes, err := client.Go("ignore", "com.duosoftware.com", "activation").GetOne().BySearching(token).Ok()
if err == "" {
var uList []User
err := json.Unmarshal(bytes, &uList)
if err == nil || bytes == nil {
//new user
if len(uList) == 0 {
term.Write("User Not Found", term.Debug)
} else {
var u User
u.UserID = uList[0].UserID
u.Password = uList[0].Password
u.Active = true
u.ConfirmPassword = uList[0].Password
u.Name = uList[0].Name
u.EmailAddress = uList[0].EmailAddress
//Change activation status to true and save
term.Write("Activate User "+u.Name+" Update User "+u.UserID, term.Debug)
client.Go("ignore", "com.duosoftware.auth", "users").StoreObject().WithKeyField("EmailAddress").AndStoreOne(u).Ok()
respond = "true"
var Activ ActivationEmail
Activ.EmailAddress = u.EmailAddress
//set token empty and save
Activ.Token = ""
client.Go("ignore", "com.duosoftware.com", "Activation").StoreObject().WithKeyField("EmailAddress").AndStoreOne(Activ).Ok()
Email(u.EmailAddress, Activ.Token, "Activated")
respond = "Success"
}
}
} else {
term.Write("Activation Fail ", term.Debug)
}
return respond
}
func (h *AuthHandler) GetAuthCode(ApplicationID, UserID, URI string) string {
var a AuthCode
a.ApplicationID = ApplicationID
a.UserID = UserID
a.URI = URI
a.Code = common.RandText(10)
client.Go("ignore", "com.duosoftware.auth", "authcode").StoreObject().WithKeyField("Code").AndStoreOne(a).Ok()
term.Write("GetAuthCode for "+ApplicationID+" with SecurityToken :"+UserID, term.Debug)
return a.Code
}
func (d *Downloader) DownloadObjects() {
nowTime := time.Now().Local() //current time
addedtime := nowTime.Add(time.Duration(15 * time.Minute)) //add 15 minutes to current time
formattedTime := addedtime.Format("20060102150405") //formatted new time
rawBytes, err := client.Go("efba1d6c3566e9bcfdf61a9a8d238dd8", "com.duosoftware.com", "schedule").GetMany().ByQuerying("Timestamp:[* " + formattedTime + "]").Ok()
if len(err) != 0 {
fmt.Println("ERROR : " + err)
}
d.executeObjects(rawBytes)
}
func addCirt(GUUserID string, p PermistionRecords, s SecInfo) {
var c Cirtificat
var r RecordUsers
term.Write("Methed Invoke addCirt", term.Debug)
c.POGid = getPODID(GUUserID, p.RecordID)
c.AccessLevel = p.AccessLevel
c.OtherData = p.OtherData
r.RecordID = p.RecordID
r.UserIDs = getUsers(p.RecordID, s)
client.Go(s.SecurityToken, s.POGDomain, "cirts").StoreObject().WithKeyField("POGid").AndStoreOne(c).Ok()
term.Write("Methed Invoke addCirt Insearted to com.duosoftware.pog.cirts."+c.POGid, term.Debug)
for _, element := range r.UserIDs {
if element == GUUserID {
return
}
}
r.UserIDs = append(r.UserIDs, GUUserID)
client.Go(s.SecurityToken, s.POGDomain, "records").StoreObject().WithKeyField("RecordID").AndStoreOne(r).Ok()
term.Write("Methed Invoke addCirt Inserted to com.duosoftware.pog.records."+r.RecordID, term.Debug)
}
func (h *TenantHandler) SearchTenants(Search string, since, pagesize int) []Tenant {
bytes, err := client.Go("ignore", "com.duosoftware.tenant", "tenants").GetMany().BySearching(Search).Ok()
var t []Tenant
if err == "" {
err := json.Unmarshal(bytes, &t)
if err != nil {
return t
}
}
return t
}
func testClient() {
//ytes, _ := client.Go("token", "com.duosoftware.customer", "account").GetOne().BySearching("supun").Ok()
tmp := Account{}
tmp.Id = "999"
tmp.name = "SVD"
tmp.address = "X"
client.Go("token", "com.duosoftware.customer", "account").StoreObject().WithKeyField("Id").AndStoreOne(tmp).Ok()
//if bytes != nil {
// fmt.Println(bytes)
//}
}
func (h *TenantHandler) Autherized(TenantID string, user session.AuthCertificate) (bool, TenantAutherized) {
bytes, err := client.Go("ignore", "com.duosoftware.tenant", "authorized").GetOne().ByUniqueKey(common.GetHash(user.UserID + "-" + TenantID)).Ok()
if err == "" {
var uList TenantAutherized
err := json.Unmarshal(bytes, &uList)
if err == nil {
return uList.Autherized, uList
} else {
return false, TenantAutherized{}
}
} else {
return false, TenantAutherized{}
}
}
func (h *TenantHandler) GetTenant(TenantID string) Tenant {
bytes, err := client.Go("ignore", "com.duosoftware.tenant", "tenants").GetOne().ByUniqueKey(TenantID).Ok()
var t Tenant
if err == "" {
err := json.Unmarshal(bytes, &t)
if err == nil {
return t
} else {
return t
}
} else {
return t
}
}
func (h *TenantHandler) GetTenantsForUser(UserID string) []TenantMinimum {
bytes, err := client.Go("ignore", "com.duosoftware.tenant", "userstenantmappings").GetOne().ByUniqueKey(UserID).Ok()
var t UserTenants
if err == "" {
err := json.Unmarshal(bytes, &t)
if err == nil {
return t.TenantIDs
} else {
return []TenantMinimum{}
}
} else {
return []TenantMinimum{}
}
}
func (h *AuthHandler) AppAutherize(ApplicationID, UserID string) bool {
bytes, err := client.Go("ignore", "com.duosoftware.auth", "atherized").GetOne().ByUniqueKey(ApplicationID + "-" + UserID).Ok()
term.Write("AppAutherize For Application "+ApplicationID+" UserID "+UserID, term.Debug)
if err == "" {
if bytes != nil {
var uList AppAutherize
err := json.Unmarshal(bytes, &uList)
if err == nil {
return true
}
}
} else {
term.Write("AppAutherize Error "+err, term.Error)
}
return false
}
func getUsers(RecordID string, s SecInfo) []string {
term.Write("Methed Invoke getUsers", term.Debug)
var c RecordUsers
//RecID = getPODID(UserID, recordID)
bytes, err := client.Go(s.SecurityToken, s.POGDomain, "records").GetOne().ByUniqueKey(RecordID).Ok()
//var t Tenant
if err == "" {
err := json.Unmarshal(bytes, &c)
if err == nil {
return c.UserIDs
} else {
return c.UserIDs
}
} else {
return c.UserIDs
}
}
func getCirt(UserID, recordID string, s SecInfo) Cirtificat {
term.Write("Methed Invoke getCirt", term.Debug)
var c Cirtificat
RecID := getPODID(UserID, recordID)
bytes, err := client.Go(s.SecurityToken, s.POGDomain, "cirts").GetOne().ByUniqueKey(RecID).Ok()
//var t Tenant
if err == "" {
err := json.Unmarshal(bytes, &c)
if err == nil {
return c
} else {
term.Write("Methed Invoke getCirt :"+err.Error(), term.Error)
return c
}
} else {
term.Write("Methed Invoke getCirt :"+err, term.Error)
return c
}
}
//User login
func (serv RegistationService) Login(l Login) {
bytes, err := client.Go("ignore", "com.duosoftware.auth", "users").GetOne().ByUniqueKey(l.EmailAddress).Ok()
fmt.Println(l.EmailAddress, l.Password)
fmt.Println("19")
if err == "" {
fmt.Println("20")
if bytes != nil {
fmt.Println("21")
newUser := User{}
//uList = make([]User, 0)
err := json.Unmarshal(bytes, &newUser)
fmt.Println("22")
fmt.Println("<<<<<<<<<<<", newUser)
if err == nil {
fmt.Println("23")
if newUser.Password == l.Password && newUser.EmailAddress == l.EmailAddress {
fmt.Println("24")
serv.ResponseBuilder().SetResponseCode(200).Write([]byte(newUser.Name))
//term.Write("password incorrect", term.Error)
} else {
fmt.Println("25")
serv.ResponseBuilder().SetResponseCode(201).Write([]byte("Password Wrong "))
}
} else {
fmt.Println("26")
if err != nil {
fmt.Println("27")
term.Write("Login user Error "+err.Error(), term.Error)
}
}
}
} else {
fmt.Println("28")
term.Write("Login user Error "+err, term.Error)
serv.ResponseBuilder().SetResponseCode(201).Write([]byte(err))
}
}
func (h *TenantHandler) AcceptRequest(u session.AuthCertificate, securityLevel, RequestToken string, accept bool) bool {
bytes, err := client.Go("ignore", "com.duosoftware.tenant", "userrequest").GetOne().ByUniqueKey(RequestToken).Ok()
var t InviteUserRequest
if err == "" {
err := json.Unmarshal(bytes, &t)
if err != nil {
if securityLevel == "" {
securityLevel = t.SecurityLevel
}
if accept {
h.AddUsersToTenant(t.TenantID, t.Name, t.UserID, securityLevel)
return true
} else {
return true
}
} else {
return false
}
} else {
return false
}
}
func (A BulkTransferService) Transfer(c messaging.BulkHeader) {
for _, detail := range c.Details {
switch detail.Type {
case "id":
bytes, err := client.Go("", c.Source, detail.Class).GetOne().ByUniqueKey(detail.Params["key"].(string)).Ok()
isErr, m := A.getMap(bytes, err)
if !isErr {
keyField := detail.Params["keyField"].(string)
client.Go("", c.Dest, detail.Class).StoreObject().WithKeyField(keyField).AndStoreOne(m).Ok()
} else {
fmt.Println("K OBJECT NOT FOUND!!!!")
}
break
case "filter":
bytes, err := client.Go("", c.Source, detail.Class).GetMany().ByQuerying(detail.Params["filter"].(string)).Ok()
isErr, m := A.getMapArray(bytes, err)
if !isErr {
keyField := detail.Params["keyField"].(string)
client.Go("", c.Dest, detail.Class).StoreObject().WithKeyField(keyField).AndStoreMany(m).Ok()
} else {
fmt.Println("F OBJECT NOT FOUND!!!!")
}
break
case "search":
bytes, err := client.Go("", c.Source, detail.Class).GetMany().BySearching(detail.Params["filter"].(string)).Ok()
isErr, m := A.getMapArray(bytes, err)
if !isErr {
keyField := detail.Params["keyField"].(string)
client.Go("", c.Dest, detail.Class).StoreObject().WithKeyField(keyField).AndStoreMany(m).Ok()
} else {
fmt.Println("S OBJECT NOT FOUND!!!!")
}
break
case "all":
break
default:
fmt.Println("UNKNOWN OPERATION!!!!")
break
}
}
A.ResponseBuilder().SetResponseCode(200).WriteAndOveride([]byte("{}"))
return
}
//Save user using Authlib
func SaveUser(u User) string {
term.Write("SaveUser saving user "+u.Name, term.Debug)
respond := ""
token := randToken()
fmt.Println("3")
fmt.Println(">>>>>>>>>>>>>>>")
fmt.Println(u.EmailAddress)
fmt.Println("<<<<<<<<<<<<<<<")
//bytes, err := client.Go("ignore", "com.duosoftware.auth", "users").GetOne().ByQuerying("EmailAddress :" + "*****@*****.**").Ok()
bytes, err := client.Go("ignore", "com.duosoftware.auth", "users").GetOne().ByUniqueKey(u.EmailAddress).Ok()
fmt.Println("{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{")
fmt.Println(string(bytes))
fmt.Println("}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}")
fmt.Println("4")
if err == "" {
var uList []User
uList = make([]User, 0)
err := json.Unmarshal(bytes, &uList)
if err == nil || bytes == nil {
fmt.Println("5")
//new user
fmt.Println(len(uList), "LLLLLLLLLLLLLLLLLLLL")
if len(uList) == 0 {
u.UserID = common.GetGUID()
term.Write("SaveUser saving user"+u.Name+" New User "+u.UserID, term.Debug)
client.Go("ignore", "com.duosoftware.auth", "users").StoreObject().WithKeyField("EmailAddress").AndStoreOne(u).Ok()
respond = "true"
fmt.Println("6")
//save Activation mail details
//EmailAddress and Token
//EmailAddress KeyProperty
var Activ ActivationEmail
Activ.EmailAddress = u.EmailAddress
Activ.Token = token
client.Go("ignore", "com.duosoftware.com", "activation").StoreObject().WithKeyField("EmailAddress").AndStoreOne(Activ).Ok()
fmt.Println("7")
Email(u.EmailAddress, token, "Activation")
} else if len(uList) == 1 {
//Alredy in Registerd user
//term.Write("User Already Registerd #"+err.Error(), term.Error)
fmt.Println("User Already Registerd")
}
} else {
fmt.Println("ERRRRRR")
//term.Write("SaveUser saving user store Error #"+err.Error(), term.Error)
respond = "false"
}
} else {
//term.Write("SaveUser saving user fetech Error #"+err, term.Error)
fmt.Println("errrrr")
respond = "false"
}
fmt.Println("8")
u.Password = "******"
u.ConfirmPassword = "******"
return respond
}
func (f *FileManager) Store(request *messaging.FileRequest) messaging.FileResponse { // store disk on database
fileResponse := messaging.FileResponse{}
if len(request.Body) == 0 {
//WHEN REQUEST COMES FROM A REST INTERFACE
file, header, err := request.WebRequest.FormFile("file")
if err != nil {
fileResponse.IsSuccess = false
fileResponse.Message = err.Error()
}
out, err := os.Create(header.Filename)
if err != nil {
fileResponse.IsSuccess = false
fileResponse.Message = err.Error()
}
// write the content from POST to the file
_, err = io.Copy(out, file)
if err != nil {
fileResponse.IsSuccess = false
fileResponse.Message = err.Error()
}
file2, err2 := ioutil.ReadFile(header.Filename)
if err2 != nil {
fileResponse.IsSuccess = false
fileResponse.Message = err.Error()
}
if checkIfFile(header.Filename) == "xlsx" {
SaveExcelEntries(header.Filename, request.Parameters["namespace"])
}
convertedBody := string(file2[:])
base64Body := common.EncodeToBase64(convertedBody)
//store file in the DB as a single file
obj := FileData{}
obj.Id = request.Parameters["id"]
obj.FileName = header.Filename
obj.Body = base64Body
headerToken := request.WebRequest.Header.Get("securityToken")
var extraMap map[string]interface{}
extraMap = make(map[string]interface{})
extraMap["File"] = "excelFile"
fmt.Println(headerToken)
fmt.Println("Namespace : " + request.Parameters["namespace"])
fmt.Println("Class : " + request.Parameters["class"])
//client.GoExtra(headerToken, request.Parameters["namespace"], request.Parameters["class"], extraMap).StoreObject().WithKeyField("Id").AndStoreOne(obj).FileOk()
fmt.Fprintf(request.WebResponse, "File uploaded successfully : ")
fmt.Fprintf(request.WebResponse, header.Filename)
//close the files
err = out.Close()
err = file.Close()
if err != nil {
fileResponse.IsSuccess = false
fileResponse.Message = err.Error()
}
//remove the temporary stored file from the disk
err2 = os.Remove(header.Filename)
if err2 != nil {
fileResponse.IsSuccess = false
fileResponse.Message = err2.Error()
}
if err == nil && err2 == nil {
fileResponse.IsSuccess = true
fileResponse.Message = "Storing file successfully completed"
} else {
fileResponse.IsSuccess = false
fileResponse.Message = "Storing file was unsuccessfull!" + "\n" + err.Error() + "\n" + err2.Error()
}
} else {
//WHEN REQUEST COMES FROM A NON REST INTERFACE
convertedBody := string(request.Body[:])
base64Body := common.EncodeToBase64(convertedBody)
//store file in the DB as a single file
obj := FileData{}
obj.Id = request.Parameters["id"]
obj.FileName = request.FileName
obj.Body = base64Body
client.Go("securityToken", request.Parameters["namespace"], request.Parameters["class"]).StoreObject().WithKeyField("Id").AndStoreOne(obj).FileOk()
fileResponse.IsSuccess = true
fileResponse.Message = "Storing file successfully completed"
}
return fileResponse
}