Пример #1
0
    def setupDB(self):
        self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
        self.connection.drop_database(MONGO_DBNAME)
        if MONGO_USERNAME:
            self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
                                                   MONGO_PASSWORD)

        # seed
        result = self.connection[MONGO_DBNAME].people.\
            insert_one({
                'name': "John"
            })
        result = self.connection[MONGO_DBNAME].people.\
            insert_one({
                'name': "Peter",
                "relations": [
                    {
                        "relation_type": "family",
                        "relation": result.inserted_id,
                    }
                ],
                "rest_relations": [
                    {
                        "relation_type": "family",
                        "relation": result.inserted_id,
                    }
                ]
            })
Пример #2
0
def initialize_db(app):
    db = MongoClient().salt
    db.init_app(app)
    # print("================init db================")
    # print(mongo.salt)
    # print("==================\n")
    return db
Пример #3
0
def is_db_server_up(mongo_url):
    client = MongoClient(mongo_url, serverSelectionTimeoutMS=100)
    try:
        client.server_info()
        return True
    except ServerSelectionTimeoutError:
        return False
Пример #4
0
 def setupDB(self):
     self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
     self.connection.drop_database(MONGO_DBNAME)
     if MONGO_USERNAME:
         self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
                                                MONGO_PASSWORD)
     self.bulk_insert()
Пример #5
0
class ErpsyTest(unittest.TestCase):

    def setUp(self):
        self.app = create_app(config_name='testing')
        self.client = self.app.test_client
        self.part = {"name": "Polystyrene PWB",
                     "description": "DC Block Type Reference 22320f",
                     "part_number": "30758314"}

        self.mongo = MongoClient('localhost', 27017)
        db = self.mongo['test']
        self.collection = db['parts']
        self.collection.insert_one(self.part)

    def test_parts_response(self):
        res = self.client().get('/parts/')
        self.assertEqual(res.status_code, 200)

    def test_parts_format(self):
        res = self.client().get('/parts/')
        keys = set(json.loads(res.get_data(as_text=True))[
            0].keys())
        self.assertEqual(
            keys, set(['part_number', 'description', 'name']))

    def tearDown(self):
        self.collection.delete_many({})
        self.mongo.close()
Пример #6
0
def get_db_version(mongo_url):
    """
    Return the mongo db version
    :param mongo_url: Which mongo to check.
    :return: version as a tuple (e.g. `(u'4', u'0', u'8')`)
    """
    client = MongoClient(mongo_url, serverSelectionTimeoutMS=100)
    server_version = tuple(client.server_info()["version"].split("."))
    return server_version
Пример #7
0
    def setUp(self):
        self.app = create_app(config_name='testing')
        self.client = self.app.test_client
        self.part = {"name": "Polystyrene PWB",
                     "description": "DC Block Type Reference 22320f",
                     "part_number": "30758314"}

        self.mongo = MongoClient('localhost', 27017)
        db = self.mongo['test']
        self.collection = db['parts']
        self.collection.insert_one(self.part)
Пример #8
0
def addstate():
    try:
       card=random.randint(55555,99999)
       balance=random.randint(1000,8000)
       conn = MongoClient('localhost',27017)
       db = conn.admin
       collection = db.bankdetails
       status=collection.insert_one({"name":"stu","card no": card,"balance":balance})
       conn.close()
       return "successful"
    except:
       return "unsuccessful"
    def setUp(self):

        # setup a test client
        app.app.testing = True
        self.app = app.app.test_client()

        # configure access rights to the mongodb testdatabase
        app.app.config['MONGO_DBNAME'] = "testdatabase"
        app.app.config[
            "MONGO_URI"] = 'mongodb://*****:*****@ds237770.mlab.com:37770/testdatabase'

        # configure connection to the testdatabase
        app.client = MongoClient(
            'mongodb://*****:*****@ds237770.mlab.com:37770/testdatabase')
        app.db = app.client['testdatabase']

        app.db.drop_collection('customers')
        # create a test collection called 'customers'
        app.db.create_collection('customers')
        customers = app.db.get_collection('customers')

        # insert test customers
        customers.insert_one(
            insertCustomer('12345', 'Krueger', 'Freddy', 63, 2000, '9:30'))
        customers.insert_one(
            insertCustomer('56789', 'Vorhees', 'Jason', 45, 9000, '12:00'))
