async def on_raw_reaction_remove(payload):
# ignore other channels and self
if payload.channel_id != botconfig['reactionChannelID'] or payload.user_id == bot.user.id:
return
# fetch
reactionMsg = await reactionChannel.fetch_message(payload.message_id)
# resolve emoji
reaction = payload.emoji.name
idx = regional_indicators.index(reaction)
# resolve role
em = reactionMsg.embeds[0]
data = urlToDict(em.description.splitlines()[0][4:-1])
roleId, categoryId = data[str(idx)]
role = reactionMsg.guild.get_role(roleId)
# resolve user
member = reactionMsg.guild.get_member(payload.user_id)
await member.remove_roles(role)
# update firestore
db.collection('user').document(str(payload.user_id)).set({
'courses': firestore.ArrayRemove([str(categoryId)])
}, merge=True)
def delete_workspace():
try:
if request.method == "POST":
workspace_info = request.json
userUID = workspace_info['uid']
workspaceId = workspace_info['workspaceId']
db = firestore.client()
#delete the entire workspace collection, if it exists
gallery_ref = db.collection(u'workspaces').document(
workspaceId).collection(u'galleryCards')
if len(list(gallery_ref.stream())) > 0:
delete_entire_collection(gallery_ref, 10)
#delete the entire stylesheets collection, if it exists
stylesheets_ref = db.collection(u'workspaces').document(
workspaceId).collection(u'stylesheets')
if len(list(stylesheets_ref.stream())) > 0:
delete_entire_collection(stylesheets_ref, 10)
# Delete workspace and reference under the user
db.collection(u'workspaces').document(workspaceId).delete()
user_ref = db.collection(u'users').document(userUID)
user_ref.update(
{u'workspaces': firestore.ArrayRemove([workspaceId])})
except Exception as ex:
print(str(ex))
print("something went wrong?")
return jsonify(success=False)
return jsonify(success=True)
async def delete_project_from_profile(email, project):
try:
project_data = db.collection("projects").document(project).get()
project_dict = project_data.to_dict()
users = project_dict["users"]
print("users")
if len(users) == 1:
folder = os.path.join(PROJECT_DIR, project)
print("folder")
if os.path.isfile(folder):
for filename in os.listdir(folder):
file_path = os.path.join(folder, filename)
try:
if os.path.isfile(file_path) or os.path.islink(
file_path):
os.unlink(file_path)
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
except Exception as e:
print('Failed to delete %s. Reason: %s' %
(file_path, e))
print("after deleting")
ref = db.collection("profiles").document(email)
ref.update({"projects": firestore.ArrayRemove([project])})
# TODO: delete in firestore with subcollections
return True
except:
return False
def moveFile(username, user_ref, current_folder_id, move_from_folder_id,
file_id):
file_ref = user_ref.collection('files').document(file_id)
move_from_folder_ref = user_ref.collection('folders').document(
move_from_folder_id)
current_folder_ref = user_ref.collection('folders').document(
current_folder_id)
file_data = file_ref.get().to_dict()
current_file_parent = file_data['parent']
file_name = file_data['name']
if current_file_parent == move_from_folder_id:
storage_current_file_name = username + '/' + current_file_parent + '/' + file_name
storage_new_file_name = username + '/' + current_folder_id + '/' + file_name
if duplicate_file_exists(file_name, current_folder_id, username):
return 1 #duplicate file exists in new folder. Cannot move file.
else:
move_from_folder_ref.update(
{'files': firestore.ArrayRemove([file_id])})
current_folder_ref.update(
{'files': firestore.ArrayUnion([file_id])})
file_ref.update({'parent': current_folder_id})
storage.rename_file(storage_current_file_name,
storage_new_file_name)
session.pop('movefrom', None)
session.pop('movefile', None)
else:
return 2 # move from and file parent do not match
def edit_exhibition():
museum_id = request.args.get('museum_id')
museum = getMuseumByID(museum_id)
exhibition_id = request.args.get('exhibition_id')
exhibition = getExhibitionByID(museum_id, exhibition_id)
museum_ref = db.collection(u'museums').document(museum_id)
form = ExhibitionForm()
if form.validate_on_submit():
#FIXME
if type(form.languages.data[0]) is not str:
languages = [str(x['language']) for x in form.languages.data]
museum_ref.update({u'exhibitions': firestore.ArrayRemove([exhibition.to_dict()])})
exhibition = Exhibition(
title = form.title.data,
description = form.description.data,
image_url = form.image_url.data,
languages = languages,
time = form.time.data,
type = form.type.data,
items = exhibition.items,
_id = exhibition_id
)
save_exhibition(museum_id, exhibition)
return redirect("/exhibitions?museum_id=" + museum_id)
return render_template('edit_exhibition.html', form=form, museum=museum, exhibition=exhibition)
def delete_exhibition():
museum_id = request.args.get('museum_id')
exhibition_id = request.args.get('exhibition_id')
museum_ref = db.collection(u'museums').document(museum_id)
exhibition = getExhibitionByID(museum_id, exhibition_id)
museum_ref.update({u'exhibitions': firestore.ArrayRemove([exhibition.to_dict()])})
return redirect("/exhibitions?museum_id=" + museum_id)
def tag_remove(self, instance, value):
# remove a tag from the 'tags' array field.
self.profilescreen.ids.tag_box.remove_widget(instance)
self.user['tags'].remove(value)
self.user_ref.update({u'tags': firestore.ArrayRemove([value])})
self.user_ref.update({u'timestamp': firestore.SERVER_TIMESTAMP})
toast(f"{value} removed")
def removeSelfAsManager(self, employee_uid: str) -> None:
self.document.update(
{"employees": firestore.ArrayRemove([employee_uid])})
self.database.document(employee_uid).update({
"manager_id": "",
"manager_email": "",
"manager_name": ""
})
async def delete_channel(project, dashboard, tile, channel):
try:
ref = db.collection("projects").document(project).collection(
"dashboards").document(dashboard).collection("tiles").document(
tile)
ref.update({"channels": firestore.ArrayRemove([channel])})
return True
except:
return False
def delete_friend(self,friend):
# Atomically add a new tag to the 'tags' array field. you can add multiple.
self.chatscreen.ids.friendlist.remove_widget(friend)
# remove a friend
self.user_ref.update({u'friends': firestore.ArrayRemove([friend.text])})
self.user_ref.update({
u'timestamp': firestore.SERVER_TIMESTAMP
})
def revokeRole():
"""
Remove a role from a specificed user. Level is also updated if it's affected by the removal of role
Returns:
Response of 200 for successfully removing role from DB
"""
data = request.get_json()['data']
email = data['email']
role_to_remove = data['role']
new_level = 0
user = auth.get_user_by_email(email)
current_custom_claims = user.custom_claims
try:
if current_custom_claims[role_to_remove] is True:
del current_custom_claims[role_to_remove]
all_keys = list(current_custom_claims.keys())
# Get map of roles to level from DB
doc_ref = db.collection(u'Roles').document(u'allRoles')
doc = doc_ref.get()
roles_map = doc.to_dict()['roles']
for key in all_keys:
if key != "accessLevel":
role_level = roles_map[key]
# if current level status is equal to one of user's existing roles' level
if role_level == current_custom_claims['accessLevel']:
auth.set_custom_user_claims(user.uid,
current_custom_claims)
return jsonify({"Message": "Complete"})
if role_level > new_level:
new_level = role_level
current_custom_claims['accessLevel'] = new_level
auth.set_custom_user_claims(user.uid, current_custom_claims)
# Map this new entry to roles_to_user
doc_ref.set(
{
u'roles_to_user': {
role_to_remove: firestore.ArrayRemove([email])
}
},
merge=True)
return jsonify({"Message": "Complete"}), 200
except ValueError:
return jsonify(
{'Error': 'Specified user ID or the custom claims are invalid'})
except:
return jsonify({'Error': 'User has no role to remove'})
def remove(chart):
form = StatsDD()
chart_ref = db.collection(current_user.brand).document(chart) # get the chart object
chart = chart_ref.get().to_dict() # get it as dictrp
stats = chart['stats']
form.stats.choices = stats
if form.is_submitted():
result = form.stats.data
chart_ref.update({'stats': firestore.ArrayRemove([result])})
return redirect(url_for('chart', chart_name=chart))
return render_template('remove.html', form=form)
def removeManagerForEmployee(self, manager_uid: str,
employee_uid: str) -> bool:
employees = set(self.managerData["employees"])
if manager_uid in employees and employee_uid in employees:
self.database.document(manager_uid).update(
{"employees": firestore.ArrayRemove([employee_uid])})
self.database.document(employee_uid).update({
"manager_id": "",
"manager_email": "",
"manager_name": ""
})
return True
else:
return False
def on_disable_notifications(update: Update, context, firestore):
code = update.callback_query.data.replace("disable_notif_", "")
doc = firestore.collection(u'lines').document(code)
doc.update({
u'user_subscriptions':
firestore_api.ArrayRemove([update.effective_chat.id])
})
update.callback_query.edit_message_reply_markup(
reply_markup=_get_enable_notifications_btn(code))
context.bot.answer_callback_query(update.callback_query.id,
text='Notifiche disabilitate')
def updateDetails():
Data = request.get_json(force=True)
doc_ref = db.collection('users').document(Data['uid'])
doc = doc_ref.get()
if doc.exists:
doc_ref.update(
{Data['fieldName']: firestore.ArrayRemove([Data['id']])})
else:
return jsonify({"Message": "Invalid user id"})
return jsonify({
"Message": "Data Updated successfully",
'status': 200
})
def deleteFolder(username, user_ref, current_folder_ref, folder_id):
folder_delete_ref = user_ref.collection('folders').document(folder_id)
folder_data = folder_delete_ref.get().to_dict()
folder_parent_id = folder_data['parent']
if not folder_parent_id == current_folder_ref.id:
return 2
if folder_empty(username, folder_id):
folder_delete_ref.delete()
current_folder_ref.update(
{'folders': firestore.ArrayRemove([folder_id])})
user_data = user_ref.get().to_dict()
totalFolders = int(user_data['folders']) - 1
user_ref.update({
'folders': totalFolders,
})
return 0
else:
return 1
def assignOtherManager(self, manager_uid: str, employee_uid: str) -> bool:
employees = set(self.managerData["employees"])
managerData = self.database.document(manager_uid).get().to_dict()
if (manager_uid in employees or manager_uid == self.uid):
self.document.update(
{"employees": firestore.ArrayRemove([employee_uid])})
self.database.document(manager_uid).update(
{"employees": firestore.ArrayUnion([employee_uid])})
self.database.document(employee_uid).update({
"manager_id":
managerData["user_id"],
"manager_email":
managerData["email"],
"manager_name":
managerData["name"]
})
return True
else:
return False
def deleteFile(username, user_ref, current_folder_ref, file_id):
#directory = directory.rstrip('/')
file_delete_ref = user_ref.collection('files').document(file_id)
file_data = file_delete_ref.get().to_dict()
file_parent_id = file_data['parent']
if not current_folder_ref.id == file_parent_id:
return 2
if user_logged_in() and session['username'] == username:
filename = username + '/' + file_parent_id + '/' + file_data['name']
storage.delete_blob(filename)
file_delete_ref.delete()
current_folder_ref.update({'files': firestore.ArrayRemove([file_id])})
user_data = user_ref.get().to_dict()
totalFiles = int(user_data['files']) - 1
totalStorageUsed = int(
user_data['total_storage_used']) - file_data['size']
user_ref.update({
'files': totalFiles,
'total_storage_used': totalStorageUsed,
})
return 0
def removeEmployee(self, userID: str) -> None:
"""
Remove an employee and assign manager to all employees under the person
to as self
"""
employeeDoc = self.database.document(userID)
employeeDict = employeeDoc.get().to_dict()
employeeDoc.update({
"salary": 0.0,
"is_manager": False,
"employees": [],
"team_id": "",
"manager_id": "",
"manager_email": "",
"manager_name": "",
"role": ""
})
self.document.update({"employees": firestore.ArrayRemove(userID)})
for empID in employeeDict["employees"]:
self.database.document(empID)\
.update({"manager_id": self.managerData["user_id"],
"manager_email": self.managerData["email"],
"manager_name": self.managerData["name"]})
def delete_user(chatroom_id, user_id): # chatroomのuserの削除
chatroom_ref = db.collection(u'Chatroom').document(chatroom_id)
chatroom_ref.update({u'user_ids': firestore.ArrayRemove([user_id])})
def results():
db_usertype = session['db_usertype']
if request.method == 'POST':
def createMap(posts):
markers = []
temp_posts = []
for post in posts:
coords = []
for point in post.to_dict()["location"]:
coords.append(point)
markers.append(
{
'lat': coords[0],
'lng': coords[1],
'infobox': "<b>" + str(post.to_dict()["title"]) + "</b>" + "<br><img width=50px height=50px src=\'" + str(post.to_dict()["imgURL"]) + "\'></img>"
}
)
temp_posts.append(post)
map = Map(
identifier="sndmap",
lat=30.2672,
lng=-97.7431,
markers=markers,
cluster=True,
cluster_imagepath="https://developers.google.com/maps/documentation/javascript/examples/markerclusterer/m"
)
return [map, temp_posts]
if 'tags' in request.form:
tags = request.form['filterValue']
tagsSplit = tags.split(", ")
#GET DATA STREAM
posts = db_firestore.collection("posts").where("tags", "array_contains_any", tagsSplit).stream()
ourContent = createMap(posts)
json_post = {
'type': 'tags',
'tags': tags,
'posts': ourContent[1],
'map': ourContent[0],
'usertype': db_usertype
}
'''
if 'Content-Type' in request.headers:
if 'application/json' in request.headers['Content-Type']:
json_list = [
{'posts': [json_post]}
]
return jsonify(json_list)
'''
return render_template('results.html', type='tags', tags=tags, posts=ourContent[1], map=ourContent[0], usertype=db_usertype)
elif 'category' in request.form:
filterValue = request.form['category']
#GET DATA STREAM
posts = db_firestore.collection("posts").where("category", "==", filterValue).stream()
ourContent = createMap(posts)
json_post = {
'type': 'category',
'posts': ourContent[1],
'map': ourContent[0],
'filterValue': filterValue,
'usertype': db_usertype
}
'''
if 'Content-Type' in request.headers:
if 'application/json' in request.headers['Content-Type']:
json_list = [
{'posts': [json_post]}
]
return jsonify(json_list)
'''
return render_template('results.html', type='category', posts=ourContent[1], map=ourContent[0], filterValue=filterValue, usertype=db_usertype)
elif 'category-Sub' in request.form:
subscription = request.form['category-Sub']
# Find the current db_username
db_username = session['db_username']
#Check if the subscription is already in the subscription List
doc_ref = db_firestore.collection(u'users').document(db_username)
doc = doc_ref.get()
for sub in doc.to_dict()['subscriptions']:
if sub == subscription:
return redirect(url_for('manage'))
#doc_ref = db_firestore.collection(u'users').where("username", "==", db_username).stream()
#for post in posts:
# coords = []
# for point in post.to_dict()["location"]:
# coords.append(point)
doc_ref.update({u'subscriptions': firestore.ArrayUnion([subscription])})
# If not add it
#return to the manage page
return redirect(url_for('manage'))
elif 'category-Unsub' in request.form:
subscription = request.form['category-Unsub']
# Find the current db_username
db_username = session['db_username']
#Check if the subscription is already in the subscription List
doc_ref = db_firestore.collection(u'users').document(db_username)
#doc_ref = db_firestore.collection(u'users').where("username", "==", db_username).stream()
#for post in posts:
# coords = []
# for point in post.to_dict()["location"]:
# coords.append(point)
doc_ref.update({u'subscriptions': firestore.ArrayRemove([subscription])})
# If not add it
#return to the manage page
return redirect(url_for('manage'))
return render_template('results.html', error=None)