def create_template_project(request):
workspace = Workspace.objects.get(owner=request.user,
inner_name='home_page')
count = Project.objects.filter(
owner=request.user, inner_name__startswith='custom_template').count()
project = Project.objects.create(owner=request.user,
inner_name='custom_template',
workspace_id=workspace.id,
name=u'定制模板{}'.format(count + 1),
type='weapp')
Project.objects.filter(id=project.id).update(
inner_name=project.inner_name + str(project.id))
#导入page
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
custom_template_source_dir = os.path.join(
settings.PROJECT_HOME,
'../webapp/modules/viper_workspace_home_page/project_weapp_custom_template_base/'
)
pages_data_file_path = os.path.join(custom_template_source_dir,
'pages.json')
pages_data_file = open(pages_data_file_path, 'rb')
content = pages_data_file.read()
pages_data_file.close()
for page in json.loads(content):
page_id = page['page_id']
page_component = page['component']
page_component['is_new_created'] = True
pagestore.save_page(str(project.id), page_id, page_component)
response = create_response(200)
response.data = {'project_id': project.id}
return response.get_response()
def get(request):
"""
导航渲染页面
project_id的格式为：
fake:${project_type}:${webapp_owner_id}:${page_id}:${mongodb_id}
"""
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
project_id = 'fake:wepage:%d:navbar' % request.manager.id
page_id = 'navbar'
page = pagestore.get_page(project_id, page_id)
if page:
mongodb_id = str(page['_id'])
else:
mongodb_id = 'new'
project_id = '%s:%s' % (project_id, mongodb_id)
# 是否启用
global_navbar = termite_models.TemplateGlobalNavbar.get_object(
request.manager.id)
c = RequestContext(
request, {
'first_nav_name': FIRST_NAV,
'second_navs': export.get_wepage_second_navs(request),
'second_nav_name': export.WEPAGE_GLOBAL_NAVBAR_NAV,
'is_new_navbar': True,
'project_id': project_id,
'is_enable': global_navbar.is_enable
})
return render_to_response('termite2/global_navbar_editor.html', c)
def __delete_workspaces(workspace_ids):
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
project_ids = []
for workspace_id in workspace_ids:
for project in Project.objects.filter(workspace_id=workspace_id):
print '>>> remove mongo page in project ', project.id
pagestore.remove_project_pages(str(project.id))
project_ids.append(project.id)
Project.objects.filter(id__in=project_ids).delete()
Workspace.objects.filter(id__in=workspace_ids).delete()
def __delete_project(project):
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
#module_project = Project.objects.get(id=project_id)
'''
for jqm_project in Project.objects.filter(datasource_project_id=module_project.id):
pagestore.remove_project_pages(str(jqm_project.id))
Project.objects.filter(datasource_project_id=module_project.id).delete()
'''
pagestore.remove_project_pages(str(project.id))
Project.objects.filter(id=project.id).delete()
def copy_page(project, source_template_id):
"""
从mongodb中拷贝现存project的page数据
"""
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
page_id = 1
page = pagestore.get_page(source_template_id, page_id)
page_component = page['component']
page_component['is_new_created'] = True
pagestore.save_page(str(project.id), page_id, page_component)
return True
def sync_to_user_template_project(request):
"""
将template project同步到所有用户
"""
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
project_id = request.POST['project_id']
page = pagestore.get_first_page(project_id)
project = Project.objects.get(id=project_id)
inner_name = project.inner_name
manager = User.objects.get(username='******')
#workspace_ids = Project.objects.values_list('workspace_id', flat=True).filter(inner_name=inner_name, owner=manager)
#workspace2project = dict([(p.workspace_id, p) for p in Project.objects.filter(workspace_id__in=workspace_ids, inner_name=inner_name)])
#为所有拥有该workspace的用户添加project
source_workspace = Workspace.objects.get(owner=manager, inner_name="home_page")
project = Project.objects.get(owner=manager, workspace=source_workspace, inner_name=inner_name)
for workspace in Workspace.objects.filter(source_workspace_id=source_workspace.id):
is_new_created_page = True
if Project.objects.filter(workspace=workspace, inner_name=inner_name).count() > 0:
#更新
is_new_created_page = False
new_project = Project.objects.get(workspace=workspace, inner_name=inner_name)
new_project_id = str(new_project.id)
else:
#创建
new_project = Project.objects.create(
owner_id = workspace.owner_id,
workspace = workspace,
name = project.name,
inner_name = project.inner_name,
type = project.type,
css = project.css,
pagestore = project.pagestore,
source_project_id = project.id,
datasource_project_id = 0,
template_project_id = 0
)
new_project_id = str(new_project.id)
if project.type == 'jqm':
page_id = page['page_id']
page_component = page['component']
page_component['is_new_created'] = is_new_created_page
pagestore.save_page(new_project_id, page_id, page_component)
response = create_response(200)
return response.get_response()
def api_delete(request):
#删除mongo中project所有的page
project_id = request.POST['id']
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
pagestore.remove_project_pages(str(project_id))
#删除project本身
webapp_models.Project.objects.filter(owner=request.manager,
id=project_id).delete()
#清除webapp page cache
Project.delete_webapp_page_cache(request.manager.id, project_id)
response = create_response(200)
return response.get_response()
def create_empty_app_page(request):
"""
创建新的
"""
_, app_name, _ = request.GET['project_id'].split(':')
page_component = json.loads(request.POST['page_json'])
page_component['is_new_created'] = True
page_id = 1
project_id = 'app:%s:%s:%s' % (app_name, request.manager.id,
time.time())
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
pagestore.save_page(project_id, page_id, page_component)
page = pagestore.get_page(project_id, page_id)
new_project_id = str(page['_id'])
pagestore.update_page_project_id(project_id, page_id, new_project_id)
return new_project_id
def create_empty_page(project):
"""
从硬盘导入空page的json数据到mongodb
"""
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
custom_template_source_dir = os.path.join(
settings.PROJECT_HOME,
'../webapp/modules/viper_workspace_home_page/project_wepage_template_base/'
)
pages_data_file_path = os.path.join(custom_template_source_dir,
'pages.json')
pages_data_file = open(pages_data_file_path, 'rb')
content = pages_data_file.read()
pages_data_file.close()
page = json.loads(content)[0]
page_id = page['page_id']
page_component = page['component']
page_component['is_new_created'] = True
pagestore.save_page(str(project.id), page_id, page_component)
return True
def get_workspace_navs(user):
from webapp.models import Workspace, Project
from termite import pagestore as pagestore_manager
webapp_editor_navs = []
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
for workspace in Workspace.objects.filter(owner=user):
if 'viper:' in workspace.data_backend:
project_id = workspace.data_backend.split(':')[-1]
project = Project.objects.get(id=project_id)
pages = pagestore.get_pages(project_id=project_id)
webapp_editor_nav = {
'section': workspace.name,
'navs': []
}
for page in pages:
page_id = page['page_id']
page_model = page['component']['model']
print page_model
if page_model.get('is_free_page', 'no') == 'yes':
url = '/workbench/viper/page/?project_id=%s&page_id=%s' % (project_id, page_id)
else:
url = '/workbench/viper/records/?project_id=%s&page_id=%s' % (project_id, page_id)
webapp_editor_nav['navs'].append({
'name': page_id,
'url': url,
'title': page['component']['model']['navName']
})
webapp_editor_navs.append(webapp_editor_nav)
elif 'module:' in workspace.data_backend:
webapp_template_info_module = 'webapp.modules.%s.webapp_template_info' % workspace.data_backend.split(':')[-1]
module = __import__(webapp_template_info_module, {}, {}, ['*',])
webapp_editor_navs.append({'section': workspace.name, 'navs':module.NAV['navs']})
else:
pass
return webapp_editor_navs
def update_template_project(request):
"""
从硬盘上更新数据库中的模板project和page信息
"""
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
project_id = request.POST['project_id']
project = Project.objects.get(id=project_id)
#删除已有的page
pagestore.remove_project_pages(project_id)
#更新page
project_dir = '%s/../webapp/modules/viper_workspace_home_page/project_jqm_%s' % (settings.PROJECT_HOME, project.inner_name)
pages_data_file_path = os.path.join(project_dir, 'pages.json')
pages_data_file = open(pages_data_file_path, 'rb')
content = pages_data_file.read()
pages_data_file.close()
has_page = False
for page in json.loads(content):
has_page = True
page_id = page['page_id']
page_component = page['component']
page_component['is_new_created'] = True
pagestore.save_page(str(project.id), page_id, page_component)
if settings.MODE == 'develop' and has_page:
print 'create project\'s pages: %s' % pages_data_file_path
#更新css
# css_dir = os.path.join(settings.TERMITE_HOME, '../static/project_css')
# src_file = os.path.join(project_dir, 'project.css')
# dst_file = os.path.join(css_dir, 'project_%s.css' % project.id)
# shutil.copyfile(src_file, dst_file)
# if settings.MODE == 'develop':
# print 'update css file: %s' % dst_file
response = create_response(200)
return response.get_response()
def __get_modules_page_second_navs(workspaces):
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
second_navs = []
for workspace in workspaces:
if workspace.is_deleted:
continue
if 'viper:' in workspace.data_backend:
project_id = workspace.data_backend.split(':')[-1]
project = Project.objects.get(id=project_id)
#取viper project的source project的page集合
pages = list(pagestore.get_pages(str(project.source_project_id)))
webapp_editor_nav = {'section': workspace.name, 'navs': []}
for page in pages:
page_id = page['page_id']
page_model = page['component']['model']
print page_model
if page_model.get('is_free_page', 'no') == 'yes':
url = '/workbench/viper/page/?project_id=%s&page_id=%s' % (
project_id, page_id)
else:
url = '/workbench/viper/records/?project_id=%s&page_id=%s' % (
project_id, page_id)
webapp_editor_nav['navs'].append({
'name':
page_id,
'url':
url,
'title':
page['component']['model']['navName']
})
#插入“管理模板”
'''
webapp_editor_nav['navs'].append({
'name': 'template',
'url': '/termite/workbench/project/edit/%d/' % workspace.template_project_id,
'title': u'模板管理'
})
'''
second_navs.append(webapp_editor_nav)
elif 'module:' in workspace.data_backend:
export_module_name = 'webapp.modules.%s.export' % workspace.data_backend.split(
':')[-1]
module = __import__(export_module_name, {}, {}, [
'*',
])
#second_navs.append({'section': workspace.name, 'navs':module.NAV['navs']})
nav = copy.deepcopy(module.NAV)
#插入“管理模板”
'''
nav['navs'].append({
'name': 'template',
'url': '/termite/workbench/project/edit/%d/' % workspace.template_project_id,
'title': u'模板管理'
})
'''
second_navs.append(nav)
else:
pass
'''
second_navs.append(
{
'section': u'微站模块',
'navs': [{
'name': 'module',
'title': u'模块管理',
'url': '/webapp/modules/',
}]
}
)
second_navs.append(
{
'section': u'微站统计',
'navs': [{
'name': 'statistics',
'title': u'流量统计',
'url': '/webapp/visit_statistics/',
}]
}
)
'''
return second_navs
def add_module(request):
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
#获得页面上选中的module
module_ids = []
for key, value in request.POST.items():
if key.startswith('module_'):
module_ids.append(int(value))
module_id_set = set(module_ids)
#获得用户已经创建的workspace
existed_workspaces = list(Workspace.objects.filter(owner=request.user))
existed_source_workspace_id_set = set()
modules_need_restore = set()
modules_need_delete = set()
for existed_workspace in existed_workspaces:
existed_source_workspace_id_set.add(
existed_workspace.source_workspace_id)
if (existed_workspace.source_workspace_id
in module_id_set) and existed_workspace.is_deleted:
#已删除的workspace出现在选中的workspace集合中，需要恢复
modules_need_restore.add(existed_workspace.id)
continue
if not (existed_workspace.source_workspace_id in module_id_set):
#已有的workspace不在选中的workspace集合中，需要删除
modules_need_delete.add(existed_workspace.id)
continue
modules_need_add = module_id_set - existed_source_workspace_id_set
#处理需要创建的module workspace
id2module = dict([(workspace.id, workspace)
for workspace in Workspace.objects.filter(
id__in=list(modules_need_add))])
for module_workspace_id, module_workspace in id2module.items():
new_workspace = Workspace.objects.create(
owner=request.user,
name=module_workspace.name,
source_workspace_id=module_workspace.id,
data_backend=module_workspace.data_backend)
module_projects = list(
Project.objects.filter(workspace=module_workspace_id))
#复制workspace下的jqm project，及其page
template_project = None #template_project默认为遇到的第一个jqm project
new_data_backend = None
for module_project in module_projects:
new_project = Project.objects.create(
owner=request.user,
workspace_id=new_workspace.id,
name=module_project.name,
type=module_project.type,
source_project_id=module_project.id,
datasource_project_id=0)
if module_project.type == 'viper':
#跳过viper project，不拷贝page
new_data_backend = 'viper:%d' % new_project.id
continue
pagestore.copy_project_pages(str(module_project.id),
str(new_project.id))
if not template_project:
template_project = new_project
if new_data_backend:
Workspace.objects.filter(id=new_workspace.id).update(
template_project_id=template_project.id,
data_backend=new_data_backend)
else:
Workspace.objects.filter(id=new_workspace.id).update(
template_project_id=template_project.id)
#处理需要恢复的module workspace
#Workspace.objects.filter(id__in=list(modules_need_restore)).update(is_deleted = False)
#处理需要删除的module workspace
#Workspace.objects.filter(id__in=list(modules_need_delete)).update(is_deleted = True)
#做物理删除
__delete_workspaces(list(modules_need_delete))
return HttpResponseRedirect('/webapp/modules/')
def sync_workspace(request):
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
modules_info = json.loads(request.POST['modules_info'])
modules = modules_info['modules']
allow_update = modules_info['allow_update']
modules_dir = os.path.join(settings.PROJECT_HOME, '../webapp/modules')
for module in modules:
module_dir = os.path.join(modules_dir, module)
print 'process module: ', module_dir
#加载workspace的table data json文件
workspace_table_data_file_path = os.path.join(module_dir,
'workspace_table.json')
if os.path.exists(workspace_table_data_file_path):
workspace_table_data_file = open(workspace_table_data_file_path,
'rb')
content = workspace_table_data_file.read()
workspace_table_data_file.close()
data = json.loads(content)
data['owner'] = request.user
del data['id']
try:
workspace = Workspace.objects.get(
owner=request.user, inner_name=data['inner_name'])
except:
workspace = None
if workspace:
if allow_update:
#workspace已经存在，更新之
print 'update workspace: ', workspace.inner_name
Workspace.objects.filter(
owner=request.user,
inner_name=data['inner_name']).update(**data)
else:
print 'not allowed to update workspace'
else:
#workspace不存在，创建之
print 'create workspace: ', data['inner_name']
workspace = Workspace.objects.create(**data)
#TODO: 是否为所有用户创建workspace?
#同步project
apis_dir = os.path.join(settings.PROJECT_HOME, '../webapp')
css_dir = os.path.join(settings.TERMITE_HOME, '../static/project_css')
template_project = None
for file in os.listdir(module_dir):
if not file.startswith('project_'):
continue
project_dir = os.path.join(module_dir, file)
print 'process project: ', project_dir
#加载project的table data json文件
project_table_data_file_path = os.path.join(
project_dir, 'project_table.json')
if not os.path.exists(project_table_data_file_path):
continue
project_table_data_file = open(project_table_data_file_path, 'rb')
content = project_table_data_file.read()
project_table_data_file.close()
data = json.loads(content)
data['owner'] = request.user
data['workspace'] = workspace
del data['id']
allow_update_pages = False #是否允许更新mongo中的pages
try:
project = Project.objects.get(workspace=workspace,
inner_name=data['inner_name'])
if allow_update:
#如果project存在，删除pages
print 'delete pages for project: ', project.inner_name, ' ', project.id
pagestore.remove_project_pages(str(project.id))
allow_update_pages = True
else:
print 'not allowed to remove project\'s pages'
except:
project = None
if project:
if allow_update:
#project已经存在，更新之
print 'update project: %s(%d)-%s' % (
workspace.inner_name, workspace.id, data['inner_name'])
Project.objects.filter(
workspace=workspace,
inner_name=data['inner_name']).update(**data)
else:
print 'not allowed to update project'
else:
#project不存在，创建之
print 'create project: %s-%s' % (workspace.inner_name,
data['inner_name'])
project = Project.objects.create(**data)
'''
if project.type == 'wepage' and project.inner_name == 'empty':
print 'update is_active=True'
project.is_active = True
project.save()
'''
allow_update_pages = True
if project.inner_name == 'default':
template_project = project
#拷贝apis.py
# src_file = os.path.join(project_dir, 'apis.py')
# dst_file = os.path.join(apis_dir, 'apis_%s.py' % project.id)
# shutil.copyfile(src_file, dst_file)
#拷贝project.css
# src_file = os.path.join(project_dir, 'project.css')
# dst_file = os.path.join(css_dir, 'project_%s.css' % project.id)
# shutil.copyfile(src_file, dst_file)
#拷贝pages
if allow_update_pages:
pages_data_file_path = os.path.join(project_dir, 'pages.json')
pages_data_file = open(pages_data_file_path, 'rb')
content = pages_data_file.read()
pages_data_file.close()
has_page = False
for page in json.loads(content):
has_page = True
page_id = page['page_id']
page_component = page['component']
page_component['is_new_created'] = True
pagestore.save_page(str(project.id), page_id,
page_component)
if has_page:
print 'create project\'s pages: %s' % pages_data_file_path
else:
print 'not allowed to re-create pages'
if template_project:
print 'set template project to: ', template_project.id
Workspace.objects.filter(id=workspace.id).update(
template_project_id=template_project.id)
response = create_response(200)
return response.get_response()
def export_workspace(request):
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
workspace_id = request.GET['workspace_id']
workspace = Workspace.objects.get(id=workspace_id)
if not workspace.data_backend:
response = create_response(500)
response.data = u'没有配置数据源，请先配置'
return response.get_response()
#
#获得workspace_dir
#
data_type, name_or_id = workspace.data_backend.split(':')
webapp_modules_dir = os.path.join(settings.PROJECT_HOME,
'../webapp/modules')
workspace_dir = None
if data_type == 'viper':
workspace_name = 'viper_workspace_%s' % workspace.inner_name
workspace_dir = os.path.join(webapp_modules_dir, workspace_name)
'''
if os.path.isdir(workspace_dir):
#删除已存在的workspace
shutil.rmtree(workspace_dir)
#重建workspace目录
os.makedirs(workspace_dir)
'''
elif data_type == 'module':
workspace_name = name_or_id
workspace_dir = os.path.join(webapp_modules_dir, workspace_name)
#
#导出workspace数据表的内容到${workspace_dir}/workspace目录下
#
workspace_data_dir = os.path.join(workspace_dir, 'workspace')
table_data = {
'id': workspace.id,
'name': workspace.name,
'inner_name': workspace.inner_name,
'data_backend': workspace.data_backend,
'source_workspace_id': workspace.source_workspace_id,
'template_project_id': workspace.template_project_id
}
workspace_data_file_path = os.path.join(workspace_dir,
'workspace_table.json')
workspace_data_file = open(workspace_data_file_path, 'wb')
print >> workspace_data_file, json.dumps(table_data, indent=True)
workspace_data_file.close()
#
#删除已存在的project
#
'''
for file in os.listdir(workspace_dir):
if not file.startswith('project_'):
continue
project_dir = os.path.join(workspace_dir, file)
if os.path.isdir(project_dir):
project_info_file_path = os.path.join(project_dir, 'project_info.json')
if os.path.exists(project_info_file_path):
f = open(project_info_file_path, 'rb')
content = f.read()
f.close()
print content
project_info = json.loads(content)
if project_info['type'] == 'raw':
#跳过raw 类型的project
continue
else:
shutil.rmtree(project_dir)
'''
#
#导出project
#
apis_dir = os.path.join(settings.PROJECT_HOME, '../webapp')
css_dir = os.path.join(settings.TERMITE_HOME, '../static/project_css')
for project in Project.objects.filter(workspace_id=workspace.id):
project_name = 'project_%s_%s' % (project.type, project.inner_name)
project_dir = os.path.join(workspace_dir, project_name)
if not os.path.isdir(project_dir):
os.makedirs(project_dir)
#写数据库数据文件
table_data = {
'id': project.id,
'name': project.name,
'inner_name': project.inner_name,
'type': project.type,
'css': project.css,
'pagestore': project.pagestore,
'source_project_id': project.source_project_id,
'datasource_project_id': project.datasource_project_id,
'template_project_id': project.template_project_id
}
data_file_path = os.path.join(project_dir, 'project_table.json')
data_file = open(data_file_path, 'wb')
print >> data_file, json.dumps(table_data, indent=True)
data_file.close()
#拷贝apis.py
src_file = os.path.join(apis_dir, 'apis_%s.py' % project.id)
if os.path.exists(src_file):
dst_file = os.path.join(project_dir, 'apis.py')
shutil.copyfile(src_file, dst_file)
#export project.css
src_file = os.path.join(css_dir, 'project_%s.css' % project.id)
if os.path.exists(src_file):
dst_file = os.path.join(project_dir, 'project.css')
shutil.copyfile(src_file, dst_file)
#导出project中的page
pages = []
for page in pagestore.get_pages(str(project.id)):
del page['_id']
pages.append(page)
data_file_path = os.path.join(project_dir, 'pages.json')
data_file = open(data_file_path, 'wb')
print >> data_file, json.dumps(pages, indent=True)
data_file.close()
response = create_response(200)
return response.get_response()
def api_post(request):
"""
保存(更新)模板项目
"""
project_id = request.POST['id']
field = request.POST['field']
if field == 'page_content_from_zip':
if not Project.import_from_zip_file(request):
response = create_response(501)
response.errMsg = u'导入page失败'
return response.get_response()
elif field == 'page_content':
project_id = request.GET.get('project_id', '')
if project_id.startswith('fake:'):
_, project_type, webapp_owner_id, page_id, mongodb_id = project_id.split(
':')
pagestore = pagestore_manager.get_pagestore_by_type('mongo')
page_component = json.loads(request.POST['page_json'])
if mongodb_id == 'new':
page_component['is_new_created'] = True
real_project_id = 'fake:%s:%s:%s' % (project_type,
webapp_owner_id, page_id)
pagestore.save_page(real_project_id, page_id, page_component)
if mongodb_id == 'new':
page = pagestore.get_page(real_project_id, page_id)
result_project_id = 'fake:%s:%s:%s:%s' % (
project_type, webapp_owner_id, page_id, str(
page['_id']))
else:
result_project_id = project_id
response = create_response(200)
response.data = result_project_id
Project.delete_all_webapp_page_cache(webapp_owner_id)
return response.get_response()
if project_id.startswith('new_app:'):
if project_id.endswith(':0'):
project_id = Project.create_empty_app_page(request)
response = create_response(200)
response.data = {'project_id': project_id}
Project.delete_all_webapp_page_cache(request.manager.id)
return response.get_response()
else:
Project.update_app_page_content(request)
else:
Project.update_page_content(request)
#清除webapp page cache
# Project.delete_webapp_page_cache(request.manager.id, project_id)
elif field == 'is_enable':
webapp_models.Project.objects.filter(id=project_id).update(
is_enable=True)
else:
if field[0] == '[':
fields = json.loads(field)
values = json.loads(request.POST['value'])
options = dict(zip(fields, values))
else:
value = request.POST['value']
options = {field: value}
webapp_models.Project.objects.filter(id=project_id).update(
**options)
key_termite_page = 'termite_webapp_page_%s_*' % request.manager.id
cache_util.delete_pattern(key_termite_page)
purge_webapp_page_from_varnish_cache.delay(request.manager.id)
response = create_response(200)
return response.get_response()