Пример #10
0
def mongo_login():
    email = request.form['email']
    password = request.form['password']
    print('email: %s, password: %s' % (email, password))
    try:
        client = MongoClient()
        db = client.test_db
        user = db.users.find_one({'email': email.lower()})
        if user and user['password'] == password:
            result = {
                'resultCode': '1',
                'email': user['email'],
                'name': user['name'],
                'surname': user['surname']
            }
        else:
            result = {
                'resultCode': '0',
            }

        print result
        return json.dumps(result)

    except Exception as e:
        return "error: %s" % (e)
Пример #11
0
def stats():
    '''
    Statistics page
    This page initially writes to a
    json file the entire collection, it then calls the
    actual page to be rendered.

    The ObjectID is excluded from this json file.
    '''
    title = "Statistics | RecipieDB"
    client = MongoClient()
    collection = mongo.db.recipies
    cursor = collection.find({}, {"_id": 0})
    file = open("static/data/collection.json", "w")
    file.write('[')

    qnt_cursor = 0
    for document in cursor:
        qnt_cursor += 1
        num_max = cursor.count()
        if (num_max == 1):
            file.write(json.dumps(document))
        elif (num_max >= 1 and qnt_cursor <= num_max - 1):
            file.write(json.dumps(document))
            file.write(',')
        elif (qnt_cursor == num_max):
            file.write(json.dumps(document))
    file.write(']')
    file.close()
    return render_template('stats.html', title=title)
Пример #12
0
    def open(self):
        try:
            self.client = MongoClient(MONGO_ADDR, MONGO_PORT)
            self.mongo = self.client[self.db_name]

        except pymongo.errors.ConnectionFailure, conn_exception:
            raise "Could not connect to MongoDB: {}".format(conn_exception)
Пример #13
0
    def delete_from_all_collections_by_user_id(self, db_name: str,
                                               user_id: str) -> dict:
        print('In Method: delete_by_user_id()')

        client = MongoClient(db_config.connection_string)
        db = client.get_database(db_name)

        try:
            collection_names = [
                collection for collection in db.collection_names()
                if not collection.startswith('system.')
            ]
            for collection_name in collection_names:
                db[collection_name].delete_many({'user_id': user_id})
        except Exception as e:
            print('Exception Thrown:')
            print(e)

            client.close()

            return {'success': False}

        client.close()

        return {'success': True}
Пример #14
0
def addstate():
    #try:
    #args = request.args
    #strng = base64.b64decode(args['val']).decode('utf-8')
    #obj = request.get_json()
    card = random.randint(55555, 99999)
    balance = random.randint(1000, 8000)
    conn = MongoClient('localhost', 27017)
    db = conn.admin
    collection = db.bankdetails
    status = collection.insert_one({
        "name": "stu",
        "card no": card,
        "balance": balance
    })
    conn.close()
    #print(obj)
    return "successful"
Пример #15
0
class TestMultiMongo(TestBase):
    def setUp(self):
        super(TestMultiMongo, self).setUp()

        self.setupDB2()

        schema = {
            'author': {
                'type': 'string'
            },
            'title': {
                'type': 'string'
            },
        }
        settings = {'schema': schema, 'mongo_prefix': 'MONGO1'}

        self.app.register_resource('works', settings)

    def tearDown(self):
        super(TestMultiMongo, self).tearDown()
        self.dropDB2()

    def setupDB2(self):
        self.connection = MongoClient()
        self.connection.drop_database(MONGO1_DBNAME)
        self.connection[MONGO1_DBNAME].add_user(MONGO1_USERNAME,
                                                MONGO1_PASSWORD)
        self.bulk_insert2()

    def dropDB2(self):
        self.connection = MongoClient()
        self.connection.drop_database(MONGO1_DBNAME)
        self.connection.close()

    def bulk_insert2(self):
        _db = self.connection[MONGO1_DBNAME]
        works = self.random_works(self.known_resource_count)
        _db.works.insert(works)
        self.work = _db.works.find_one()
        self.connection.close()

    def random_works(self, num):
        works = []
        for i in range(num):
            dt = datetime.now()
            work = {
                'author': self.random_string(20),
                'title': self.random_string(30),
                eve.LAST_UPDATED: dt,
                eve.DATE_CREATED: dt,
            }
            works.append(work)
        return works
