def login_response(self, users_collection):
user = find_one(users_collection, self.login, 'login')
if user is None:
return json_response({"message": "User do not exist"}, 404)
user = User(**user)
return user.authenticate(self.password)
def get_friends_helper(request):
user = authorize(request)
if not user:
return {"message":"Not authorized!"}, 401
user_entry = db.find_one({"username":user})#["friends"]
return {"friends":user_entry["friends"],"friend_requests":user_entry["friend_requests"]}, 200
def parse(self, response):
"""
:param response:
:return:请求完成之后的回调函数
"""
item = CrawlArticleReadDataItem()
item['read_data'] = response.get_ext_data['read_data']
item['nickname'] = response.get_ext_data['nickname']
item['content_url'] = response.get_ext_data['content_url']
# 打印状爬虫状态信息
self.task_counter += 1
pre_time_gap = time() - self.pre_time
total_time_gap = time() - self.begin_time
time_need = (self.task_num - self.task_counter) * (total_time_gap /
self.task_counter)
print(round(pre_time_gap, 2),
round(total_time_gap / self.task_counter,
2), "%d/%d" % (self.task_counter, self.task_num),
response.get_ext_data['read_data']['read_num'],
response.get_ext_data['read_data']['like_num'],
response.get_ext_data['read_data']['nick_name'],
str(datetime.timedelta(seconds=time_need)).split('.')[0])
self.pre_time = time()
crawling_item = {}
crawling_item['nickname'] = item['nickname']
crawling_item['percent'] = '%d/%d' % (self.task_counter, self.task_num)
crawling_item['more'] = response.get_ext_data['read_data']['read_num']
crawling_item['title'] = find_one(item['nickname'],
item['content_url'])['title'][:10]
gc.report_crawling(crawling_item)
yield item
def update(self, collection, meeting_id, rooms_collection, user):
self.user_id = str(user.get_id())
self._id = meeting_id
old_meeting = find_one(collection, meeting_id)
if old_meeting is None:
return json_response({"message": "Meeting doesn't exist"}, 404)
old_meeting = Meeting(**old_meeting)
if old_meeting.e_tag != self.e_tag:
return json_response({"message": "ETag header is invalid"}, 400)
self._id = old_meeting._id
if self.room_id is None:
self.room_id = old_meeting.room_id
if self.room_id is not None:
room_data = find_one(rooms_collection, self.room_id)
if room_data is None:
return json_response({"message": "Room doesn't exist"}, 400)
room_data = Room(**room_data)
if not room_data.available(collection, self.start_time,
self.end_time, str(self._id)):
return json_response(
{
"message":
"Room is not available for the specified time"
}, 400)
else:
selected_room = None
data = rooms_collection.find({})
for x in data:
x_room = Room(**x)
if x_room.available(collection, self.start_time,
self.end_time):
selected_room = x_room
break
if selected_room is None:
return json_response(
{
"message":
"There is no free room for the specified time"
}, 400)
self.room_id = str(selected_room.get_id())
return object_save(collection, self.to_dict())
def test_db(self):
id = db.find_and_modify({'url':'https://github.com/okamuuu'}, {'url':'https://github.com/okamuuu'})
url = db.find_one({'url':'https://github.com/okamuuu'})
self.assertTrue(url)
### clean up
db.remove({'_id':url['_id']})
def get_user_by_token(collection, token):
user_id = get_token(token)
if user_id is None:
return None
user = find_one(collection, user_id)
if user is None:
return None
return User(**user)
def accept_friend_request_helper(request):
# check access token
user = authorize(request)
if not user:
return {"message": "Not authorized!"}, 401
body = loads(request.data)
friend_username = body["friend_username"]
if not db.find_one({"username": user, "friend_requests": friend_username}):
return {
"message": "Friend not found in pending friend requests. Weird"
}, 404
# add accepted friend to user's friend list
friends = db.find_one({"username": user})["friends"]
new_friend = {
"username": friend_username,
"songsReceived": [],
"songsSent": []
}
friends.append(new_friend)
db.update_one({"username": user}, {"$set": {"friends": friends}})
# clear new friend from requests
db.update_one({"username": user},
{"$pull": {
"friend_requests": friend_username
}})
# add user to the accepted friend's friend list
other_friends = db.find_one({"username": friend_username})["friends"]
other_friends.append({
"username": user,
"songsReceived": [],
"songsSent": []
})
db.update_one({"username": friend_username},
{"$set": {
"friends": other_friends
}})
return {"message": "friend added!"}, 200
def update(self, collection, old_id):
old_room = find_one(collection, old_id)
if old_room is None:
return json_response({"message": "Room doesn't exist"}, 404)
old_room = Room(**old_room)
if old_room.e_tag != self.e_tag:
return json_response({"message": "ETag header is invalid"}, 400)
self._id = old_room._id
return object_save(collection, self.to_dict())
def episode_new_callback(data):
"""
On receiving a episode:new event, add the episode to the Avalon
mongodb.
"""
# Log in to API
gazu.client.set_host("{0}/api".format(os.environ["GAZU_URL"]))
gazu.log_in(os.environ["GAZU_USER"], os.environ["GAZU_PASSWD"])
episode = gazu.shot.get_episode(data["episode_id"])
project = gazu.project.get_project(episode["project_id"])
project_name = lib.get_consistent_name(project["name"])
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
episode_data = {
"schema": "avalon-core:asset-2.0",
"name": lib.get_consistent_name(episode["name"]),
"silo": "shots",
"type": "asset",
"parent": db.locate([project_name]),
"data": {
"label": episode["name"].upper(),
"group": "Episode"
}
}
episode_data["data"]["visible"] = False
# Inset asset into Avalon DB
db.insert_one(episode_data)
# Get the Id of the asset we just inserted into Avalon
avalon_episode = db.find_one({
"name":
lib.get_consistent_name(episode["name"]),
"type":
"asset"
})
# Encode and store the Gazu Id and Avalon Id
lib.set_asset_data(project["id"], data["episode_id"],
avalon_episode["_id"])
db.uninstall()
logger.info("Create Episode \"{0}\" in Project \"{1}\"".format(
episode["name"], project["name"]))
def transfer_meetings(u_login):
user_data = find_one(db.users, u_login, 'login')
if user_data is None:
return json_response({"message": "User does not exist"}, 404)
user_data = User(**user_data)
data = get_request_data(request)
if data.get('user_login') is None:
return json_response(
{"message": "Missing user_login in the request body"}, 400)
new_user_data = find_one(db.users, data.get('user_login'), 'login')
if new_user_data is None:
return json_response({"message": "User does not exist"}, 404)
new_user_data = User(**new_user_data)
db.meetings.find_and_modify(
query={"user_id": str(user_data.get_id())},
update={"$set": {
"user_id": str(new_user_data.get_id())
}})
return json_response("", 200)
def asset_update_callback(data):
"""Update an asset name when receiving an asset:update event"""
# Log in to API
gazu.client.set_host("{0}/api".format(os.environ["GAZU_URL"]))
gazu.log_in(os.environ["GAZU_USER"], os.environ["GAZU_PASSWD"])
asset = gazu.asset.get_asset(data["asset_id"])
project = gazu.project.get_project(asset["project_id"])
project_name = lib.get_consistent_name(project["name"])
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
# Get Avalon Asset Id.
asset_id = lib.get_asset_data(project["id"], data["asset_id"])
# Get asset Type
entity_type = gazu.entity.get_entity_type(asset["entity_type_id"])
# Find the asset in Avalon
avalon_asset = db.find_one({"_id": db.ObjectId(asset_id), "type": "asset"})
# Set keep asset name for use in filesystem path renaming.
old_asset_name = lib.get_consistent_name(avalon_asset["name"])
# Ensure asset["name"] consistency.
asset_name = lib.get_consistent_name(asset["name"])
avalon_asset["name"] = asset_name
avalon_asset["data"]["label"] = asset["name"]
avalon_asset["data"]["group"] = entity_type["name"]
db.replace_one({
"_id": db.ObjectId(asset_id),
"type": "asset"
}, avalon_asset)
db.uninstall()
logger.info("Updated Asset \"{0}\" in Project \"{1}\"".format(
old_asset_name, project["name"]))
if asset_name != old_asset_name:
logger.info("Asset renamed from \"{0}\" to \"{1}\"".format(
old_asset_name, asset_name))
# If file system path renaming is enabled, rename asset disk
# filepaths to match.
if (os.environ["FILESYS_RENAME"]):
lib.rename_filepath(old_asset_name, asset_name, project_name, "assets")
def asset_create_callback(data):
"""
On receiving a asset:create event, insert the asset into the
Avalon mongodb and store Zou Id and Avalon Id key value pair
for using in asset update events.
"""
# Log in to API
gazu.client.set_host("{0}/api".format(os.environ["GAZU_URL"]))
gazu.log_in(os.environ["GAZU_USER"], os.environ["GAZU_PASSWD"])
asset = gazu.asset.get_asset(data["asset_id"])
project = gazu.project.get_project(asset["project_id"])
project_name = lib.get_consistent_name(project["name"])
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
entity_type = gazu.entity.get_entity_type(asset["entity_type_id"])
asset_data = {
"schema": "avalon-core:asset-2.0",
"name": lib.get_consistent_name(asset["name"]),
"silo": "assets",
"type": "asset",
"parent": db.locate([project_name]),
"data": {
"label": asset.get("label", asset["name"]),
"group": entity_type["name"]
}
}
# Inset asset into Avalon DB
db.insert_one(asset_data)
# Get the Id of the asset we just inserted into Avalon
avalon_asset = db.find_one({
"name": lib.get_consistent_name(asset["name"]),
"type": "asset"
})
# Encode and store the Gazu Id and Avalon Id
lib.set_asset_data(project["id"], data["asset_id"], avalon_asset["_id"])
db.uninstall()
logger.info("Create Asset \"{0}\" in Project \"{1}\"".format(
asset["name"], project["name"]))
def task_new_callback(data):
"""
On receiving a task:new event, add a task to an asset in the
Avalon mongodb.
"""
# Log in to API
gazu.client.set_host("{0}/api".format(os.environ["GAZU_URL"]))
gazu.log_in(os.environ["GAZU_USER"], os.environ["GAZU_PASSWD"])
task = gazu.task.get_task(data["task_id"])
entity = task["entity"]
project = task["project"]
task_type = task["task_type"]
project_name = lib.get_consistent_name(project["name"])
task_name = lib.get_consistent_name(task_type["name"])
# Get Avalon Asset Id.
entity_id = lib.get_asset_data(project["id"], entity["id"])
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
# Find the asset in Avalon
avalon_entity = db.find_one({
"_id": db.ObjectId(entity_id),
"type": "asset"
})
if avalon_entity["data"] is not None:
if "tasks" in avalon_entity["data"]:
avalon_entity["data"]["tasks"].append(task_name)
else:
avalon_entity["data"]["tasks"] = [task_name]
else:
avalon_entity["data"]["tasks"] = [task_name]
db.replace_one({
"_id": db.ObjectId(entity_id),
"type": "asset"
}, avalon_entity)
db.uninstall()
logger.info("Added new \"{2}\" Task to \"{0}\" in Project \"{1}\"".format(
avalon_entity["name"], project["name"], task_type["name"]))
def update(self, collection, old_login):
user = find_one(collection, old_login, 'login')
if user is None:
return json_response({"message": "User doesn't exist"}, 404)
user = User(**user)
if user.e_tag != self.e_tag:
return json_response({"message": "ETag header is invalid"}, 400)
if self.login != user.login:
return json_response({"message": "You cannot change user login"},
400)
self._id = user._id
return object_save(collection, self.to_dict())
def user_meetings(u_login):
user_data = find_one(db.users, u_login, 'login')
if user_data is None:
return json_response({"message": "User does not exist"}, 404)
user_data = User(**user_data)
if request.method == 'DELETE':
if g.user.get_id() != user_data.get_id():
return json_response(
{"message": "You cannot delete different user meetings"}, 403)
return delete_many(db.meetings, {'user_id': str(user_data.get_id())})
else:
return list_meetings(db.meetings, {'user_id': str(user_data.get_id())},
request.args)
def from_edge(edge):
'''
take the first node, match input to each its edges
'''
edge = tuple(edge)
label, *nodes = edge
node = next(node for node in nodes if isa(node, str))
vertex = db.find_one({'node': node})
if vertex:
arcs = vertex['edges']
for arc in arcs:
arc = Edge(**arc)
if arc == edge:
yield arc
def getAccountInfo(venmo_name):
account_info = db.find_one(account_collection_str, {"user_id" : str(venmo_name)})
if account_info is None:
return jsonify(**{})
return jsonify(**{
"user_name" : account_info['user_name'],
"chequing_balance" : account_info['chequing_balance'],
"savings_balance" : account_info['savings_balance'],
"allowance_amount" : account_info['allowance_amount'],
"debt_amount" : account_info['debt_amount'],
"savings_amount" : account_info['savings_amount'],
"savings_interest_rate" : account_info['savings_interest_rate'],
"loan_interest_rate" : account_info['loan_interest_rate']
})
def room(room_id):
if request.method == 'PUT':
room_data = Room(**get_request_data(request),
e_tag=request.headers.get('If-Match'))
if not room_data.validate():
return json_response({"message": "Room form is invalid"}, 400)
return room_data.update(db.rooms, room_id)
elif request.method == 'GET':
return find_one_response(db.rooms, room_id)
else:
if find_one(db.meetings, room_id, 'room_id'):
return json_response(
{
"message":
"Cannot delete room because there is a meeting that is associated with "
"that room"
}, 400)
return delete_one_response(db.rooms, room_id)
def login_helper(request):
creds = b64decode(request.headers['Authorization'])
colon = creds.find(':')
username, password_attempt = creds[:colon], creds[colon+1:]
print(request.headers['Authorization'])
user = db.find_one({"username":username})
if user:
pwa_hash = hash_alg(password_attempt)
print('attempts:',username,password_attempt,pwa_hash)
if user["password"].decode() == pwa_hash:
return {'access_token':create_access_token(username),
'message':'Success!'}, 200
else:
return {'access_token':'',
'message':'Wrong password.'}, 202
return {'access_token':'',
'message':'User not found.'}, 404
def parse(self, response):
"""
:param response:
:return:请求完成之后的回调函数
"""
item = CrawlArticleItem()
item['article_data'] = response.get_ext_data['article_data']
item['nickname'] = response.get_ext_data['nickname']
item['raw_url'] = response.get_ext_data['raw_url']
self.crawler_parse_counter += 1
time_gap = time() - self.crawler_begin_time
print(round(time_gap / self.crawler_parse_counter, 3),
item['article_data']['article'].replace('\n', ''))
# 发送状态给前端
crawling_item = {}
crawling_item['nickname'] = item['nickname']
crawling_item['percent'] = self.crawler_parse_counter
crawling_item['more'] = round(time_gap / self.crawler_parse_counter, 3)
crawling_item['title'] = find_one(item['nickname'],
item['raw_url'])['title'][:10]
gc.report_crawling(crawling_item)
yield item
def setCurrentInvestment():
venmo_id = request.form['venmo_name']
investment_id = request.form['investment_id']
amount = float(request.form['amount'])
account_info = db.find_one(account_collection_str, {"user_id" : str(venmo_id)})
current_chequing = float(account_info['chequing_balance'])
new_investments_collection = db.get_collection(new_investments_str)
investment = new_investments_collection.find_one({'investment_id': investment_id})
# post as long as value is 0
if amount < 0 or current_chequing < amount or investment['is_purchased'] == True:
return jsonify(**{
"success": False
})
else:
addBoughtInvestment(venmo_id,
investment_id,
amount,
)
new_chequing_balance = current_chequing - amount
account_info = db.get_collection(account_collection_str)
account_info.update({"user_id" : venmo_id},
{"$set": {"chequing_balance" : new_chequing_balance}})
new_investment_list = db.find(new_investments_str, {"user_id" : venmo_id, "is_purchased": False })
current_investment_list = db.find(bought_investments_str, {"user_id" : venmo_id })
return jsonify(**{
"chequing_balance": new_chequing_balance,
"new_investments" : new_investment_list,
"my_investments" : current_investment_list,
})
def shot_update_callback(data):
"""Update an shot name when receiving an shot:update event"""
# Log in to API
gazu.client.set_host("{0}/api".format(os.environ["GAZU_URL"]))
gazu.log_in(os.environ["GAZU_USER"], os.environ["GAZU_PASSWD"])
shot = gazu.shot.get_shot(data["shot_id"])
project = gazu.project.get_project(shot["project_id"])
if project["production_type"] == "tvshow":
# Ensure name consistency.
project_name = lib.get_consistent_name(project["name"])
episode_name = lib.get_consistent_name(shot["episode_name"])
sequence_name = lib.get_consistent_name(shot["sequence_name"])
shot_name = lib.get_consistent_name(shot["name"])
visualParent = [
project_name, "{0}_{1}".format(episode_name, sequence_name)
]
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
# Get Avalon Shot Id.
shot_id = lib.get_asset_data(project["id"], data["shot_id"])
# Find the asset in Avalon
avalon_shot = db.find_one({
"_id": db.ObjectId(shot_id),
"type": "asset"
})
# Set keep shot name for use in filesystem path renaming.
old_shot_name = lib.get_consistent_name(avalon_shot["name"])
new_shot_name = "{0}_{1}_{2}".format(episode_name, sequence_name,
shot_name)
avalon_shot["name"] = new_shot_name
avalon_shot["data"]["label"] = shot["name"]
avalon_shot["data"]["group"] = "{0} {1}".format(
shot["episode_name"].upper(), shot["sequence_name"].upper())
avalon_shot["data"]["visualParent"] = db.locate(visualParent)
else:
# Ensure name consistency.
project_name = lib.get_consistent_name(project["name"])
sequence_name = lib.get_consistent_name(shot["sequence_name"])
shot_name = lib.get_consistent_name(shot["name"])
visualParent = [project_name, "{0}".format(sequence_name)]
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
# Get Avalon Shot Id.
shot_id = lib.get_asset_data(project["id"], data["shot_id"])
# Find the asset in Avalon
avalon_shot = db.find_one({
"_id": db.ObjectId(shot_id),
"type": "asset"
})
# Set keep shot name for use in filesystem path renaming.
old_shot_name = lib.get_consistent_name(avalon_shot["name"])
new_shot_name = "{0}_{1}".format(sequence_name, shot_name)
avalon_shot["name"] = new_shot_name
avalon_shot["data"]["label"] = shot["name"]
avalon_shot["data"]["group"] = "{0}".format(
shot["sequence_name"].upper())
avalon_shot["data"]["visualParent"] = db.locate(visualParent)
if shot["data"] is not None:
if "frame_in" in shot["data"]:
avalon_shot["data"]["edit_in"] = shot["data"]["frame_in"]
avalon_shot["data"]["startFrame"] = shot["data"]["frame_in"]
if "frame_out" in shot["data"]:
avalon_shot["data"]["edit_out"] = shot["data"]["frame_out"]
avalon_shot["data"]["endFrame"] = shot["data"]["frame_out"]
if "fps" in shot["data"]:
if shot["data"]["fps"] != "":
avalon_shot["data"]["fps"] = int(shot["data"]["fps"])
if "fps" in avalon_shot["data"] and shot["data"]["fps"] == "":
del avalon_shot["data"]["fps"]
db.replace_one({"_id": db.ObjectId(shot_id), "type": "asset"}, avalon_shot)
db.uninstall()
logger.info("Updated Shot \"{0}\" in Project \"{1}\"".format(
avalon_shot["name"], project["name"]))
if new_shot_name != old_shot_name:
logger.info("Shot renamed from \"{0}\" to \"{1}\"".format(
old_shot_name, new_shot_name))
# If file system path renaming is enabled, rename shot disk
# filepaths to match.
if (os.environ["FILESYS_RENAME"]):
lib.rename_filepath(old_shot_name, new_shot_name, project_name,
"shots")
def shot_new_callback(data):
"""
On receiving a shot:new event, insert the shot into the
Avalon mongodb and store Zou Id and Avalon Id key value pair
for using in asset update events.
"""
# Log in to API
gazu.client.set_host("{0}/api".format(os.environ["GAZU_URL"]))
gazu.log_in(os.environ["GAZU_USER"], os.environ["GAZU_PASSWD"])
shot = gazu.shot.get_shot(data["shot_id"])
project = gazu.project.get_project(shot["project_id"])
if project["production_type"] == "tvshow":
project_name = lib.get_consistent_name(project["name"])
episode_name = lib.get_consistent_name(shot["episode_name"])
sequence_name = lib.get_consistent_name(shot["sequence_name"])
shot_name = lib.get_consistent_name(shot["name"])
visualParent = [
project_name, "{0}_{1}".format(episode_name, sequence_name)
]
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
shot_data = {
"schema": "avalon-core:asset-2.0",
"name": "{0}_{1}_{2}".format(episode_name, sequence_name,
shot_name),
"silo": "shots",
"type": "asset",
"parent": db.locate([project_name]),
"data": {
"label":
shot["name"],
"group":
"{0} {1}".format(shot["episode_name"].upper(),
shot["sequence_name"].upper()),
"visualParent":
db.locate(visualParent)
}
}
else:
project_name = lib.get_consistent_name(project["name"])
sequence_name = lib.get_consistent_name(shot["sequence_name"])
shot_name = lib.get_consistent_name(shot["name"])
visualParent = [project_name, "{0}".format(sequence_name)]
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
shot_data = {
"schema": "avalon-core:asset-2.0",
"name": "{0}_{1}".format(sequence_name, shot_name),
"silo": "shots",
"type": "asset",
"parent": db.locate([project_name]),
"data": {
"label": shot["name"],
"group": "{0}".format(shot["sequence_name"].upper()),
"visualParent": db.locate(visualParent)
}
}
# Inset shot into Avalon DB
db.insert_one(shot_data)
# Get the Id of the shot we just inserted into Avalon
avalon_shot = db.find_one({
"name":
lib.get_consistent_name(shot_data["name"]),
"type":
"asset"
})
# Encode and store the Gazu Id and Avalon Id
lib.set_asset_data(project["id"], data["shot_id"], avalon_shot["_id"])
logger.info("Created Shot \"{0}\" in Project \"{1}\"".format(
shot["name"], project["name"]))
def project_update_callback(data):
"""Update a project in Avalon when receiving an project:update event"""
# Log in to API
gazu.client.set_host("{0}/api".format(os.environ["GAZU_URL"]))
gazu.log_in(os.environ["GAZU_USER"], os.environ["GAZU_PASSWD"])
project = gazu.project.get_project(data["project_id"])
# Get the Avalon project ID from partd
project_data = lib.get_project_data(data["project_id"])
os.environ["AVALON_PROJECT"] = project_data["collection"]
db.uninstall()
db.install()
# Find the project in Avalon
avalon_project = db.find_one({
"_id": db.ObjectId(project_data["id"]),
"type": "project"
})
# Ensure project["name"] consistency.
project_name = lib.get_consistent_name(project["name"])
old_project_name = lib.get_consistent_name(avalon_project["name"])
# Projects may not have a resolution set
if project["resolution"]:
resolution_width = int(int(project["resolution"]) / 9 * 16)
else:
resolution_width = None
project["resolution"] = None
# Get latest Tasks from Gazu
tasks = [{
"name": lib.get_consistent_name(task["name"]),
"label": task["name"]
} for task in gazu.task.all_task_types()]
# Update the Avalon project with new data from Gazu
avalon_project["name"] = project_name
avalon_project["data"]["label"] = project["name"]
avalon_project["data"]["fps"] = int(project["fps"])
avalon_project["data"]["resolution_width"] = int(resolution_width)
avalon_project["data"]["resolution_height"] = int(project["resolution"])
avalon_project["config"]["tasks"] = tasks
db.replace_one({
"_id": db.ObjectId(project_data["id"]),
"type": "project"
}, avalon_project)
db.uninstall()
if old_project_name != project_name:
logger.info("Updating project name from {0} to {1}".format(
old_project_name, project_name))
lib.collection_rename(project_name)
lib.set_project_data(data["project_id"], avalon_project["_id"],
avalon_project["name"])
# If file system path renaming is enabled, rename project disk
# filepaths to match.
if (os.environ["FILESYS_RENAME"]):
avalon_projects = os.environ["AVALON_PROJECTS"]
old_folder_name = os.path.join(avalon_projects, old_project_name)
new_folder_name = os.path.join(avalon_projects, project_name)
if os.path.exists(old_folder_name):
if not os.path.exists(new_folder_name):
logger.info(
"Project name updated, renaming {0} to {1}".format(
old_folder_name, new_folder_name))
shutil.move(old_folder_name, new_folder_name)
else:
logger.warning(
"Project name updated, trying to rename {0} to {1}, but new "
"folder already exists. No action taken.".format(
old_folder_name, new_folder_name))
else:
logger.warning(
"Project name updated, but {0} does not exist. No "
"action taken.".format(old_folder_name))
logger.info("Updating Project: \"{0} ({1})\"".format(
avalon_project["data"]["label"], project_name))
def project_new_callback(data):
"""
On receiving a project:new event, insert the project into the
Avalon mongodb and store Zou id and Avalon id key value pair for
using in asset update events.
"""
# Log in to API
gazu.client.set_host("{0}/api".format(os.environ["GAZU_URL"]))
gazu.log_in(os.environ["GAZU_USER"], os.environ["GAZU_PASSWD"])
project = gazu.project.get_project(data["project_id"])
# Ensure project["name"] consistency.
project_name = lib.get_consistent_name(project["name"])
os.environ["AVALON_PROJECT"] = project_name
db.uninstall()
db.install()
# Newly created projects don't have a resolution set
if project["resolution"]:
resolution_width = int(int(project["resolution"]) / 9 * 16)
else:
resolution_width = None
project["resolution"] = None
# Get tasks from Gazu API
tasks = [{
"name": lib.get_consistent_name(task["name"]),
"label": task["name"]
} for task in gazu.task.all_task_types()]
project_data = {
"schema": "avalon-core:project-2.0",
"name": project_name,
"type": "project",
"parent": None,
"data": {
"label": project["name"],
"fps": project["fps"],
"resolution_width": resolution_width,
"resolution_height": project["resolution"]
},
"config": {
"schema": "avalon-core:config-1.0",
"apps": [{
"name": "maya2018",
"label": "Autodesk Maya 2018"
}],
"tasks": tasks,
"template": {
"work":
"{root}/{project}/{silo}/{asset}/work/"
"{task}/{app}",
"publish":
"{root}/{project}/{silo}/{asset}/publish/"
"{subset}/v{version:0>3}/{subset}.{representation}"
}
}
}
# Insert asset into Avalon DB
db.insert_one(project_data)
# Find the project in Avalon
avalon_project = db.find_one({
"name":
lib.get_consistent_name(project["name"]),
"type":
"project"
})
# Encode and store the data
lib.set_project_data(data["project_id"], avalon_project["_id"],
avalon_project['name'])
db.uninstall()
logger.info("Created Project: \"{0}\"".format(project["name"]))
def room_meetings(room_id):
if find_one(db.rooms, room_id) is None:
return json_response({"message": "Room does not exist"}, 404)
return list_all(db.meetings, {"room_id": room_id}, request.args)
def create(self, collection):
if find_one(collection, self.login, 'login') is not None:
return json_response({"message": "User already exists"}, 409)
return object_save(collection, self.to_dict(), "users")
def get_url(short):
result = db.find_one({'short':short})
redirect(result['url'])
def from_node(node):
vertex = db.find_one({'node': node})
if vertex:
for arc in vertex['edges']:
arc = Edge(**arc)
yield arc
def main():
projects = {}
objects = {}
objects_count = 0
logger.info("Get Project, Task, Asset and Shot Data...")
tasks = [{
"name": lib.get_consistent_name(task["name"]),
"label": task["name"]
} for task in gazu.task.all_task_types()]
for project in gazu.project.all_projects():
# Ensure project["name"] consistency.
project_name = lib.get_consistent_name(project["name"])
# Collect assets.
assets = []
for asset in gazu.asset.all_assets_for_project(project):
# Faking a parent for better hierarchy structure, until folders are
# supported in Kitsu.
asset["parents"] = ["assets"]
asset["tasks"] = gazu.task.all_tasks_for_asset(asset)
assets.append(asset)
# Collect shots and parents.
episodes = []
sequences = []
shots = []
if project["production_type"] == "tvshow":
for episode in (gazu.shot.all_episodes_for_project(project) or []):
episode["code"] = lib.get_consistent_name(episode["name"])
# Faking a parent for better hierarchy structure, until
# folders are supported in Kitsu.
episode["parents"] = ["episodes"]
episodes.append(episode)
for sequence in gazu.shot.all_sequences_for_episode(episode):
sequence["code"] = lib.get_consistent_name(
sequence["name"])
sequence["label"] = sequence["name"]
sequence["name"] = "{0}_{1}".format(
episode["code"], sequence["code"])
sequence["visualParent"] = episode["name"]
sequences.append(sequence)
for shot in gazu.shot.all_shots_for_sequence(sequence):
shot["code"] = lib.get_consistent_name(shot["name"])
shot["label"] = shot["name"]
shot["name"] = "{0}_{1}_{2}".format(
episode["code"], sequence["code"], shot["code"])
shot["visualParent"] = sequence["name"]
shot["tasks"] = gazu.task.all_tasks_for_shot(shot)
shots.append(shot)
else:
for sequence in gazu.shot.all_sequences_for_project(project):
sequence["code"] = lib.get_consistent_name(sequence["name"])
sequence["label"] = sequence["name"]
sequence["name"] = "{0}".format(sequence["code"])
sequences.append(sequence)
for shot in gazu.shot.all_shots_for_sequence(sequence):
shot["code"] = lib.get_consistent_name(shot["name"])
shot["label"] = shot["name"]
shot["name"] = "{0}_{1}".format(sequence["code"],
shot["code"])
shot["visualParent"] = sequence["name"]
shot["tasks"] = gazu.task.all_tasks_for_shot(shot)
shots.append(shot)
silos = [[assets, "assets"], [episodes, "shots"], [sequences, "shots"],
[shots, "shots"]]
entities = {}
for assets, silo in silos:
for asset in assets:
entity_type = gazu.entity.get_entity_type(
asset["entity_type_id"])
data = {
"id": asset["id"],
"schema": "avalon-core:asset-2.0",
"name": lib.get_consistent_name(asset["name"]),
"silo": silo,
"type": "asset",
"parent": project_name,
"data": {
"label": asset.get("label", asset["name"]),
"group": entity_type["name"],
}
}
if silo == "assets":
data["data"]["group"] = entity_type["name"]
# If the silo is shots, group the shot under the proper
# sequence and episode and hide sequences and episodes in the
# launcher.
elif silo == "shots":
if asset["type"] == "Shot":
data["data"]["group"] = asset["visualParent"].upper(
).replace("_", " ")
# Add frame data for shots.
if asset["data"] is not None:
if "frame_in" in asset["data"]:
data["data"]["edit_in"] = asset["data"][
"frame_in"]
data["data"]["startFrame"] = asset["data"][
"frame_in"]
if "frame_out" in asset["data"]:
data["data"]["edit_out"] = asset["data"][
"frame_out"]
data["data"]["endFrame"] = asset["data"][
"frame_out"]
if "fps" in asset["data"]:
if asset["data"]["fps"] != "":
data["data"]["fps"] = int(
asset["data"]["fps"])
elif asset["type"] == "Sequence":
if "visualParent" in asset:
data["data"]["group"] = asset["visualParent"]
data["data"]["visible"] = False
elif asset["type"] == "Episode":
data["data"]["visible"] = False
data["asset_type"] = asset["type"]
if "visualParent" in asset:
data["data"]["visualParent"] = asset["visualParent"]
if "tasks" in asset:
data["data"]["tasks"] = []
for task in asset["tasks"]:
data["data"]["tasks"].append(
lib.get_consistent_name(task["task_type_name"]))
entities[data["name"]] = data
objects_count += 1
objects[project["id"]] = entities
# Newly created projects don't have a resolution set
if project["resolution"]:
resolution_width = int(int(project["resolution"]) / 9 * 16)
else:
resolution_width = None
project["resolution"] = None
projects[project_name] = {
"id": project["id"],
"schema": "avalon-core:project-2.0",
"type": "project",
"name": project_name,
"data": {
"label": project["name"],
"fps": int(project["fps"]),
"resolution_width": int(resolution_width),
"resolution_height": int(project["resolution"])
},
"parent": None,
"config": {
"schema": "avalon-core:config-1.0",
"apps": [{
"name": "maya2018",
"label": "Autodesk Maya 2018"
}],
"tasks": tasks,
"template": {
"work":
"{root}/{project}/{silo}/{asset}/work/"
"{task}/{app}",
"publish":
"{root}/{project}/{silo}/{asset}/publish/"
"{subset}/v{version:0>3}/{subset}.{representation}"
}
}
}
logger.info("Found {0} projects".format(len(projects)))
logger.info("Found {0} assets".format(objects_count))
os.environ["AVALON_PROJECT"] = "temp"
os.environ["AVALON_ASSET"] = "bruce"
os.environ["AVALON_SILO"] = "assets"
os.environ["AVALON_TASK"] = "model"
os.environ["AVALON_WORKDIR"] = "/avalon"
existing_projects = {}
logger.info("Synchronising...")
for name, project in projects.items():
project_info = lib.get_project_data(project["id"])
if project_info:
existing_projects[project["name"]] = project
# Update project
os.environ["AVALON_PROJECT"] = project_info["collection"]
db.uninstall()
db.install()
# Find the project in Avalon
avalon_project = {}
avalon_project = db.find_one({
"_id": db.ObjectId(project_info["id"]),
"type": "project"
})
# If project not found in Avalon DB error.
if not avalon_project:
logger.critical("Project missing from db.")
logger.critical("Data directory and Avalon out of sync "
"quitting...")
quit()
# Set old and new project names
project_name = lib.get_consistent_name(project["name"])
old_project_name = lib.get_consistent_name(avalon_project["name"])
# Update the Avalon project with new data from Gazu
logger.info("Updating Project: {0} ({1})".format(
project["data"]["label"], name))
avalon_project["name"] = project_name
avalon_project["data"]["label"] = project["data"]["label"]
avalon_project["data"]["fps"] = int(project["data"]["fps"])
avalon_project["data"]["resolution_width"] = int(
project["data"]["resolution_width"])
avalon_project["data"]["resolution_height"] = int(
project["data"]["resolution_height"])
avalon_project["config"]["tasks"] = tasks
db.replace_one(
{
"_id": db.ObjectId(project_info["id"]),
"type": "project"
}, avalon_project)
db.uninstall()
if old_project_name != project_name:
logger.info("Updating project name from {0} to {1}".format(
old_project_name, project_name))
lib.collection_rename(project_name)
lib.set_project_data(project["id"], project_info["id"],
avalon_project["name"])
# If file system path renaming is enabled, rename project disk
# filepaths to match.
if (os.environ["FILESYS_RENAME"]):
avalon_projects = os.environ["AVALON_PROJECTS"]
old_folder_name = os.path.join(avalon_projects,
old_project_name)
new_folder_name = os.path.join(avalon_projects,
project_name)
if os.path.exists(old_folder_name):
if not os.path.exists(new_folder_name):
logger.info(
"Project name updated, renaming {0} to {1}".
format(old_folder_name, new_folder_name))
shutil.move(old_folder_name, new_folder_name)
else:
logger.warning(
"Project name updated, trying to rename {0} to {1}, but "
"new folder already exists. No action taken.".
format(old_folder_name, new_folder_name))
else:
logger.warning(
"Project name updated, but {0} does not exist. No "
"action taken.".format(old_folder_name))
else:
logger.info("Installing project: {0}".format(project["name"]))
os.environ["AVALON_PROJECT"] = project["name"]
db.uninstall()
db.install()
# Remove Gazu ID from project so it doesn't go into the Avalon DB
project_id = project.pop("id")
# Inset project into Avalon DB
db.insert_one(project)
# Put Gazu ID back into the project so we can use it later for
# assets.
project.update(id=project_id)
# Find the new project in Avalon
avalon_project = db.find_one({
"name":
lib.get_consistent_name(project["name"]),
"type":
"project"
})
# Store a key of Gazu project ID and a list of the Avalon
# project ID and project code (mongodb collection) as a value.
lib.set_project_data(project_id, avalon_project["_id"],
project["name"])
for project["id"], assets in objects.items():
project_info = lib.get_project_data(project["id"])
os.environ["AVALON_PROJECT"] = project_info["collection"]
db.uninstall()
db.install()
for asset_name, asset in assets.items():
asset_id = lib.get_asset_data(project["id"], asset["id"])
if asset_id:
# Update Assets in Avalon with new data from Gazu
# Find asset in Avalon
avalon_asset = {}
avalon_asset = db.find_one({
"_id": db.ObjectId(asset_id),
"type": "asset"
})
logger.info("Updating Asset: {0} ({1})".format(
avalon_asset["data"]["label"], avalon_asset["name"]))
# Set keep asset name for use in filesystem path renaming.
old_asset_name = lib.get_consistent_name(avalon_asset["name"])
# Ensure asset["name"] consistency.
asset_name = lib.get_consistent_name(asset["name"])
if old_asset_name != asset_name:
logger.info("Updating asset name from {0} to {1}".format(
avalon_asset["name"], asset_name))
avalon_asset["name"] = asset_name
avalon_asset["data"]["label"] = asset["data"]["label"]
avalon_asset["data"]["group"] = asset["data"]["group"]
if avalon_asset["silo"] == "shots" and asset[
"asset_type"] == "Shot":
if asset["data"] is not None:
if "edit_in" in asset["data"]:
avalon_asset["data"]["edit_in"] = asset["data"][
"edit_in"]
avalon_asset["data"]["startFrame"] = asset["data"][
"startFrame"]
if "edit_out" in asset["data"]:
avalon_asset["data"]["edit_out"] = asset["data"][
"edit_out"]
avalon_asset["data"]["endFrame"] = asset["data"][
"endFrame"]
if "fps" in asset["data"]:
if asset["data"]["fps"] != "":
avalon_asset["data"]["fps"] = int(
asset["data"]["fps"])
if "fps" in avalon_asset[
"data"] and "fps" not in asset["data"]:
del avalon_asset["data"]["fps"]
if "tasks" in asset["data"]:
avalon_asset["data"]["tasks"] = asset["data"]["tasks"]
db.replace_one({
"_id": db.ObjectId(asset_id),
"type": "asset"
}, avalon_asset)
if (os.environ["FILESYS_RENAME"]):
if avalon_asset["silo"] == "shots":
# If file system path renaming is enabled, rename shot disk
# filepaths to match.
lib.rename_filepath(old_asset_name, asset_name,
project_name, "shots")
else:
# If file system path renaming is enabled, rename asset disk
# filepaths to match.
lib.rename_filepath(old_asset_name, asset_name,
project_name, "assets")
else:
# Insert new Assets into Avalon
asset["parent"] = db.locate([asset["parent"]])
if "visualParent" in asset["data"]:
visual_parent = lib.get_consistent_name(
asset["data"]["visualParent"])
asset_data = db.find_one({
"type": "asset",
"name": visual_parent
})
asset["data"]["visualParent"] = asset_data["_id"]
logger.info("Installing asset: \"{0} / {1}\"".format(
project["id"], asset_name))
# Remove Gazu ID and asset_type from asset so it doesn't go
# into the Avalon DB.
asset_gazu_id = asset.pop("id")
if "asset_type" in asset:
asset.pop("asset_type")
# Inset asset into Avalon DB
db.insert_one(asset)
# Get the Id of the asset we just inserted into Avalon
avalon_asset = db.find_one({
"name":
lib.get_consistent_name(asset["name"]),
"type":
"asset"
})
# Encode and store the Gazu Id and Avalon Id
lib.set_asset_data(project["id"], asset_gazu_id,
avalon_asset["_id"])
logger.info("Success")
