mega-dtbs - npm Package Compare versions

Comparing version 0.1.10 to 0.1.11

index.js

@@ -438,5 +438,308 @@
 
+    },
+    //esta funcion te permite ordenar valores, tambien de permite actualizar propiedades especificas usando el .
+    this.ordenar = function(key_value, type_value) {
+      if(!key_value && key_value != false) throw new TypeError("Clave no especificada.")
+      if(key_value != false && typeof key_value != "string") throw new TypeError("Formato invalido, la clave debes de ser un string (cadena de texto) o false en caso de que no busques propiedades.")
+      if (!type_value && type_value != false && type_value != 0) throw new TypeError("Valor no especificado.")
+
+
+      return new Promise((resolve, reject) => {
+
+        if(key_value == false) {
+          //si la clave es false        
+          if(type_value == false) {
+            //si el valor es false y no es un objeto
+            let final_array = []
+            for(var key in this.value) {
+              if(typeof this.value[key] != "number") reject("Los valores no son numeros.")
+              final_array.push({clave: key, valor: this.value[key]})
+            }
+            final_array.sort(function (a,b) {
+              return b.valor - a.valor
+            })
+            resolve(final_array)
+          }
+          else{
+            //si el valor no es false y es un objeto
+            if(typeof type_value != "string") throw new TypeError("Formato invalido, el valor debe ser un string (cadena de texto) o false en caso de que no busques propiedades.")
+            if(type_value.includes(".")) {
+              //si el valor incluye propiedades
+              let properties = type_value.split(".")
+              if(properties.some(r => r.length <= 0)) throw new TypeError("Formato invalido, asegurate de no poner espacios en blanco en la clave, tampoco usar dos puntos uno seguido de otro.")
+
+              let final_array = []
+              for(var key1 in this.value) {
+
+                let lastobject = this.value[key1]
+
+                for(var x = 0; x < properties.length; x++) {
+                  let index = properties[x]
+                  if(lastobject[index] != null) {
+                    if(x === properties.length - 1) {
+                      if(typeof lastobject[index] != "number") reject("Los valores no son numeros.")
+                      final_array.push({clave: key1, valor: lastobject})
+                    }
+      
+                    lastobject = lastobject[index]
+      
+                  }
+                  else{
+                    reject(null)
+                  }
+                }
+              }
+              
+              final_array.sort(function (a,b) {
+                return b.valor[properties[properties.length - 1]] - a.valor[properties[properties.length - 1]]
+              })
+              resolve(final_array)
+
+            }
+            else{
+              //si el valor no incluye propiedades
+              let final_array = []
+              for(var key in this.value) {
+                if(typeof this.value[key][type_value] != null) {
+                  if(typeof this.value[key][type_value] != "number") reject("Los valores no son numeros.")
+                  final_array.push({clave: key, valor: this.value[key]})
+                }
+                else{
+                  reject(null)
+                }
+              }
+
+              final_array.sort(function (a,b) {
+                return b.valor[type_value] - a.valor[type_value]
+              })
+              resolve(final_array)
+            }
+          }
+        }
+        else{ 
+          //si la clave no es false
+          if(type_value == false) {
+            //si el valor es false
+            if(key_value.includes(".")) {
+              //si la clave contiene propiedades
+
+              let properties = key_value.split(".")
+              if(properties.some(r => r.length <= 0)) throw new TypeError("Formato invalido, asegurate de no poner espacios en blanco en la clave, tampoco usar dos puntos uno seguido de otro.")
+
+              let final_array = []
+              let lastobject = this.value
+
+              for(var x = 0; x < properties.length; x++) {
+                let index = properties[x]
+                if(lastobject[index] != null) {
+                  lastobject = lastobject[index]
+                  if(x === properties.length - 1) {
+                    for(var key in lastobject) {
+                      
+                      if(lastobject[key] != null) {
+                        if(typeof lastobject[key] != "number") reject("Los valores no son numeros.")
+                        final_array.push({clave: key, valor: lastobject[key]})
+                      }
+                      else{
+                        reject(null)
+                      }
+                    }
+                  }     
+                }
+                else{
+                  reject(null)
+                }
+              }
+
+              final_array.sort(function (a,b) {
+                return b.valor - a.valor
+              })
+              resolve(final_array)
+            }
+            else{
+              //si la clave no contiene propiedades
+              let final_array = []
+              let lastobject = this.value[key_value]
+              for(var key in lastobject) {
+                if(lastobject[key] != null) {
+                  if(typeof lastobject[key] != "number") reject("Los valores no son numeros.")
+                  final_array.push({clave: key, valor: lastobject[key]})
+                }
+                else{
+                  reject(null)
+                }
+              }
+
+              final_array.sort(function (a,b) {
+                return b.valor - a.valor
+              })
+              resolve(final_array)
+            }
+          }
+          else{
+
+            if(typeof type_value != "string") throw new TypeError("Formato invalido, la clave debe ser un string (cadena de texto) o false en caso de que no busques propiedades.")
+            if(key_value.includes(".")) {
+              //si la clave incluye propiedades
+              let properties = key_value.split(".")
+              if(properties.some(r => r.length <= 0)) throw new TypeError("Formato invalido, asegurate de no poner espacios en blanco en la clave, tampoco usar dos puntos uno seguido de otro.")
+              
+              if(type_value.includes(".")) {
+                let final_array = []
+
+                //si el valor incluye propiedades
+                let valuerties = type_value.split(".")
+                if(valuerties.some(r => r.length <= 0)) throw new TypeError("Formato invalido, asegurate de no poner espacios en blanco en la clave, tampoco usar dos puntos uno seguido de otro.")
+
+                let lastobject = this.value
+                
+                for(var x = 0; x < properties.length; x++) {
+                  let index = properties[x]
+                  if(lastobject[index] != null) {
+                    if(x === properties.length - 1) {
+                      lastobject = lastobject[index]
+                      for(var key in lastobject) {
+
+                        let propobject = lastobject[key]
+                        for(var y = 0; y < valuerties.length; y++) {
+                          let index_2 = valuerties[y]
+                          if(propobject[index_2] != null) {
+
+                            if(y === valuerties.length - 1) {
+                              
+                              if(typeof propobject[index_2] != "number") reject("Los valores no son numeros.")
+                              final_array.push({clave: key, valor: propobject})
+                            }
+
+                            propobject = propobject[index_2]
+    
+                          }
+                          else{
+                            reject(null)
+                          }    
+                        }
+                      }
+                    }
+        
+                    lastobject = lastobject[index]
+        
+                  }
+                  else{
+                      reject(null)
+                  }
+                }
+
+                final_array.sort(function (a,b) {
+                  return b.valor[valuerties[valuerties.length - 1]] - a.valor[valuerties[valuerties.length - 1]]
+                })
+                resolve(final_array)
+              }
+              else{
+                //Si el valor no incluye propiedades
+                let final_array = []
+
+                let lastobject = this.value
+                for(var x = 0; x < properties.length; x++) {
+                  let index = properties[x]
+                  if(lastobject[index] != null) {
+                    lastobject = lastobject[index]
+                    if(x === properties.length - 1) {                    
+                      for(key in lastobject) {
+
+                        if(lastobject[key][type_value] != null) {
+                          if(typeof lastobject[key][type_value] != "number") reject("Los valores no son numeros.")
+                          final_array.push({clave: key, valor: lastobject[key]})
+                        }
+                        else{
+                          reject(null)
+                        }
+                      }
+                    }                      
+                  }
+                  else{
+                    reject(null)
+                  }
+                }
+
+                final_array.sort(function (a,b) {
+                  return b.valor[type_value] - a.valor[type_value]
+                })
+                resolve(final_array)
+              }
+            }
+            else{
+              //si la clave no incluye propiedades
+              if(type_value.includes(".")){
+                //si el valor incluye propiedades
+                let final_array = []
+                let valuerties = type_value.split(".")
+                if(valuerties.some(r => r.length <= 0)) throw new TypeError("Formato invalido, asegurate de no poner espacios en blanco en la clave, tampoco usar dos puntos uno seguido de otro.")
+
+                if(this.value[key_value] != null) {
+                  let lastobject = this.value[key_value]
+                  for(var key in lastobject) {
+
+                    let propobject = lastobject[key]
+
+                    for(var x = 0; x < valuerties.length; x++) {
+                      let index = valuerties[x]
+                      if(propobject[index] != null) {
+                
+                        if(x === valuerties.length - 1) {
+                          if(typeof propobject[index] != "number") reject("Los valores no son numeros.")
+                          final_array.push({clave: key, valor: propobject})                                    
+                        }
+
+                        propobject = propobject[index]
+
+                      }
+                      else{
+                        reject(null)
+                      }
+                    }
+                  }
+                }
+                else{
+                  reject(null)
+                }
+
+                final_array.sort(function (a,b) {
+                  return b.valor[valuerties[valuerties.length - 1]] - a.valor[valuerties[valuerties.length - 1]]
+                })
+                resolve(final_array)
+
+              }
+              else{
+                //si el valor no incluye propiedades
+                let final_array = []
+                if(this.value[key_value] != null) {
+                  let lastobject = this.value[key_value]
+                  for(var key in lastobject) {
+                    if(lastobject[key][type_value] != null) {
+                      if(typeof lastobject[key][type_value] != "number") reject("Los valores no son numeros.")
+                      final_array.push({clave: key, valor: lastobject[key]})
+                    }
+                    else{
+                      reject(null)
+                    }
+                  }
+                }
+                else{
+                  reject(null)
+                }
+
+                final_array.sort(function (a,b) {
+                  return b.valor[type_value] - a.valor[type_value]
+                })
+
+                resolve(final_array)
+
+              }
+            }         
+          }
+        }
+      });
     }