Пример #16
0
 def get_product_by_id(product_id):
     """
     Method for finding product by id
     :param product_id:
     :return:
     """
     mongo = MongoClient(Config.MONGO_URI)
     if ObjectId().is_valid(product_id) is False:
         return bad_request(t['invalid_id'])
     db_operations = mongo.db.product
     product = db_operations.find_one_or_404({'_id': ObjectId(product_id)})
     response_product = Product().from_dict(product).to_dict()
     return jsonify(response_product)
Пример #17
0
def main(ip='*', ip_db='*'):
    global url, collection
    url = "tcp://{}:9002".format(ip)

    app.config['MONGO_DBNAME'] = 'users'
    app.config['MONGO_URI'] = 'mongodb://' + ip_db + ':27017/users'
    dbconnect = False
    while not dbconnect:
        conn = MongoClient('mongodb://' + ip_db + ':27017/',
                           serverSelectionTimeoutMS=5000,
                           connectTimeoutMS=200000)
        try:
            conn.server_info()  # force connection
            # Database
            db = conn.users
            # Created or Switched to collection names: my_gfg_collection
            collection = db.user_collection
            dbconnect = True
        except ServerSelectionTimeoutError as e:
            if DEBUG:
                print(e)
            print("Could not connect to MongoDB", flush=True)

    app.run(debug=True, host='0.0.0.0', port='5002')
Пример #18
0
def mongo_get_users():
    try:
        client = MongoClient()
        db = client.test_db
        users = db.users
        result = []
        for user in users.find():
            result.append({
                'email': user['email'],
                'password': user['password'],
                'name': user['name'],
                'surname': user['surname']
            })
        return json.dumps(result)
    except Exception as e:
        return "error: %s" % (e)
Пример #19
0
    def __init__(self, app):
        uri = (
            "mongodb://{user}:{password}@{host}:{port}/{db}?ssl=false").format(
                user=mongo_user,
                password=mongo_pass,
                host=mongo_host,
                port=mongo_port,
                db=mongo_dB)

        app.config["MONGO_URI"] = uri
        app.config["MONGO_DBNAME"] = "desafioluiza"

        mongo = PyMongo(app)
        client = MongoClient(uri)

        self.db = client.desafioluiza
Пример #20
0
def mongo_sign_up():
    try:
        email = request.form['email']
        password = request.form['password']
        name = request.form['name']
        surname = request.form['surname']
        client = MongoClient()
        db = client.test_db
        db.users.insert_one({
            "email": email.lower(),
            "password": password,
            "name": name,
            "surname": surname
        })
        return "gud"
    except Exception as e:
        return "error: %s" % (e)
Пример #21
0
 def get_products():
     """
     Method for get product list with pagination by params: dict and/or title: str
     :return:
     """
     mongo = MongoClient(Config.MONGO_URI)
     page = request.args.get('page', DEFAULT_PAGE, type=int)
     per_page = min(
         request.args.get('per_page', PER_PAGE_DEFAULT, type=int),
         PER_PAGE_MAX)
     db_operations = mongo.db.product
     data = {
         k: v
         for k, v in request.args.items() if k not in ['page', 'per_page']
     }
     query_data = Product.get_query_from_data(data)
     query = db_operations.find
     result = Product().to_collection_dict(query, query_data, page,
                                           per_page)
     return jsonify(result)
Пример #22
0
    def create_product():
        """
        Method for product creation by request
        :return:
        """
        mongo = MongoClient(Config.MONGO_URI)
        db_operations = mongo.db.product
        data = request.get_json(force=True) or {}
        if 'title' not in data or 'description' not in data or 'params' not in data:
            return bad_request(t['empty_field'])
        new_product = Product()
        if Product.params_is_valid(data):
            new_product.save_to_db(data, db_operations)

            response = jsonify(new_product.to_dict())
            response.status_code = 201
            response.headers['Location'] = url_for('api.get_product_by_id',
                                                   product_id=new_product._id)
            return response
        else:
            return bad_request(t['invalid_value'])
