def edit_book(_id):
params = request.get_json() or request.form
if not params:
return jsonify({
'message': 'invalid params',
'code': 154000,
}), 400
name = params.get('name')
description = params.get('description')
status = params.get('status', 1)
maintainer = params.get('maintainer', [])
import_type = params.get('importType')
galaxy_repo = params.get('galaxyRepo')
record = Book.find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({
'message': 'record not found',
'code': 154041,
}), 404
data = {
'status': status,
}
if name:
data['name'] = name
if description:
data['description'] = description
if maintainer:
data['maintainer'] = maintainer
if import_type == 'galaxy':
galaxy = AnsibleGalaxy([galaxy_repo], {'force': True})
galaxy.install(record.get('_id'))
Book.update_one({'_id': ObjectId(_id)}, {'$set': data}, upsert=True)
logger.info('book update', extra={'record': record, 'changed': data})
return jsonify({
'message': 'ok',
'code': 0,
'data': data,
})
def delete_book(_id):
record = Book.find_by_id(_id)
if not record:
return jsonify({'message': 'record not found', 'code': 154041}), 404
update = {
'$set': {
'status': -1,
'delete_at': time.time(),
'delete_by': login_user.get('username'),
'version': str(ObjectId()),
}
}
Book.update_one({'_id': record['_id']}, update=update)
db.collection('playbook').update_many({'book_id': str(record['_id'])},
update=update)
return jsonify({
'message': 'ok',
'code': 0,
})
def test_get_playbook(self):
book = self.get_data('book')
playbook = self.get_data('playbook')
result = Book.insert_one(book.copy())
book_id = result.inserted_id
playbook['book_id'] = str(book_id)
Playbook.insert_one(playbook)
self.trash += [[Book, book_id], [Playbook, playbook['_id']]]
url = self.get_api_path('/books/%s/playbook' % str(ObjectId()))
response = self.client.get(url, headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 154001)
Book.update_one({'_id': book_id}, {'$set': {'status': -1}})
url = self.get_api_path('/books/%s/playbook' % str(book_id))
response = self.client.get(url, headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 154001)
Book.update_one({'_id': book_id}, {'$set': {'status': 1}})
url = self.get_api_path('/books/%s/playbook' % str(book_id))
response = self.client.get(url, headers=self.jwt_headers)
self.assert200(response)
def test_get_playbook(self):
data = self.get_data('book')
playbook = self.get_data('playbook')
data['name'] = str(uuid.uuid4())
result = Book.insert_one(data.copy())
book_id = result.inserted_id
playbook['book_id'] = str(book_id)
Playbook.insert_one(playbook)
self.trash += [
[Book, book_id],
[Playbook, playbook['_id']],
]
url = self.get_api_path('/books/%s/playbook' % str(ObjectId()))
query = {'current': str(playbook['_id'])}
response = self.client.get(url,
query_string=query,
headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 154001)
url = self.get_api_path('/books/%s/playbook' % playbook['book_id'])
Book.update_one({'_id': book_id}, {'$set': {'status': -1}})
response = self.client.get(url,
query_string=query,
headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 154001)
Book.update_one({'_id': book_id}, {'$set': {'status': 1}})
url = self.get_api_path('/books/%s/playbook' % playbook['book_id'])
response = self.client.get(url,
query_string=query,
headers=self.jwt_headers)
self.assert200(response)
result = response.json
data = result.get('data')
check = map(lambda i: str(i['_id']), data)
check = list(check)
assert str(playbook['_id']) in check
def books():
query = request.args
page = int(query.get('page', 1))
size = int(query.get('pageSize', 50))
offset = (page - 1) * size
keyword = query.get('keyword')
is_admin = login_user.get('is_admin')
start = query.get('start')
end = query.get('end')
maintainer = query.get('maintainer')
where = {'status': {'$ne': -1}}
if keyword:
where['name'] = {'$regex': keyword}
if not is_admin:
where['maintainer'] = {'$in': [login_user.get('username')]}
elif maintainer:
where['maintainer'] = {'$in': [maintainer]}
date = []
if start:
date.append({
'created_at': {
'$gte': int(time.mktime(time.strptime(start, '%Y-%m-%d')))
}
})
if end:
date.append({
'created_at': {
'$lte': int(time.mktime(time.strptime(end, '%Y-%m-%d')))
}
})
if date:
where['$and'] = date
cursor = Book.find(where, skip=offset, limit=size)
total = cursor.count()
records = list(cursor)
data = []
for item in records:
item['job'] = None
where = {
'type': 'playbook',
'template.entry': {
'$in': [str(item['_id'])]
}
}
job = db.collection('jobs').find_one(where)
if job:
item['job'] = {
'_id': job.get('_id'),
'name': job.get('name'),
'type': job.get('type'),
}
if item.get('status'):
data.append(item)
continue
where = {
'role': 'entry',
'book_id': item['_id'],
}
entry = Playbook.find_one(where)
if not entry:
Book.update_one({'_id': item['_id']}, {'$set': {'status': 0}})
item['status'] = 0
data.append(item)
return jsonify({
'message': 'ok',
'code': 0,
'data': {
'list': records,
'page': page,
'pageSize': size,
'total': total,
}
})
def add_book():
params = request.get_json() or request.form
if not params:
return jsonify({
'message': 'invalid params',
'code': 154000,
}), 400
name = params.get('name')
if not name:
return jsonify({
'message': 'name param required',
'code': 154001,
}), 400
existed = Book.find_one({'name': name})
if existed:
return jsonify({
'message': 'book exist',
'code': 154003,
}), 400
description = params.get('description')
status = params.get('status', 1)
bid = params.get('_id')
import_type = params.get('importType')
galaxy_repo = params.get('galaxyRepo')
maintainer = params.get('maintainer', [])
if bid:
record = Book.find_one({'_id': ObjectId(bid)})
if not record:
return jsonify({
'message': 'record not found',
'code': 154041,
}), 404
else:
if import_type == 'galaxy' and galaxy_repo:
galaxy = AnsibleGalaxy([galaxy_repo])
galaxy.install()
logger.info('import galaxy', extra={'repo': galaxy_repo})
data = {
'name': name,
'description': description,
'maintainer': maintainer,
'import_type': import_type,
'galaxy_repo': galaxy_repo,
'status': int(status),
'created_at': int(time.time())
}
result = Book.update_one({'_id': ObjectId(bid)}, {'$set': data},
upsert=True)
data['_id'] = result.upserted_id
return jsonify({
'message': 'ok',
'code': 0,
'data': data,
})
def import_book_from_dir(self,
home_path,
book_id,
exclude=None,
links=False,
prefix='/'):
"""
import dir file to db
@todo
"""
book_id = str(book_id)
exclude = exclude or ['*.retry']
bucket = []
cursor = 0
home_path = home_path.rstrip('/')
parent = home_path
book_record = Book.find_by_id(book_id)
model = Model.build_model('playbook')
playbooks = model.find({'book_id': book_id})
paths = map(lambda i: i['path'], playbooks)
paths = list(paths)
pattern = '|'.join(exclude).replace('*', '.*?')
home_path = '/'.join([home_path, ''])
for current, dirs, files in os.walk(home_path,
topdown=True,
followlinks=links):
pathname = current.replace(home_path, '')
if pathname != '/':
pathname = os.path.join(prefix, pathname)
if exclude:
match = re.search(pattern, pathname)
if match:
continue
if pathname in paths:
index = paths.index(pathname)
paths.pop(index)
dir_record = {
'book_id': str(book_record.get('_id')),
'path': pathname,
'is_dir': True,
'is_edit': False,
'seq_no': cursor,
'parent': None,
'created_at': int(time.time()),
}
if not current == home_path:
dir_record['parent'] = parent
meta = get_meta(pathname)
dir_record.update(meta)
dir_record['additions'] = meta
parent = pathname
bucket.append(dir_record)
for file in files:
pathname = parent.rstrip('/') + '/' + file
if exclude:
match = re.match(pattern, pathname)
if match:
continue
cursor += 1
filename = current + '/' + file
can_edit = is_edit(filename)
file_record = dir_record.copy()
file_record['is_edit'] = can_edit
file_record['path'] = pathname
file_record['parent'] = parent
file_record['is_dir'] = False
file_record['seq_no'] = cursor
if is_edit:
with open(filename, 'r', encoding='utf-8') as fd:
file_record['content'] = fd.read()
file_record['md5'] = md5(file_record['content'])
file_record['is_encrypt'] = Vault.is_encrypted(
file_record['content'])
meta = get_meta(file_record['path'])
file_record['additions'] = meta
file_record.update(meta)
bucket.append(file_record)
cursor += 1
is_entry = filter(lambda i: i.get('role') == 'entry', bucket)
is_entry = list(is_entry)
# if not entry set book status to disable
if not is_entry:
Book.update_one({'_id': ObjectId(book_id)},
{'$set': {
'status': 0
}})
for path in paths:
model.delete_one({'book_id': book_id, 'path': path})
mapping = {}
map(lambda i: {mapping['path']: i}, playbooks)
for item in bucket:
record = mapping.get(item['path'])
if not record:
model.insert_one(item)
continue
else:
# inherit old additions
if record['additions']:
item['additions'].update(record['additions'])
model.update_one({'_id': record['_id']}, {'$set': item})
return bucket
def add_book():
params = request.get_json() or request.form
if not params:
return jsonify({
'message': 'invalid params',
'code': 154000,
}), 400
name = params.get('name')
if not name:
return jsonify({
'message': 'name param required',
'code': 154001,
}), 400
existed = Book.find_one({'name': name})
if existed:
return jsonify({
'message': 'book exist',
'code': 154003,
}), 400
description = params.get('description')
status = params.get('status', 0)
book_id = params.get('_id')
import_type = params.get('importType')
repo = params.get('repo')
maintainer = params.get('maintainer', [])
readonly = params.get('readonly', False)
if book_id:
record = Book.find_by_id(book_id)
if not record:
return jsonify({
'message': 'record not found',
'code': 154041,
}), 404
else:
data = {
'name': name,
'readonly': readonly,
'description': description,
'maintainer': maintainer,
'import_type': import_type,
'repo': repo,
'created_at': int(time.time())
}
result = Book.insert_one(data)
book_id = result.inserted_id
if import_type == 'galaxy' and repo:
galaxy = AnsibleGalaxy([repo])
galaxy.install(book_id)
logger.info('import galaxy', extra={'repo': repo})
elif import_type == 'git' and repo:
git = GitDownload({'repository': repo})
dest = git.install()
Workspace().import_book_from_dir(dest, book_id, exclude=['.git'])
data = {
'readonly': readonly,
'description': description,
'maintainer': maintainer,
'import_type': import_type,
'repo': repo,
'status': int(status),
'updated_at': time.time(),
}
Book.update_one({'_id': ObjectId(book_id)}, {'$set': data}, upsert=True)
data['_id'] = book_id
return jsonify({
'message': 'ok',
'code': 0,
'data': data,
})
