Ejemplo n.º 1
0
func setOneRedisExcel(request *messaging.ObjectRequest) RepositoryResponse {
	response := RepositoryResponse{}
	client, isError, errorMessage := getRedisExcelConnection(request)

	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		key := request.Controls.Namespace + "." + request.Controls.Class + "." + request.Controls.Id

		value := getStringByObject(request, request.Body.Object)

		err := client.Set(key, value, 0, 0, false, false)

		if err != nil {
			response.IsSuccess = false
			request.Log("Error inserting/updating object in Redis : " + key + ", " + err.Error())
			response.GetErrorResponse("Error inserting/updating one object in Redis" + err.Error())
		} else {
			response.IsSuccess = true
			response.Message = "Successfully inserted/updated one object in Redis"
			request.Log(response.Message)
		}
	}

	return response
}
Ejemplo n.º 2
0
func (repository CouchRepository) GetByKey(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting GET-BY-KEY")
	response := RepositoryResponse{}

	bucket, errorMessage, isError := getCouchBucket(request)

	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		key := request.Controls.Namespace + "." + request.Controls.Class + "." + request.Controls.Id
		rawBytes, err := bucket.GetRaw(key)

		var returnData map[string]interface{}
		returnData = make(map[string]interface{})

		json.Unmarshal(rawBytes, &returnData)

		if request.Controls.SendMetaData == "false" {
			delete(returnData, "__osHeaders")
		}

		rawBytes, err = json.Marshal(returnData)

		if err != nil {
			response.GetErrorResponse("Error retrieving object from couchbase")
		} else {
			response.GetResponseWithBody(rawBytes)
		}
	}

	return response
}
Ejemplo n.º 3
0
func (repository ElasticRepository) GetQuery(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting GET-QUERY!")
	response := RepositoryResponse{}
	queryType := request.Body.Query.Type

	switch queryType {
	case "Query":
		if request.Body.Query.Parameters != "*" {
			fieldsInByte := executeElasticQuery(request)
			if fieldsInByte != nil {
				response.IsSuccess = true
				response.Message = "Successfully Retrieved Data For Custom Query"
				response.GetResponseWithBody(fieldsInByte)
			} else {
				response.IsSuccess = false
				response.Message = "Aborted! Unsuccessful Retrieving Data For Custom Query"
				errorMessage := response.Message
				response.GetErrorResponse(errorMessage)
			}
		} else {
			//Check if just STAR then execute GET-SEARCH method
			request.Log("Redirecting to GET-SEARCH!")
			return search(request, request.Body.Query.Parameters)
		}
	default:
		return search(request, request.Body.Query.Parameters)

	}

	return response
}
Ejemplo n.º 4
0
func (repository PostgresRepository) GetQuery(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting GET-QUERY")
	response := RepositoryResponse{}

	queryType := request.Body.Query.Type
	switch queryType {
	case "Query":
		if request.Body.Query.Parameters != "*" {
			fieldsInByte := executePostgresQuery(request)
			if fieldsInByte != nil {
				response.IsSuccess = true
				response.Message = "Successfully Retrieved Data For Custom Query"
				response.GetResponseWithBody(fieldsInByte)
			} else {
				response.IsSuccess = false
				response.Message = "Aborted! Unsuccessful Retrieving Data For Custom Query"
				errorMessage := response.Message
				response.GetErrorResponse(errorMessage)
			}
		} else {
			return repository.GetAll(request)
		}
	default:
		request.Log(queryType + " not implemented in Postgres_SQL Db repository")
		return getDefaultNotImplemented()

	}

	return response
}
Ejemplo n.º 5
0
func setOneRedis(request *messaging.ObjectRequest) RepositoryResponse {
	response := RepositoryResponse{}
	client, isError, errorMessage := getRedisConnection(request)
	keyValue := getRedisRecordID(request, nil)
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else if keyValue != "" {
		key := request.Controls.Namespace + "." + request.Controls.Class + "." + keyValue
		request.Body.Object[request.Body.Parameters.KeyProperty] = keyValue
		value := getStringByObject(request.Body.Object)

		err := client.Set(key, value, 0, 0, false, false)

		if err != nil {
			response.IsSuccess = false
			request.Log("Error inserting/updating object in Redis : " + key + ", " + err.Error())
			response.GetErrorResponse("Error inserting/updating one object in Redis" + err.Error())
		} else {
			response.IsSuccess = true
			response.Message = "Successfully inserted/updated one object in Redis"
			request.Log(response.Message)
		}
	}

	//Update Response
	var Data []map[string]interface{}
	Data = make([]map[string]interface{}, 1)
	var actualData map[string]interface{}
	actualData = make(map[string]interface{})
	actualData["ID"] = keyValue
	Data[0] = actualData
	response.Data = Data

	return response
}
Ejemplo n.º 6
0
func (repository MongoRepository) InsertSingle(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting INSERT-SINGLE")
	response := RepositoryResponse{}
	collection, isError, errorMessage := getMongoConnection(request)
	key := getMongoDBRecordID(request, nil)
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else if key != "" {

		request.Body.Object[request.Body.Parameters.KeyProperty] = key
		request.Body.Object["_id"] = request.Controls.Namespace + "." + request.Controls.Class + "." + key

		err := collection.Insert(bson.M(request.Body.Object))
		if err != nil {
			response.IsSuccess = false
			response.GetErrorResponse("Error inserting one object in mongo" + err.Error())
		} else {
			response.IsSuccess = true
			response.Message = "Successfully inserted one object in Mongo"
			request.Log(response.Message)
		}
	}
	var Data []map[string]interface{}
	Data = make([]map[string]interface{}, 1)
	var actualData map[string]interface{}
	actualData = make(map[string]interface{})
	actualData["ID"] = key
	Data[0] = actualData
	response.Data = Data
	return response
}
Ejemplo n.º 7
0
func (repository CassandraRepository) GetByKey(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting Get-BY-KEY!")
	response := RepositoryResponse{}
	session, isError, errorMessage := getCassandraConnection(request)
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		isError = false

		//get primary key field name
		iter := session.Query("select type, column_name from system.schema_columns WHERE keyspace_name='" + getSQLnamespace(request) + "' AND columnfamily_name='" + request.Controls.Class + "'").Iter()

		my1, _ := iter.SliceMap()

		iter.Close()

		fieldName := ""

		for _, value := range my1 {

			if value["type"].(string) == "partition_key" {
				fieldName = value["column_name"].(string)
				break
			}
		}

		parameter := request.Controls.Id

		iter2 := session.Query("SELECT * FROM " + request.Controls.Class + " where " + fieldName + " = '" + parameter + "'").Iter()

		my, isErr := iter2.SliceMap()

		iter2.Close()

		if request.Controls.SendMetaData == "false" {

			for index, arrVal := range my {
				for key, _ := range arrVal {
					if key == "osheaders" {
						delete(my[index], key)
					}
				}
			}
		}

		byteValue, errMarshal := json.Marshal(my)
		if errMarshal != nil {
			response.IsSuccess = false
			response.GetErrorResponse("Error getting values for one object in Cassandra" + isErr.Error())
		} else {
			response.IsSuccess = true
			response.GetResponseWithBody(byteValue)
			response.Message = "Successfully retrieved values for one object in Cassandra"
			request.Log(response.Message)
		}
	}

	return response
}
Ejemplo n.º 8
0
func (repository CassandraRepository) GetAll(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting GET-ALL!")
	response := RepositoryResponse{}
	session, isError, errorMessage := getCassandraConnection(request)
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		isError = false

		iter2 := session.Query("SELECT * FROM " + request.Controls.Class).Iter()

		my, isErr := iter2.SliceMap()

		iter2.Close()

		skip := 0

		if request.Extras["skip"] != nil {
			skip, _ = strconv.Atoi(request.Extras["skip"].(string))
		}

		take := len(my)

		if request.Extras["take"] != nil {
			take, _ = strconv.Atoi(request.Extras["take"].(string))
		}

		fmt.Println(reflect.TypeOf(my))

		if request.Controls.SendMetaData == "false" {

			for index, arrVal := range my {
				for key, _ := range arrVal {
					if key == "osheaders" {
						delete(my[index], key)
					}
				}
			}
		}

		byteValue, errMarshal := json.Marshal(my[skip:(skip + take)])
		if errMarshal != nil {
			response.IsSuccess = false
			response.GetErrorResponse("Error getting values for all objects in Cassandra" + isErr.Error())
		} else {
			response.IsSuccess = true
			response.GetResponseWithBody(byteValue)
			response.Message = "Successfully retrieved values for all objects in Cassandra"
			request.Log(response.Message)
		}
	}

	return response
}
Ejemplo n.º 9
0
func (r QueuedStorageEngine) Store(request *messaging.ObjectRequest) (response repositories.RepositoryResponse) {

	conn, err := amqp.Dial("amqp://*****:*****@localhost:5672/")

	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()
	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	err = ch.ExchangeDeclare(
		"publisher_01", // name
		"direct",       // type
		true,           // durable
		false,          // auto-deleted
		false,          // internal
		false,          // no-wait
		nil,            // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	body, errMarshal := json.Marshal(request)

	if errMarshal != nil {
		response.Message = "Conversion to JSON failed!"
		request.Log(response.Message)
	} else {
		response.Message = "Conversion to JSON Success!"
		request.Log(response.Message)
		log.Printf(" [x] Sent %s", body)

	}
	err = ch.Publish(
		"publisher_01", // exchange
		"Queued",       // routing key
		false,          // mandatory
		false,          // immediate
		amqp.Publishing{
			// ContentType: "text/plain",
			ContentType: "*messaging.ObjectRequest",
			Body:        body,
		})
	failOnError(err, "Failed to publish a message")
	if err == nil {
		response.IsSuccess = true
	}

	//log.Printf(" [x] Sent %s", body)

	return response

}
Ejemplo n.º 10
0
func getRedisConnection(request *messaging.ObjectRequest) (client *goredis.Redis, isError bool, errorMessage string) {

	isError = false
	client, err := goredis.DialURL("tcp://@" + request.Configuration.ServerConfiguration["REDIS"]["Host"] + ":" + request.Configuration.ServerConfiguration["REDIS"]["Port"] + "/0?timeout=10s&maxidle=1")
	if err != nil {
		isError = true
		errorMessage = err.Error()
		request.Log("Error! Can't connect to server!error")

	}
	request.Log("Reusing existing GoRedis connection")
	return
}
Ejemplo n.º 11
0
func (repository ElasticRepository) DeleteMultiple(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting DELETE-MULTIPLE")
	response := RepositoryResponse{}

	conn := getConnection()(request)

	for _, object := range request.Body.Objects {
		key := getNoSqlKeyById(request, object)
		request.Log("Deleting single object from Elastic Search : " + key)
		_, err := conn.Delete(request.Controls.Namespace, request.Controls.Class, key, nil)
		_, err = conn.Delete(getKibanaElasticName(request), getKibanaElasticName(request), key, nil)
		if err != nil {
			errorMessage := "Elastic Search single delete error : " + err.Error()
			request.Log(errorMessage)
			response.GetErrorResponse(errorMessage)
		} else {
			response.IsSuccess = true
			response.Message = "Successfully deleted one in elastic search"
			request.Log(response.Message)
		}
	}

	return response

}
Ejemplo n.º 12
0
func (repository CouchRepository) DeleteSingle(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting DELETE-SINGLE")
	response := RepositoryResponse{}

	bucket, errorMessage, isError := getCouchBucket(request)
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		key := request.Controls.Namespace + "." + request.Controls.Class + "." + request.Controls.Id
		request.Log("Deleting object from couchbase : " + key)
		err := bucket.Delete(key)
		if err != nil {
			response.IsSuccess = false
			request.Log("Error deleting object from couchbase : " + key + ", " + err.Error())
			response.GetErrorResponse("Error deleting one object in Couchbase" + err.Error())
		} else {
			response.IsSuccess = true
			response.Message = "Successfully deleted one object in Coucahbase"
			request.Log(response.Message)
		}

	}

	return response
}
Ejemplo n.º 13
0
func (repository MysqlRepository) UpdateMultiple(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting UPDATE-MULTIPLE")
	response := RepositoryResponse{}
	session, isError, errorMessage := getMysqlConnection(request)
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {

		for i := 0; i < len(request.Body.Objects); i++ {
			noOfElements := len(request.Body.Objects[i]) - 1
			var keyUpdate = make([]string, noOfElements)
			var valueUpdate = make([]string, noOfElements)

			var startIndex = 0
			for key, value := range request.Body.Objects[i] {
				if key != request.Body.Parameters.KeyProperty {
					if key != "__osHeaders" {
						keyUpdate[startIndex] = key
						valueUpdate[startIndex] = value.(string)
						startIndex = startIndex + 1
					} else {
						keyUpdate[startIndex] = "osHeaders"
						valueUpdate[startIndex] = ConvertOsheaders(value.(messaging.ControlHeaders))
						startIndex = startIndex + 1
					}
				}

			}

			var argValueList string

			//Build the query string
			for i := 0; i < noOfElements; i++ {
				if i != noOfElements-1 {
					argValueList = argValueList + keyUpdate[i] + " = " + "'" + valueUpdate[i] + "'" + ", "
				} else {
					argValueList = argValueList + keyUpdate[i] + " = " + "'" + valueUpdate[i] + "'"
				}
			}

			//DEBUG USE : Display Query information
			//	fmt.Println("Table Name : " + request.Controls.Class)
			//	fmt.Println("Value list : " + argValueList)
			request.Log("UPDATE " + getSQLnamespace(request) + "." + request.Controls.Class + " SET " + argValueList + " WHERE " + request.Body.Parameters.KeyProperty + " =" + "'" + request.Body.Objects[i][request.Body.Parameters.KeyProperty].(string) + "'")
			_, err := session.Query("UPDATE " + getSQLnamespace(request) + "." + request.Controls.Class + " SET " + argValueList + " WHERE " + request.Body.Parameters.KeyProperty + " =" + "'" + request.Body.Objects[i][request.Body.Parameters.KeyProperty].(string) + "'")

			if err != nil {
				response.IsSuccess = false
				request.Log("Error updating object in MySQL  : " + getNoSqlKey(request) + ", " + err.Error())
				response.GetErrorResponse("Error updating one object in MySQL because no match was found!" + err.Error())
			} else {
				response.IsSuccess = true
				response.Message = "Successfully updating one object in MySQL "
				request.Log(response.Message)
			}
		}

	}
	return response
}
Ejemplo n.º 14
0
func (repository CouchRepository) DeleteMultiple(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting DELETE_MULTIPLE")
	response := RepositoryResponse{}

	bucket, errorMessage, isError := getCouchBucket(request)
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		for _, obj := range request.Body.Objects {
			key := getNoSqlKeyById(request, obj)
			request.Log("Deleting object from couchbase : " + key)
			err := bucket.Delete(key)
			if err != nil {
				response.IsSuccess = false
				request.Log("Error deleting object from couchbase : " + key + ", " + err.Error())
				response.GetErrorResponse("Error deleting Multiple objects in Couchbase" + err.Error())
			} else {
				response.IsSuccess = true
				response.Message = "Successfully deleted Multiple objects in Coucahbase"
				request.Log(response.Message)
			}
		}

	}

	return response
}
Ejemplo n.º 15
0
func getRedisExcelConnection(request *messaging.ObjectRequest) (client *goredis.Redis, isError bool, errorMessage string) {

	isError = false

	client, err := goredis.DialURL("tcp://@127.0.0.1:6379/0?timeout=10s&maxidle=1")
	if err != nil {
		isError = true
		errorMessage = err.Error()
		request.Log("Error! Can't connect to server!error")

	}
	request.Log("Reusing existing GoRedis connection")
	return
}
Ejemplo n.º 16
0
func (repository CouchRepository) GetAll(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting GET-ALL")
	response := RepositoryResponse{}
	bucket, errorMessage, isError := getCouchBucket(request)

	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		//Get all IDs
		viewResult, err := bucket.View("dev_allkeytemp", "allkeystemp", nil)

		//Iterate check for pattern and choose only desired IDs
		pattern := request.Controls.Namespace + "." + request.Controls.Class + "."

		var idArray []string
		for _, row := range viewResult.Rows {
			if strings.Contains((row.Key).(string), pattern) {
				idArray = append(idArray, (row.Key).(string))
			}
		}

		//read all data for fetched days and return
		var returnDataMap []map[string]interface{}

		data, err := bucket.GetBulkRaw(idArray)

		for key, _ := range data {
			var tempData map[string]interface{}
			tempData = make(map[string]interface{})
			json.Unmarshal(data[key], &tempData)

			if request.Controls.SendMetaData == "false" {
				delete(tempData, "__osHeaders")
			}

			returnDataMap = append(returnDataMap, tempData)
		}

		rawBytes, err := json.Marshal(returnDataMap)
		if err != nil {
			fmt.Println(err.Error())
			response.GetErrorResponse("Error retrieving object from couchbase : " + err.Error())
		} else {
			response.GetResponseWithBody(rawBytes)
		}
	}

	return response
}
Ejemplo n.º 17
0
func startAtomicOperation(request *messaging.ObjectRequest, repositoryList []repositories.AbstractRepository, successAction int, failAction int) (response repositories.RepositoryResponse) {

	canRollback := false
	if repositoryList == nil {
		fmt.Println("NIL REPOSITORIES")
	} else {
		fmt.Println("REPOSITORIES FOUND!")
		fmt.Print("Fetched Repositories : ")
		fmt.Println(repositoryList)
	}
	for _, repository := range repositoryList {
		if repository != nil {
			request.Log("Executing repository : " + repository.GetRepositoryName())

			tmpResponse := repositories.Execute(request, repository)
			canBreak := false

			if tmpResponse.IsSuccess {
				request.Log("Executing repository : " + repository.GetRepositoryName() + " - Success")
				switch successAction {
				case 1:
					response = tmpResponse
					continue
				case 3:
					response = tmpResponse
					canBreak = true
				}
			} else {
				request.Log("Executing repository : " + repository.GetRepositoryName() + " - Failed")
				switch failAction {
				case 1:
					continue
				case 2:
					canRollback = true
					canBreak = true
				case 3:
					response = tmpResponse
					canBreak = true
				}

				if canBreak == true {
					break
				}

				//1 = COMMIT, 2 = ROLLBACK, 3 = BREAK

			}
		} else {
			fmt.Println("NIL REPOSITORY FOUND!")
			continue
		}

	}

	if canRollback {
		request.Log("Transaction failed Rollbacking!!!")
	}
	return
}
Ejemplo n.º 18
0
func setManyRedis(request *messaging.ObjectRequest) RepositoryResponse {
	response := RepositoryResponse{}
	client, isError, errorMessage := getRedisConnection(request)
	var idData map[string]interface{}
	idData = make(map[string]interface{})
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {

		isError := false
		index := 0
		for _, object := range request.Body.Objects {
			index++
			keyValue := getRedisRecordID(request, object)

			if keyValue == "" {
				response.IsSuccess = false
				response.Message = "Failed inserting multiple object in Cassandra"
				request.Log(response.Message)
				request.Log("Inavalid ID request")
				return response
			}
			key := request.Controls.Namespace + "." + request.Controls.Class + "." + keyValue
			object[request.Body.Parameters.KeyProperty] = keyValue

			idData[strconv.Itoa(index)] = keyValue

			value := getStringByObject(object)
			err := client.Set(key, value, 0, 0, false, false)

			if err != nil {
				isError = true
				errorMessage = err.Error()
				break
			}
		}

		if isError == true {
			response.IsSuccess = false
			request.Log("Error inserting/updating multiple objects in Redis : " + errorMessage)
			response.GetErrorResponse("Error inserting/updating multiple objects in Redis" + errorMessage)
		} else {
			response.IsSuccess = true
			response.Message = "Successfully inserted/updated multiple objects in Redis"
			request.Log(response.Message)
		}
	}

	//Update Response
	var DataMap []map[string]interface{}
	DataMap = make([]map[string]interface{}, 1)
	var actualInput map[string]interface{}
	actualInput = make(map[string]interface{})
	actualInput["ID"] = idData
	DataMap[0] = actualInput
	response.Data = DataMap

	return response
}
Ejemplo n.º 19
0
func getMongoConnection(request *messaging.ObjectRequest) (client *mgo.Collection, isError bool, errorMessage string) {

	isError = false

	session, err := mgo.Dial(request.Configuration.ServerConfiguration["MONGO"]["Url"])
	if err != nil {
		isError = false
		errorMessage = err.Error()
		request.Log("Mongo connection initilizing failed!")
	}

	namespace := getSQLnamespace(request)
	client = session.DB(namespace).C(request.Controls.Class)
	return
}
func getPostgresReportingFieldOrder(request *messaging.ObjectRequest) []string {
	var returnArray []string
	//read fields
	byteValue := executePostgresReportingGetFields(request)

	err := json.Unmarshal(byteValue, &returnArray)
	if err != nil {
		request.Log("Converstion of Json Failed!")
		returnArray = make([]string, 1)
		returnArray[0] = "nil"
		return returnArray
	}

	return returnArray
}
Ejemplo n.º 21
0
func getCustomMongoConnection(request *messaging.ObjectRequest, customNamespace string, customClass string) (client *mgo.Collection, isError bool, errorMessage string) {

	isError = false

	session, err := mgo.Dial(request.Configuration.ServerConfiguration["MONGO"]["Url"])
	if err != nil {
		isError = false
		errorMessage = err.Error()
		request.Log("Mongo connection initilizing failed!")
	}

	//namespace := getSQLnamespace(request)
	client = session.DB(customNamespace).C(customClass)
	request.Log("Reusing existing Mongo connection")
	return
}
Ejemplo n.º 22
0
func executeCassandraGetSelectedFields(request *messaging.ObjectRequest) (returnByte []byte) {
	session, isError, _ := getCassandraConnection(request)
	if isError == true {
		request.Log("Cassandra connection failed")
		returnByte = nil
	} else {
		isError = false

		var selectedItemsQuery string

		var requestedFields []string
		request.Log("Requested Field List : " + request.Body.Special.Parameters)
		if request.Body.Special.Parameters == "*" {
			request.Log("All fields requested")
			requestedFields = make([]string, 1)
			requestedFields[0] = "*"
			selectedItemsQuery = "*"
		} else {
			requestedFields = strings.Split(request.Body.Special.Parameters, " ")

			for key, value := range requestedFields {
				if key == len(requestedFields)-1 {
					selectedItemsQuery += value
				} else {
					selectedItemsQuery += (value + ",")
				}
			}
		}

		iter2 := session.Query("select " + selectedItemsQuery + " from " + request.Controls.Class).Iter()

		my, _ := iter2.SliceMap()

		iter2.Close()

		byteValue, errMarshal := json.Marshal(my)
		if errMarshal != nil {
			request.Log("Error getting values for all objects in Cassandra")
			returnByte = []byte("Error JSON marshalling to BYTE array")
		} else {
			request.Log("Successfully retrieved values for all objects in Cassandra")
			returnByte = byteValue
		}
	}

	return
}
Ejemplo n.º 23
0
func (repository MongoRepository) GetAll(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting GET-ALL")
	response := RepositoryResponse{}
	collection, isError, errorMessage := getMongoConnection(request)

	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		isError = false
		var data []bson.M
		err := collection.Find(bson.M{}).All(&data)

		take := len(data)

		if request.Extras["take"] != nil {
			take, _ = strconv.Atoi(request.Extras["take"].(string))
		}

		skip := 0

		if request.Extras["skip"] != nil {
			skip, _ = strconv.Atoi(request.Extras["skip"].(string))
		}

		for index, _ := range data {
			if request.Controls.SendMetaData == "false" {
				delete(data[index], "__osHeaders")
			}
			delete(data[index], "_id")
		}

		byteValue, errMarshal := json.Marshal(data[skip:(skip + take)])

		if errMarshal != nil {
			response.IsSuccess = false
			response.GetErrorResponse("Error getting values for all objects in mongo" + err.Error())
		} else {
			response.IsSuccess = true
			response.GetResponseWithBody(byteValue)
			response.Message = "Successfully retrieved values for all objects in mongo"
			request.Log(response.Message)
		}

	}
	return response
}
Ejemplo n.º 24
0
func (repository RedisRepository) GetByKey(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting GET-BY-KEY")
	response := RepositoryResponse{}
	client, isError, errorMessage := getRedisConnection(request)

	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		key := getNoSqlKey(request)
		value, err := client.Get(key)

		var tempMap map[string]interface{}
		tempMap = make(map[string]interface{})
		err = json.Unmarshal(value, &tempMap)
		if err != nil {
			request.Log("Error converting Json to Map : " + err.Error())
		} else {
			if request.Controls.SendMetaData == "false" {
				delete(tempMap, "__osHeaders")
			}
		}

		byteValue, _ := json.Marshal(tempMap)

		if err != nil {
			response.IsSuccess = false
			request.Log("Error getting value by key for object in Redis : " + key + ", " + err.Error())
			response.GetErrorResponse("Error getting value by key for one object in Redis" + err.Error())
		}
		if err != nil {
			response.IsSuccess = false
			request.Log("Error getting value by key for object in Redis : " + key + ", " + err.Error())
			response.GetErrorResponse("Error getting value by key for one object in Redis" + err.Error())
		} else {
			response.IsSuccess = true
			response.GetResponseWithBody(byteValue)
			response.Message = "Successfully retrieved one object in Redis"
			request.Log(response.Message)
		}

	}
	return response
}
Ejemplo n.º 25
0
func (repository MongoRepository) InsertMultiple(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting INSERT-MULTIPLE")
	response := RepositoryResponse{}
	collection, isError, errorMessage := getMongoConnection(request)
	var idData map[string]interface{}
	idData = make(map[string]interface{})
	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {
		isError = false
		if isError == true {
			response.IsSuccess = false
			request.Log("Error inserting multiple objects in Mongo : " + errorMessage)
			response.GetErrorResponse("Error inserting multiple objects in Mongo" + errorMessage)
		} else {
			response.IsSuccess = true
			response.Message = "Successfully inserted multiple objects in Mongo"
			request.Log(response.Message)
		}

		for i := 0; i < len(request.Body.Objects); i++ {
			key := getMongoDBRecordID(request, request.Body.Objects[i])

			if key == "" {
				continue
			}

			request.Body.Objects[i]["_id"] = request.Controls.Namespace + "." + request.Controls.Class + "." + key
			request.Body.Objects[i][request.Body.Parameters.KeyProperty] = key
			idData[strconv.Itoa(i)] = key

			err := collection.Insert(bson.M(request.Body.Objects[i]))

			if err != nil {
				response.IsSuccess = false
				response.GetErrorResponse("Error inserting many object in mongo" + err.Error())
			} else {
				response.IsSuccess = true
				response.Message = "Successfully inserted many object in Mongo"
				request.Log(response.Message)
			}
		}

	}
	var DataMap []map[string]interface{}
	DataMap = make([]map[string]interface{}, 1)
	var actualInput map[string]interface{}
	actualInput = make(map[string]interface{})
	actualInput["ID"] = idData
	DataMap[0] = actualInput
	response.Data = DataMap
	return response
}
Ejemplo n.º 26
0
func executeCouchbaseGetClasses(request *messaging.ObjectRequest) (returnByte []byte) {

	bucket, _, isError := getCouchBucket(request)

	if isError == true {
		returnByte = nil
	} else {
		//Get Classes Details
		key := request.Controls.Namespace + "#DomainClasses"
		rawBytes, err := bucket.GetRaw(key)
		if err != nil {
			request.Log("Error connection reset. Try again!")
			returnByte = nil
		} else {
			returnByte = rawBytes
		}
	}
	return
}
Ejemplo n.º 27
0
func (repository RedisRepository) DeleteMultiple(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting DELETE-MULTIPLE")
	response := RepositoryResponse{}
	client, isError, errorMessage := getRedisConnection(request)

	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {

		isError := false

		for _, object := range request.Body.Objects {
			key := getNoSqlKeyById(request, object)
			reply, err := client.ExecuteCommand("DEL", key)
			err2 := reply.OKValue()
			if err != nil {
				isError = true
				errorMessage = err.Error()
				response.IsSuccess = false
				request.Log("Error deleting object in Redis!" + err2.Error())
				response.GetErrorResponse("Error deleting object in Redis!" + err2.Error())
				break
			} else {
				response.IsSuccess = true
				response.Message = "Successfully deleted multiple objects in Redis"
				request.Log("Successfully deleted all objects in Redis!")
			}
		}

		if isError == true {
			response.IsSuccess = false
			request.Log("Error deleting multiple objects in Redis : " + errorMessage)
			response.GetErrorResponse("Error deleting multiple objects in Redis" + errorMessage)
		} else {
			response.IsSuccess = true
			response.Message = "Successfully deleted multiple objects in Redis"
			request.Log(response.Message)
		}
	}

	return response
}
Ejemplo n.º 28
0
func getCassandraConnection(request *messaging.ObjectRequest) (session *gocql.Session, isError bool, errorMessage string) {
	keyspace := getSQLnamespace(request)
	isError = false
	cluster := gocql.NewCluster(request.Configuration.ServerConfiguration["CASSANDRA"]["Url"])
	cluster.Keyspace = keyspace
	request.Log("Cassandra URL : " + request.Configuration.ServerConfiguration["CASSANDRA"]["Url"])
	request.Log("KeySpace : " + keyspace)

	session, err := cluster.CreateSession()
	if err != nil {
		isError = false
		errorMessage = err.Error()
		request.Log("Cassandra connection initilizing failed!")
		session, _ = createNewCassandraKeyspace(request)
	} else {
		request.Log("Cassandra connection initilizing success!")
	}
	//defer session.Close()
	request.Log("Reusing existing Cassandra connection")
	return
}
Ejemplo n.º 29
0
func executeCassandraGetNamespaces(request *messaging.ObjectRequest) (returnByte []byte) {
	session, isError, _ := getCassandraConnection(request)
	if isError == true {
		request.Log("Cassandra connection failed")
		returnByte = nil
	} else {
		isError = false

		iter2 := session.Query("select keyspace_name from system.schema_keyspaces").Iter()

		my, _ := iter2.SliceMap()

		iter2.Close()

		var fields []string
		fields = make([]string, len(my))

		for key, value := range my {
			for _, fieldname := range value {
				fields[key] = fieldname.(string)
			}
		}

		byteValue, errMarshal := json.Marshal(fields)
		if errMarshal != nil {
			request.Log("Error getting values for all objects in Cassandra")
			returnByte = []byte("Error JSON marshalling to BYTE array")
		} else {
			request.Log("Successfully retrieved values for all objects in Cassandra")
			returnByte = byteValue
		}

	}
	return
}
Ejemplo n.º 30
0
func (repository CassandraRepository) DeleteMultiple(request *messaging.ObjectRequest) RepositoryResponse {
	request.Log("Starting DELETE-MULTIPLE")
	response := RepositoryResponse{}
	session, isError, errorMessage := getCassandraConnection(request)

	if isError == true {
		response.GetErrorResponse(errorMessage)
	} else {

		for _, obj := range request.Body.Objects {

			err := session.Query("DELETE FROM " + request.Controls.Class + " WHERE " + request.Body.Parameters.KeyProperty + " = '" + obj[request.Body.Parameters.KeyProperty].(string) + "'").Exec()
			if err != nil {
				response.IsSuccess = false
				request.Log("Error deleting object in Cassandra  : " + err.Error())
				response.GetErrorResponse("Error deleting one object in Cassandra because no match was found!" + err.Error())
			} else {
				response.IsSuccess = true
				response.Message = "Successfully deleted one object in Cassandra"
				request.Log(response.Message)
			}
		}
	}

	return response
}