Пример #23
0
class TestBase(unittest.TestCase):
    def setUp(self, settings=None):
        self.this_directory = os.path.dirname(os.path.realpath(__file__))
        if settings is None:
            settings = os.path.join(self.this_directory, 'test_settings.py')

        self.setupDB()

        self.settings = settings
        self.app = eve.Eve(settings=self.settings)

        self.app.register_blueprint(eve_swagger.swagger)
        self.app.config['SWAGGER_INFO'] = {
            'title': 'Test eve-swagger',
            'version': '0.0.1'
        }

        self.test_client = self.app.test_client()
        self.domain = self.app.config['DOMAIN']

        self.swagger_doc = self.get_swagger_doc()

    def tearDown(self):
        del self.app
        self.dropDB()

    def setupDB(self):
        self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
        self.connection.drop_database(MONGO_DBNAME)
        if MONGO_USERNAME:
            self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
                                                   MONGO_PASSWORD)

    def dropDB(self):
        self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
        self.connection.drop_database(MONGO_DBNAME)
        self.connection.close()

    def get_swagger_doc(self):
        r = self.test_client.get('/api-docs')
        return self.parse_response(r)

    def parse_response(self, r):
        try:
            v = json.loads(r.get_data().decode('utf-8'))
        except ValueError:
            v = None
        return v
Пример #24
0
class settingsTestCase(TestMinimal):
	def setUp(self):
		return super().setUp(settings_file = './settings.py') 
	def dropDB(self):
		self.connection = MongoClient(MONGO_HOST,MONGO_PORT)
		self.connection.drop_database(MONGO_DBNAME)
		self.connection.close()
	def setupDB(self):
		self.connection = MongoClient(MONGO_HOST,MONGO_PORT)
		self.connection.drop_database(MONGO_DBNAME)
	def testGet(self):
		return_json,return_code = self.get(url)
		self.assert200(return_code)
	def testPost(self):
	 	return_json, return_code = self.post(url, {"cjv": 0.1231231})
	 	self.assertFalse(self.domain)
	 	self.assertFalse(return_json)
Пример #25
0
class TestBase(unittest.TestCase):
    def setUp(self, settings=None):
        self.this_directory = os.path.dirname(os.path.realpath(__file__))
        if settings is None:
            settings = os.path.join(self.this_directory, "test_settings.py")

        self.setupDB()

        self.settings = settings
        self.app = eve.Eve(settings=self.settings)

        self.app.register_blueprint(eve_swagger.swagger)
        self.app.config["SWAGGER_INFO"] = {"title": "Test eve-swagger", "version": "0.0.1"}

        self.test_client = self.app.test_client()
        self.domain = self.app.config["DOMAIN"]

        self.swagger_doc = self.get_swagger_doc()

    def tearDown(self):
        del self.app
        self.dropDB()

    def setupDB(self):
        self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
        self.connection.drop_database(MONGO_DBNAME)
        if MONGO_USERNAME:
            self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME, MONGO_PASSWORD)

    def dropDB(self):
        self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
        self.connection.drop_database(MONGO_DBNAME)
        self.connection.close()

    def get_swagger_doc(self):
        r = self.test_client.get("/api-docs")
        return self.parse_response(r)

    def parse_response(self, r):
        try:
            v = json.loads(r.get_data().decode("utf-8"))
        except ValueError:
            v = None
        return v
Пример #26
0
from flask import Flask
from flask import render_template
from flask_pymongo import PyMongo, MongoClient

import csv

#Defines the Flask app and the MongoDB parameters.
#Additionally, allows for connection to stanford path.
app = Flask(__name__)
app.config[
    "MONGO_URI"] = "mongodb+srv://scarlettexperiment-1pxrx.mongodb.net/test"
mongo = PyMongo(app)
app.config["CLIENT"] = MongoClient(
    "mongodb+srv://scarlettexperiment-1pxrx.mongodb.net/test",
    username="******",
    password="******",
    authSource="admin")
local_corenlp_path = r'/Users/Masayuki/stanford-corenlp-full-2018-10-05'


def poemAnalysis(poemObject):
    #https://stackoverflow.com/questions/32879532/stanford-nlp-for-python
    #Connect to the Stanford NLP server. Note that in order to run this code,
    #The Stanford NLP server must be run. The local_corenlp_path above must be
    #changed, and the instructions must be followed from the link above.
    nlp = StanfordCoreNLP('http://localhost:9000')
    #Set the analysis to be of sentiment.
    pros = {'annotators': 'sentiment', 'outputFormat': 'json'}
    poem = poemObject.get('poems')[0]
    res = nlp.annotate(poem, properties=pros)
