def update(user_id=None,
email=None,
lan=None,
language=None,
image=None,
password=None,
status=None,
unset=None,
pull=None,
addToSet=None,
user=None):
"""
Update one or more users
"""
user_id = ensure_objectid(user_id)
if user_id is None:
return False
if user:
db.users.update({"_id": user_id}, user)
return True
if pull:
db.users.update({"_id": user_id}, {"$pull": pull })
return True
if addToSet:
db.users.update({"_id": user_id}, {"$addToSet": addToSet })
return True
# First, builds the filter conditions list
dict_set = {}
local = locals()
for item in ["email",
"lan",
"language",
"image",
"password",
"status"]:
if not local[item] is None:
dict_set[item] = local[item]
if not unset is None:
dict_unset = {}
for item in unset:
dict_unset[item] = 1
if is_iterable(user_id):
for _id in user_id:
if ensure_objectid(_id):
if unset:
db.users.update({"_id": _id}, {"$unset": dict_unset}, False)
db.users.update({"_id": _id}, {"$set": dict_set})
else:
if unset:
db.users.update({"_id": user_id}, {"$unset": dict_unset}, False)
db.users.update({"_id": user_id}, {"$set": dict_set})
db.users.ensure_index('username')
return True
def update(user_id=None,
email=None,
lan=None,
language=None,
image=None,
password=None,
status=None,
unset=None,
pull=None,
addToSet=None,
user=None):
"""
Update one or more users
"""
user_id = ensure_objectid(user_id)
if user_id is None:
return False
if user:
db.users.update({"_id": user_id}, user)
return True
if pull:
db.users.update({"_id": user_id}, {"$pull": pull})
return True
if addToSet:
db.users.update({"_id": user_id}, {"$addToSet": addToSet})
return True
# First, builds the filter conditions list
dict_set = {}
local = locals()
for item in ["email", "lan", "language", "image", "password", "status"]:
if not local[item] is None:
dict_set[item] = local[item]
if not unset is None:
dict_unset = {}
for item in unset:
dict_unset[item] = 1
if is_iterable(user_id):
for _id in user_id:
if ensure_objectid(_id):
if unset:
db.users.update({"_id": _id}, {"$unset": dict_unset},
False)
db.users.update({"_id": _id}, {"$set": dict_set})
else:
if unset:
db.users.update({"_id": user_id}, {"$unset": dict_unset}, False)
db.users.update({"_id": user_id}, {"$set": dict_set})
db.users.ensure_index('username')
return True
def update(rank_id=None, name=None, rank=None):
""" """
error_code = None
if ensure_objectid(rank_id) is None:
error_code = ('rank_msg', 'error_0')
elif name is None or len(name) == 0:
error_code = ('rank_msg', 'error_1')
elif rank is None:
error_code = ('rank_msg', 'error_2')
elif check.is_integer(rank) == False:
error_code = ('rank_msg', 'error_3')
else:
rank = int(rank)
result = model.ranks.update(rank_id=rank_id, name=name, rank=rank)
if result:
data = {
"success": True,
}
return data
error_code = ('rank_msg', 'error_4')
data = {
"success": False,
"errors": [{
"code": error_code
}]
}
return data
def update(page_id=None, page=None):
"""
"""
if page_id is None:
return False
if page:
db.pages.update({'_id': ensure_objectid(page_id)}, page)
return page_id
def remove(page_id=None):
"""
"""
if page_id is None:
return False
else:
db.pages.remove({'_id': ensure_objectid(page_id)})
return True
def remove(page_id=None):
"""
"""
if page_id is None:
return False
else:
db.pages.remove({'_id' : ensure_objectid(page_id)})
return True
def update(page_id=None, page=None):
"""
"""
if page_id is None:
return False
if page:
db.pages.update({'_id': ensure_objectid(page_id)}, page)
return page_id
def update(language_id=None, value=None, check=None):
"""
"""
if language_id is None:
return False
dict_set = {}
if value:
dict_set["value"] = value
if check:
dict_set["check"] = check
set_language = {'$set': dict_set}
db.languages.update({'_id': ensure_objectid(language_id)}, set_language)
return language_id
def update(rank_id=None, name=None, rank=None):
"""
"""
if rank_id is None:
return False
dict_set = {}
if name:
dict_set["name"] = name
if rank:
dict_set["rank"] = rank
set_rank = {'$set': dict_set}
db.ranks.update({'_id': ensure_objectid(rank_id)}, set_rank)
return rank_id
def get(page_id=None):
""" """
if page_id is None:
errors = [{ "message": "Page id required" }]
elif not ensure_objectid(page_id):
errors = [{ "message": "Bad page id" }]
else:
page = model.pages.find(page_id=page_id)
if page:
return dict(success=True, page=page)
else:
errors = [{ "message": "Bad page id" }]
return dict(success=False, errors=errors)
def update(language_id=None, value=None, check=None):
"""
"""
if language_id is None:
return False
dict_set = {}
if value:
dict_set["value"] = value
if check:
dict_set["check"] = check
set_language = {"$set": dict_set}
db.languages.update({"_id": ensure_objectid(language_id)}, set_language)
return language_id
def remove(rank_id=None, my_rank=None):
"""
"""
if my_rank is None or my_rank > 10:
return False
if rank_id is None:
return False
else:
rank = model.ranks.find(rank_id=rank_id, expand_number=True)
if rank is None:
return False
if rank["number_user"] != 0:
return False
db.ranks.remove({'_id': ensure_objectid(rank_id)})
return True
def get(user_id=None, my_rank=None, my_id=None):
"""
By passing a user id, return an object with the user info.
That object could be different in base of different rank permission.
:param user_id: user id
:returns: an object with all the user information
"""
if user_id is None:
errors = [{"message": "User id required"}]
elif not ensure_objectid(user_id):
errors = [{"message": "Bad user id"}]
else:
user = model.users.find(user_id=user_id, my_rank=my_rank, my_id=my_id)
if user:
return dict(success=True, user=user)
else:
errors = [{"message": "Bad user id"}]
return dict(success=False, errors=errors)
def get(user_id=None, my_rank=None, my_id=None):
"""
By passing a user id, return an object with the user info.
That object could be different in base of different rank permission.
:param user_id: user id
:returns: an object with all the user information
"""
if user_id is None:
errors = [{"message": "User id required"}]
elif not ensure_objectid(user_id):
errors = [{"message": "Bad user id"}]
else:
user = model.users.find(user_id=user_id, my_rank=my_rank, my_id=my_id)
if user:
return dict(success=True, user=user)
else:
errors = [{"message": "Bad user id"}]
return dict(success=False, errors=errors)
def update(rank_id=None, name=None, rank=None):
""" """
error_code = None
if ensure_objectid(rank_id) is None:
error_code = ('rank_msg', 'error_0')
elif name is None or len(name) == 0:
error_code = ('rank_msg', 'error_1')
elif rank is None:
error_code = ('rank_msg', 'error_2')
elif check.is_integer(rank) == False:
error_code = ('rank_msg', 'error_3')
else:
rank = int(rank)
result = model.ranks.update(rank_id=rank_id, name=name, rank=rank)
if result:
data = {
"success": True,
}
return data
error_code = ('rank_msg', 'error_4')
data = {"success": False, "errors": [{"code": error_code}]}
return data
def find(page_id=None,
name=None,
url=None,
field=None,
field_value=None,
page_id_ne=None,
sorted_by=None,
sort_ascending=True,
limit=None,
only_one=False,
skip=None,
count=None):
""" """
conditions = []
if url:
conditions.append({'url': url})
if name:
conditions.append({'name': name})
if field:
conditions.append({field: field_value})
if page_id_ne:
conditions.append({'_id': { "$ne": ensure_objectid(page_id_ne) }})
return db_engine(collection=db.pages,
item_id=page_id,
conditions=conditions,
only_one=only_one,
sorted_by=sorted_by,
sort_ascending=sort_ascending,
limit=limit,
skip=skip,
count=count)
def find(page_id=None,
name=None,
url=None,
field=None,
field_value=None,
page_id_ne=None,
sorted_by=None,
sort_ascending=True,
limit=None,
only_one=False,
skip=None,
count=None):
""" """
conditions = []
if url:
conditions.append({'url': url})
if name:
conditions.append({'name': name})
if field:
conditions.append({field: field_value})
if page_id_ne:
conditions.append({'_id': {"$ne": ensure_objectid(page_id_ne)}})
return db_engine(collection=db.pages,
item_id=page_id,
conditions=conditions,
only_one=only_one,
sorted_by=sorted_by,
sort_ascending=sort_ascending,
limit=limit,
skip=skip,
count=count)
def db_engine(collection=None,
item_id=None,
only_one=False,
conditions=None,
sorted_by=None,
sort_lang=None,
sort_ascending=True,
skip=None,
limit=None,
count=None,
denormalize=denormalize):
"""
MongoDB Engine of Bombolone
There are several main steps that every model need it.
- Looking specifically for one or more items?
No further filtering needed!
- Looking for one user only or more
- Queries the collection conditions
- Sorts the filtered query results, if they're more than one
- The skip() expression allows to implementing "paging"
- Limit the maximum number of results to return.
For best performance, use limit() whenever possible.
Otherwise, the database may return more objects than are required for processing.
- Count the items
:return a number, when count is True
:return a dictionary, when only_one is True
:return a list, when only_one is False
"""
if item_id:
if is_iterable(item_id):
list_items = collection.find({"_id" : {"$in": [ensure_objectid(x) for x in item_id]}})
list_items = sort_if_you_must(list_items, only_one, sorted_by, sort_lang, sort_ascending)
return [ denormalize(item) for item in list_items]
else:
return denormalize(collection.find_one({"_id" : ensure_objectid(item_id)}))
if only_one:
f = collection.find_one
else:
f = collection.find
if conditions:
items = f({'$and': conditions})
else:
items = f()
items = sort_if_you_must(items, only_one, sorted_by, sort_lang, sort_ascending)
if skip:
items = items.skip(skip * limit)
if only_one == False and limit:
items = items.limit(limit)
if count:
return items.count()
if only_one:
return denormalize(items)
else:
list_items = list(items)
return [ denormalize(item) for item in list_items ]
def update(hash_table_id=None, hash_map=None):
""" """
db.hash_table.update({'_id': ensure_objectid(hash_table_id)}, hash_map)
def __request_second_block(self):
""" """
form = self.params
old_url = self.page['url']
self.page['url'] = {}
self.page['title'] = {}
self.page['description'] = {}
for i in range(10):
key = 'url_%s' % i
if key in self.page:
del(self.page[key])
self.page['url'] = form['url']
self.page['title'] = form['title']
self.page['description'] = form['description']
# Get URL, Title and Description in any languages
for code in self.languages:
self.page['url'][code] = self.page['url'].get(code, '')
self.page['title'][code] = self.page['url'].get(code, '')
self.page['description'][code] = self.page['url'].get(code, '')
if self.message is None:
error_in = ' ( ' + code + ' )'
# If the url is changed
if old_url.get(code) != self.page['url'][code]:
url_list = self.__get_url_list(code)
num_urls = len(url_list)
for code_two in self.languages:
field = "url_{}.{}".format(num_urls, code_two)
page_id = ensure_objectid(self.page["_id"]) if "_id" in self.page else None
available_url = model.pages.find(field=field,
field_value=url_list,
page_id_ne=page_id,
only_one=True)
print available_url
# Check that the url is a maximum of 200 characters
if not check.length(self.page['url'][code], 0, 200):
self.message = g.pages_msg('error_b_2') + error_in
# Verify that the format of the url is correct
elif len(self.page['url'][code]) and not check.url_two(self.page['url'][code]):
print 3, self.page['url'][code]
self.message = g.pages_msg('error_b_3') + error_in
# Raises an error message if url is not available.
elif not available_url is None:
name_page = available_url['name']
error_where = '{0} in the "{1}" page'.format(error_in, name_page)
self.message = g.pages_msg('error_b_4') + error_where
else:
url_list = self.__get_url_list(code)
num_urls = len(url_list)
if self.message is None:
kind_of_url = 'url_{}'.format(num_urls)
if not kind_of_url in self.page:
self.page[kind_of_url] = {}
self.page[kind_of_url][code] = url_list
def get_user(self, _id):
""" Get the user document from Database """
_id = ensure_objectid(_id)
self.user = model.users.find(user_id=_id, my_id=_id)
def remove(hash_table_id=None):
""" """
db.hash_table.remove({'_id': ensure_objectid(hash_map_id)})
def get_user(self, _id):
""" Get the user document from Database """
_id = ensure_objectid(_id)
self.user = model.users.find(user_id=_id, my_id=_id)
def update(hash_table_id=None, hash_map=None):
""" """
db.hash_table.update({ '_id' : ensure_objectid(hash_table_id)}, hash_map)
def remove(hash_table_id=None):
""" """
db.hash_table.remove({ '_id' : ensure_objectid(hash_map_id) })
def db_engine(collection=None,
item_id=None,
only_one=False,
conditions=None,
sorted_by=None,
sort_lang=None,
sort_ascending=True,
skip=None,
limit=None,
count=None,
denormalize=denormalize):
"""
MongoDB Engine of Bombolone
There are several main steps that every model need it.
- Looking specifically for one or more items?
No further filtering needed!
- Looking for one user only or more
- Queries the collection conditions
- Sorts the filtered query results, if they're more than one
- The skip() expression allows to implementing "paging"
- Limit the maximum number of results to return.
For best performance, use limit() whenever possible.
Otherwise, the database may return more objects than are required for processing.
- Count the items
:return a number, when count is True
:return a dictionary, when only_one is True
:return a list, when only_one is False
"""
if item_id:
if is_iterable(item_id):
list_items = collection.find(
{"_id": {
"$in": [ensure_objectid(x) for x in item_id]
}})
list_items = sort_if_you_must(list_items, only_one, sorted_by,
sort_lang, sort_ascending)
return [denormalize(item) for item in list_items]
else:
return denormalize(
collection.find_one({"_id": ensure_objectid(item_id)}))
if only_one:
f = collection.find_one
else:
f = collection.find
if conditions:
items = f({'$and': conditions})
else:
items = f()
items = sort_if_you_must(items, only_one, sorted_by, sort_lang,
sort_ascending)
if skip:
items = items.skip(skip * limit)
if only_one == False and limit:
items = items.limit(limit)
if count:
return items.count()
if only_one:
return denormalize(items)
else:
list_items = list(items)
return [denormalize(item) for item in list_items]