+  }
+}
 
-  }
- }

package.json

 {
   "name": "mega-dtbs",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "simple database",
@@ -5,0 +5,0 @@ "main": "index.js",

README.md

@@ -22,2 +22,3 @@ ```
 - restar
+- ordenar
 
@@ -181,2 +182,68 @@ ## Instalacion:
 
+### ordenar(clave, valor)
+```
+Esta funcion te permite ordenar los valores de una clave de forma descendente.
+Tambien te permite ordenar valores tomando como punto referencial una propiedad especifica usando el . seguido del nombre de la propiedad.
+Clave y valor reciben dos tipos de valores, un string (cadena de texto) y un booleano (false), el false lo podemos usar cuando se requiera ordenar valores que no sean propiedades de algun objeto  (independientemente de la clave), esto mismo tambien puede aplicarse a claves.
+Esto retornara una promesa con un array mostrando los datos ordenados, si la ruta que especificaste no existe, retornara null y si los valores que se ordenaran no son numeros, retornara "Los valores no son numeros."
+```
+
+```js
+//ejemplo_1
+
+let economia_db = new db.crearDB('economia')
+economia_db.agregar('MegaStar', 100) //retorna 100
+economia_db.agregar('MoDeR', 40) //retorna 40
+economia_db.agregar('ratsagem', 320) //retorna 320
+
+economia_db.ordenar(false, false) //retorna [{clave: 'ratsagem', valor: 320}, {clave: 'MegaStar', valor: 100}, {clave: 'MoDeR', valor: 40}]
+
+//ejemplo_2
+
+let economia_db = new db.crearDB('economia')
+economia_db.agregar('MegaStar', {monedas: 100}) //retorna {monedas: 100}
+economia_db.agregar('MoDeR', {monedas: 40)} //retorna {monedas: 40)
+economia_db.agregar('ratsagem', {monedas: 320)} //retorna {monedas: 320)
+
+economia_db.ordenar(false, "monedas") //retorna [{clave: 'ratsagem', valor: {monedas: 320)}, {clave: 'MegaStar', valor: {monedas: 100}}, {clave: 'MoDeR', valor: {monedas: 40)}]
+
+//ejemplo_3
+
+let economia_db = new db.crearDB('economia')
+
+let usuarios = {
+  megastar: {monedas: 10, medallas: 15},
+  moder: {monedas: 50, medallas: 20},
+  ratsagem: {monedas: 25, medallas: 5}
+}
+economia_db.agregar('servidor.datos', usuarios) 
+//esto retorna:
+{
+  'datos': {
+    'megastar': {
+      'monedas': 10,
+      'medallas': 15
+    },
+    'moder': {
+      'monedas': 50,
+      'medallas': 20
+    },
+    'ratsagem': {
+      'monedas': 25,
+      'medallas': 5
+    }
+  }
+}
+
+
+economia_db.ordenar('servidor.datos', "medallas") //lo ordenaremos por el numero de medallas
+//esto retorna
+[
+  {clave: 'moder', valor: {monedas: 50, medallas: 20}},
+  {clave: 'MegaStar', valor: {monedas: 10, medallas: 15}},
+  {clave: 'ratsagem', valor: {monedas: 25, medallas: 5}}
+]
+
+```
+
 ## Ejemplo usando algunas funciones:
@@ -264,2 +331,31 @@ ```js
 }
+
+/////////////////////////////////////////////////////
+
+
+const db = require('mega-dtbs');
+let economia_db = new db.crearDB('economia')
+
+let usuarios = {
+  megastar: {monedas: 10, medallas: 15},
+  moder: {monedas: 50, medallas: 20},
+  ratsagem: {monedas: 25, medallas: 5}
+}
+
+economia_db.agregar('servidor.datos', usuarios) 
+
+economia_db.ordenar('servidor.datos', "monedas").then(nuevos => {
+  let ranking = []
+  for(var x = 0; x < nuevos.length; x++) {
+    ranking.push(`rank #${parseInt(x+1)} | usuario: ${nuevos[x].clave} | monedas: ${nuevos[x].valor.monedas} | medallas: ${nuevos[x].valor.medallas}\n`)
+  }
+})
+
+
+/*resultado:
+rank #1 | usuario: moder | monedas: 50 | medallas: 20
+rank #2 | usuario: ratsagem | monedas: 25 | medallas: 5
+rank #3 | usuario: megastar | monedas: 10 | medallas: 20
+*/
+
 ```

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

42755

increased by57.67%

Lines of code

649

increased by66.41%

Number of lines in readme file

359

increased by36.5%

No dependency changes