Пример #27
0
def init(uri=None, db="trackeame"):
    app = Flask(__name__)
    app.config["MONGO_URI"] = os.environ.get("MONGOLAB_URI", uri)
    mongo = MongoClient(app.config["MONGO_URI"])
    app.mongo = mongo
    app.database = mongo[db]

    @app.route("/")
    def root_page():
        return render_template("index.html")

    @app.route("/api/users")
    def get_users():
        output = []
        users = app.database.users.find()
        for user in users:
            output.append({"name": user["name"], "lastname": user["lastname"], "sex": user["sex"]})
        return jsonify(output)

    @app.route("/api/users", methods=['POST'])
    def add_user():
        users = app.database.users
        name = request.json["name"]
        lastname = request.json["lastname"]
        sex = request.json["sex"]
        id = users.insert({"name": name, "lastname": lastname, "sex": sex})

        user = users.find_one({'_id': id})
        result = {"name": user["name"], "lastname": user["lastname"], "sex": user["sex"]}

        return jsonify(result)

    @app.route("/api/locations", methods=['DELETE'])
    def clear_locations():
        locations = app.database.locations

        try:
            locations.delete_many({})
        except KeyError:
            abort(403)

        result = {"ok": 1}

        return jsonify(result)

    @app.route("/api/locations", methods=['POST'])
    def add_locations():
        locations = app.database.locations

        cuadrantes = {"N": 1, "S":-1, "W":-1, "E": 1}

        try:
            posiciones = request.json["posiciones"]
            posiciones_parseadas = []
            ultima_posicion = None

            for posicion in posiciones.split("\n"):
                if posicion is not '':
                    nueva_posicion = {}
                    print(posicion)
                    try:
                        tipo, hora_gcm, validez, latitud, polo, longitud, hemisferio, dato1, dato2, fecha, dato3, dato4, dato5 = posicion.split(",")

                        if latitud is not '' and longitud is not '':
                            tiempo_hora = datetime( int(fecha[4:6]), int(fecha[2:4]), int(fecha[0:2]), int(hora_gcm[0:2]), int(hora_gcm[2:4]), int(hora_gcm[4:6]))

                            nueva_posicion["timestamp"] = datetime.timestamp(tiempo_hora)
                            nueva_posicion["latitud"] = (int(latitud[0:2]) + (float(latitud[2:9]) / 60)) * cuadrantes[polo]
                            nueva_posicion["longitud"] = (int(longitud[0:3]) + (float(longitud[3:10]) / 60)) * cuadrantes[hemisferio]
                            nueva_posicion["tiempo_de_parada"] = 0

                            if tipo == "$PARADA" and ultima_posicion is not None:
                                ultima_posicion["tiempo_de_parada"] = nueva_posicion["timestamp"] - ultima_posicion["timestamp"]

                            posiciones_parseadas.append(nueva_posicion)
                            ultima_posicion = nueva_posicion
                    except Exception:
                        pass

            if len(posiciones_parseadas) > 0:
                locations.insert_many(posiciones_parseadas)

        except KeyError:
            abort(403)

        resultado = {"ok": 1}

        return jsonify(resultado)

    @app.route("/api/locations")
    def get_locations():
        output = []
        locations = app.database.locations.find()
        for location in locations:
            output.append({"posicion": {
                "timestamp": location["timestamp"],
                "latitud": location["latitud"],
                "longitud": location["longitud"],
                "tiempoDeParada": location["tiempo_de_parada"]
            }})
        return jsonify(output)

    return app
Пример #28
0
from flask import Flask, jsonify, send_file, request, render_template
from flask_pymongo import MongoClient
from api.apiFunctions import getMonthlySleepDeclarations, getMonthlyNutritions, findUser, signIn, signUp, createNutrition, createSleepDeclaration, deleteNutrition, editSleepHours, updateUserInfo

app = Flask(__name__)

#DATABASE
client = MongoClient('mongodb+srv://redus:[email protected]/dnd?retryWrites=true&w=majority')
db = client['dnd']

#MODELS
User = db['users']
Nutirtion = db['nutritions']
SleepDeclaration = db['sleepDeclarations']

#FRONT END STUFF
@app.route('/nasafont')
def nasaFontMethod():
    return send_file('./font/nasalization-rg.woff')

@app.route('/homebackground')
def homeBackgroundMethod():
    return send_file('./images/background.png')

@app.route('/homemidground')
def homeMidgroundMethod():
    return send_file('./images/midground.png')

@app.route('/homeforeground')
def homeForegroundMethod():
    return send_file('./images/foreground.png')
Пример #29
0
ENVIRONMENT_DEBUG = os.environ.get("APP2_DEBUG", True)
ENVIRONMENT_PORT = os.environ.get("APP2_PORT", 8282)
REDIS_PORT = os.environ.get("REDIS_PORT", 6379)
REDIS_CHANNEL = os.environ.get("REDIS_CHANNEL", 'mongo')
REDIS_CHANNEL_NOTIFY = os.environ.get("REDIS_CHANNEL_NOTIFY", 'notify')

application = Flask(__name__)
"""
MongoDB setup
"""
# application.config["MONGO_URI"] = 'mongodb://' + os.environ['MONGODB_USERNAME'] + ':' + os.environ['MONGODB_PASSWORD'] + '@' + os.environ['MONGODB_HOSTNAME'] + ':27017/' + os.environ['MONGODB_DATABASE']
# mongo = PyMongo(application)
# db = mongo.db
client = MongoClient(host=os.environ['MONGODB_HOSTNAME'],
                     port=27017,
                     username=os.environ['MONGODB_USERNAME'],
                     password=os.environ['MONGODB_PASSWORD'],
                     authSource="admin")
db = client['flaskdb']
collection = db["data"]
"""
Redis setup
"""
redis = redis.StrictRedis(host="redis", port=REDIS_PORT, db=0)
pubsub = redis.pubsub(ignore_subscribe_messages=True)
channel = REDIS_CHANNEL
channel_notify = REDIS_CHANNEL_NOTIFY

global_json = None

Пример #30
0
"""Pull down music data"""
import datetime
import billboard
from flask_pymongo import MongoClient

FANTASY_LIFE_START_DATE = datetime.date(year=2016, month=8, day=1)

client = MongoClient()
db = client.fantasy

print("runnning")


def create_music_db():
    """Makes a new database for the nba"""
    players = db.players
    musicians = db.musicians
    musicians.drop()

    singers = ['Bruno Mars', 'Ed Sheeran', 'Kendrick Lamar', 'Future', 'Lil Uzi Vert',\
     'James Arthur', 'Julia Michaels', 'Imagine Dragons', 'Sam Hunt', 'Taylor Swift',\
     'Katy Perry', 'Justin Bieber']

    cursor = players.find()
    for singer, user in zip(singers, cursor):
        _ = musicians.insert({
            "associated_player_id": user['_id'],
            "artist": singer
        })

Пример #31
0
from flask import Flask, render_template, redirect ,request,url_for
from wtforms import StringField, BooleanField
from wtforms.validators import Length, InputRequired
from flask_wtf import FlaskForm
from bson import ObjectId
from flask_pymongo import MongoClient
from flask_bootstrap import Bootstrap

# creates a Flask application, named app
app = Flask(__name__)
Bootstrap(app)
#calling client
client = MongoClient('mongodb://127.0.0.1:27017')
#database name
db = client.mydatabase
todos = db.todo
# for securing our content
app.config['SECRET_KEY'] = 'this_is_a_secret'

class Todo(FlaskForm):
    title = StringField("Title", validators=[InputRequired(), Length(max=100)])
    done = BooleanField("Done")

    '''def validate_name(form, field):
        if len(field.data) > 50:
            raise ValidationError('Name must be less than 50 characters')
'''

'''todos = [
        {
            'Title': 'Do TOC Assignment',
Пример #32
0
 def dropDB(self):
     self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
     self.connection.drop_database(MONGO_DBNAME)
     self.connection.close()
Пример #33
0
 def setupDB(self):
     self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
     self.connection.drop_database(MONGO_DBNAME)
     if MONGO_USERNAME:
         self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME, MONGO_PASSWORD)