def post(self, request, app_name, env_name, app_path):
action = request.data['action']
if action == 'rename':
env_path = _get_existent_env_path(app_path, env_name)
new_env_name = request.data['name']
check_name(new_env_name)
new_env_path = _get_absent_env_path(app_path, new_env_name)
stop_patsaks(get_id(request.dev_name, app_name, env_name))
write_file(new_env_path, new_env_name)
schema_prefix = get_id(request.dev_name, app_name) + ':'
execute_sql(
'SELECT ak.rename_schema(%s, %s)',
(schema_prefix + env_name.lower(),
schema_prefix + new_env_name.lower()))
os.remove(env_path)
return HttpResponse()
if action == 'eval':
request.lock.release()
request.lock = None
if env_name == _RELEASE_ENV_NAME:
env_name = None
response = send_to_ecilop(
'EVAL ' + get_id(request.dev_name, app_name, env_name),
request.data['expr'])
assert response
status = response[0]
result = response[1:]
assert status in ('E', 'F', 'S')
if status == 'E':
raise Error(result, status=NOT_FOUND)
return {'ok': status == 'S', 'result': result}
raise Error('Unknown action: "%s"' % action)
def post(self, request, app_name, env_name, app_path):
action = request.data['action']
if action == 'rename':
env_path = _get_existent_env_path(app_path, env_name)
new_env_name = request.data['name']
check_name(new_env_name)
new_env_path = _get_absent_env_path(app_path, new_env_name)
stop_patsaks(get_id(request.dev_name, app_name, env_name))
write_file(new_env_path, new_env_name)
schema_prefix = get_id(request.dev_name, app_name) + ':'
execute_sql('SELECT ak.rename_schema(%s, %s)',
(schema_prefix + env_name.lower(),
schema_prefix + new_env_name.lower()))
os.remove(env_path)
return HttpResponse()
if action == 'eval':
request.lock.release()
request.lock = None
if env_name == _RELEASE_ENV_NAME:
env_name = None
response = send_to_ecilop(
'EVAL ' + get_id(request.dev_name, app_name, env_name),
request.data['expr'])
assert response
status = response[0]
result = response[1:]
assert status in ('E', 'F', 'S')
if status == 'E':
raise Error(result, status=NOT_FOUND)
return {'ok': status == 'S', 'result': result}
raise Error('Unknown action: "%s"' % action)
def __init__(self, node, tree):
""" Constructor
Keyword arguments:
node -- XML node defining this event
tree -- currently evaluted communication structure tree
Resets the 'abstract' flag for every component beeing contained here.
"""
self.name = node.get('name')
utils.check_name(self.name)
bootloader = node.find('bootloader')
if bootloader != None:
bootloader = bootloader.attrib
self.bootloader = bootloader
self.description = xml_utils.get_description(node)
self.components = utils.SingleAssignDictionary("component")
self.events = EventContainer()
self.subscriptions = {}
self.indexReady = False
for node in node.findall('component'):
component_name = node.get('name')
try:
component = tree.components[component_name]
component.abstract = False
self.components[component_name] = component
except KeyError:
raise ParserException("Unknown component '%s' in container '%s'." % (component_name, self.name))
def __init__(self, node, tree):
""" Constructor
Keyword arguments:
node -- XML node defining this event
tree -- currently evaluted communication structure tree
Resets the 'abstract' flag for every component beeing contained here.
"""
self.name = node.get('name')
utils.check_name(self.name)
bootloader = node.find('bootloader')
if bootloader != None:
bootloader = bootloader.attrib
self.bootloader = bootloader
self.description = xml_utils.get_description(node)
self.components = utils.SingleAssignDictionary("component")
self.events = EventContainer()
self.subscriptions = {}
self.indexReady = False
for node in node.findall('component'):
component_name = node.get('name')
try:
component = tree.components[component_name]
component.abstract = False
self.components[component_name] = component
except KeyError:
raise ParserException(
"Unknown component '%s' in container '%s'." %
(component_name, self.name))
def post(self, request, app_name, app_path):
env_name = request.data['name']
check_name(env_name)
env_path = _get_absent_env_path(app_path, env_name)
execute_sql(CREATE_SCHEMA_SQL,
(get_id(request.dev_name, app_name, env_name), ))
write_file(env_path, env_name)
return HttpResponse(status=CREATED)
def post(self, request, app_name, app_path):
env_name = request.data['name']
check_name(env_name)
env_path = _get_absent_env_path(app_path, env_name)
execute_sql(
CREATE_SCHEMA_SQL, (get_id(request.dev_name, app_name, env_name),))
write_file(env_path, env_name)
return HttpResponse(status=CREATED)
def __init__(self, node, tree):
self.name = node.get('name')
utils.check_name(self.name)
self.description = xml_utils.get_description(node)
self.id = xml_utils.get_identifier(node)
self.parameterType = self.__get_type(node, "parameterType", tree)
self.returnType = self.__get_type(node, "returnType", tree)
def __init__(self, node, tree):
self.name = node.get('name')
utils.check_name(self.name)
self.description = xml_utils.get_description(node)
self.id = xml_utils.get_identifier(node)
self.parameterType = self.__get_type(node, "parameterType", tree)
self.returnType = self.__get_type(node, "returnType", tree)
def __init__(self, node):
self.node = node
self.name = node.get('name')
utils.check_name(self.name)
self.description = None
self.id = None
self.extends = None
self.abstract = True
self.__flattened = None
self.actions = utils.SingleAssignDictionary("action")
self.events = EventContainer()
def __init__(self, node):
self.node = node
self.name = node.get('name')
utils.check_name(self.name)
self.description = None
self.id = None
self.extends = None
self.abstract = True
self.__flattened = None
self.actions = utils.SingleAssignDictionary("action")
self.events = EventContainer()
def role_create(auth_info, **kwargs):
if auth_info['code'] == 1:
return json.dumps(auth_info)
username = auth_info['username']
if '1' not in auth_info['r_id']:
return json.dumps({'code': 1, 'errmsg': 'you not admin,no power'})
try:
data = request.get_json()['params']
if not data.has_key('p_id'):
return json.dumps({'code': 1, 'errmsg': 'must hava p_id'})
if not app.config['cursor'].if_id_exist('power',
data['p_id'].split(',')):
return json.dumps({'code': 1, 'errmsg': 'p_id not exist'})
if not utils.check_name(data['name']):
return json.dumps({
'code': 1,
'errmsg': 'name must be string or int'
})
app.config['cursor'].execute_insert_sql('role', data)
utils.write_log('api').info(username,
"create role %s scucess" % data['name'])
return json.dumps({
'code': 0,
'result': 'create role %s scucess' % data['name']
})
except:
utils.write_log('api').error(
username, "create role error: %s" % traceback.format_exc())
return json.dumps({'code': 1, 'errmsg': 'create role fail'})
def register():
"""
Attempts to register the user with the given account information.
"""
name = request.form['name']
email = request.form['email']
password = request.form['password']
repassword = request.form['repassword']
name_error = check_name(name)
if name_error != None:
# malformed name
return jsonify({'type': 'error', 'error': name_error})
email_error = check_email(email)
if email_error != None:
# malformed e-mail
return jsonify({'type': 'error', 'error': email_error})
password_error = check_password(password, repassword)
if password_error != None:
# malformed password
return jsonify({'type': 'error', 'error': password_error})
user_exists = db.user_exists(email)
if user_exists:
# user with this e-mail already exists
error = 'An account with this e-mail address already exists!'
return jsonify({'type': 'error', 'error': error})
user = db.make_user(name, email, password)
flash('Welcome to Bookmark+, %s!' % user.name)
session['user_id'] = unicode(user._id)
return jsonify({'type': 'success', 'url': url_for('home')})
def createuser(auth_info,*arg,**kwargs):
if auth_info['code'] == 1:
return json.dumps(auth_info)
username = auth_info['username']
r_id = auth_info['r_id'] #string, eg: '1,2,3'
if '1' not in r_id: #角色id = 1 为sa组，超级管理员
return json.dumps({'code': 1,'errmsg':'you not admin,no power' })
try:
data = request.get_json()['params']
#api端对传入端参数验证
if 'r_id' not in data:
return json.dumps({'code': 1, 'errmsg': "must need a role!"})
if not app.config['cursor'].if_id_exist('role',data['r_id'].split(',')):
return json.dumps({'code': 1, 'errmsg': "Role not exist!"})
if not utils.check_name(data['username']):
return json.dumps({'code': 1, 'errmsg': "username must be string or num!"})
if data['password'] != data['repwd']:
return json.dumps({'code': 1, 'errmsg': "password equal repwd!"})
elif len(data['password']) < 6:
return json.dumps({'code': 1, 'errmsg': 'passwd must over 6 string !'})
else:
data.pop('repwd') #传入的第二次密码字段不存在，需要删除
data['password'] = hashlib.md5(data['password']).hexdigest()
data['join_date'] = time.strftime('%Y-%m-%d %H:%M:%S')
app.config['cursor'].execute_insert_sql('user', data)
utils.write_log('api').info(username, "create_user %s" % data['username'])
return json.dumps({'code': 0, 'result': 'create user %s success' % data['username']})
except:
utils.write_log('api').error("Create user error: %s" % traceback.format_exc())
return json.dumps({'code': 1, 'errmsg': 'Create user failed'})
def post(self, request):
dev_name = request.data['name']
check_name(dev_name)
if dev_name.startswith(ANONYM_PREFIX):
raise Error(
'Names starting with "%s" are reserved.' % ANONYM_PREFIX,
'Please choose another name.')
try:
user = User.objects.get(username__iexact=dev_name)
except User.DoesNotExist:
pass
else:
raise Error(
'The user "%s" already exists.' % user.username,
'Name must be be case-insensitively unique.')
email = request.data['email']
try:
validate_email(email)
except ValidationError:
raise Error('The email "%s" is incorrect.' % email,
'Please correct the email.')
if User.objects.filter(email=email):
raise Error(
'The email "%s" has already been taken.' % email,
'Please choose another email.')
user = User.objects.create_user(
dev_name, email, request.data['password'])
user.save()
if request.is_half_anonymous:
_stop_dev_patsaks(request.dev_name)
old_dev_path = ROOT.devs[request.dev_name]
dev_path = ROOT.devs[dev_name]
os.rename(old_dev_path, dev_path)
os.mkdir(old_dev_path)
os.symlink(dev_path.tablespace, old_dev_path.tablespace)
os.rename(
dev_path.grantors[request.dev_name],
dev_path.grantors[dev_name])
os.rename(ROOT.locks[request.dev_name], ROOT.locks[dev_name])
execute_sql(
'SELECT ak.rename_dev(%s, %s)',
(request.dev_name, dev_name.lower()))
else:
create_dev(dev_name)
user.backend = AUTHENTICATION_BACKENDS[0]
auth.login(request, user)
return HttpResponse(status=CREATED)
def __call__(self, form, field):
length = field.data and len(field.data) or 0
if length == 0:
pass
elif check_name(field.data):
pass
else:
raise ValidationError(self.message)
def post(self, request, project):
serializer = TestcaseSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
try:
case_name = serializer.validated_data['name']
case_type = serializer.validated_data['type']
case_description = serializer.validated_data['description']
case_script_path = serializer.validated_data['script_path']
case_config_path = serializer.validated_data['config_path']
case_parameters = serializer.validated_data['parameters']
case_feature = serializer.validated_data['feature']
suite_list = serializer.validated_data['testsuite']
except KeyError:
return Response({'detail': unicode("The lack of required parameters.")},
status=status.HTTP_400_BAD_REQUEST)
perf = serializer.validated_data.get('performance', False)
app = serializer.validated_data.get('app', None)
if perf and not app:
return Response({'detail': unicode("parameter app must provide when performance=True")},
status=status.HTTP_400_BAD_REQUEST)
if not perf and app:
return Response({'detail': unicode("parameter app can not be set when performance=False")},
status=status.HTTP_400_BAD_REQUEST)
if not check_name(TestCase, case_name, project, check_flag=True):
return Response({'detail': unicode("Found same name testcase, "
"please check your testcase name.")},
status=status.HTTP_409_CONFLICT)
for suite in suite_list:
if suite.performance != perf or suite.app != app:
return Response({'detail': unicode("suite:{0} not match test case of "
"performance type".format(suite.id))},
status=status.HTTP_409_CONFLICT)
new_case = TestCase.objects.create(
name=case_name,
type=case_type,
description=case_description,
script_path=case_script_path,
config_path=case_config_path,
parameters=case_parameters,
feature=case_feature,
performance=perf,
app=app,
project=get_project_object(project)
)
for suite in suite_list:
new_case.testsuite.add(suite)
new_case.save()
new_serializer = TestcaseSerializer(new_case)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request):
dev_name = request.data['name']
check_name(dev_name)
if dev_name.startswith(ANONYM_PREFIX):
raise Error(
'Names starting with "%s" are reserved.' % ANONYM_PREFIX,
'Please choose another name.')
try:
user = User.objects.get(username__iexact=dev_name)
except User.DoesNotExist:
pass
else:
raise Error('The user "%s" already exists.' % user.username,
'Name must be be case-insensitively unique.')
email = request.data['email']
try:
validate_email(email)
except ValidationError:
raise Error('The email "%s" is incorrect.' % email,
'Please correct the email.')
if User.objects.filter(email=email):
raise Error('The email "%s" has already been taken.' % email,
'Please choose another email.')
user = User.objects.create_user(dev_name, email,
request.data['password'])
user.save()
if request.is_half_anonymous:
_stop_dev_patsaks(request.dev_name)
old_dev_path = ROOT.devs[request.dev_name]
dev_path = ROOT.devs[dev_name]
os.rename(old_dev_path, dev_path)
os.mkdir(old_dev_path)
os.symlink(dev_path.tablespace, old_dev_path.tablespace)
os.rename(dev_path.grantors[request.dev_name],
dev_path.grantors[dev_name])
os.rename(ROOT.locks[request.dev_name], ROOT.locks[dev_name])
execute_sql('SELECT ak.rename_dev(%s, %s)',
(request.dev_name, dev_name.lower()))
else:
create_dev(dev_name)
user.backend = AUTHENTICATION_BACKENDS[0]
auth.login(request, user)
return HttpResponse(status=CREATED)
def deleteAddressbooks(name):
resultCheckName = utils.check_name(name)
if resultCheckName[0]:
return resultCheckName
dbResult= db.deletePerson(name)
if not dbResult[0]:
return response_error(dbResult[1],400)
return response_success(name+" is deleted",204)
def __init__(self, node, tree):
""" Constructor
Keyword arguments:
node -- XML node defining this event
tree -- currently evaluted communication structure tree
"""
self.name = node.get('name')
utils.check_name(self.name)
self.id = xml_utils.get_identifier(node)
self.description = xml_utils.get_description(node)
self.rate = node.get('rate')
type = node.get('type')
if type is None:
self.type = None
else:
try:
self.type = tree.types[type]
except KeyError as e:
raise ParserException("Type '%s' is not defined. Used by Event '%s')" % (type, self.name))
def create(auth_info, **kwargs):
username = auth_info['username']
if '1' not in auth_info['r_id']
return json.dumps({'code':1, 'errmsg':'you are not admin, no power'})
try:
data = request.get_json()['params']
if not utils.check_name(data['name'])
return json.dumps({'code':1, 'errmsg':'name must be stirng or num'})
app.config['db'].execute_insert_sql('power', data)
utils.write_log('api').info('%s create power %s success' % (username, data['name']))
return json.dumps({'code':0 , 'result': '%s create %s success' % (username, data[name]}))
except:
utils.write_log('api').error('create power error' % traceback.format_exec())
return json.dumps({'code':1 , 'errmsg': 'create power failed' })
def __init__(self, node, tree):
""" Constructor
Keyword arguments:
node -- XML node defining this event
tree -- currently evaluted communication structure tree
"""
self.name = node.get('name')
utils.check_name(self.name)
self.id = xml_utils.get_identifier(node)
self.description = xml_utils.get_description(node)
self.rate = node.get('rate')
type = node.get('type')
if type is None:
self.type = None
else:
try:
self.type = tree.types[type]
except KeyError as e:
raise ParserException(
"Type '%s' is not defined. Used by Event '%s')" %
(type, self.name))
def post(self, request, project):
serializer = TestexecutionOsSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
os_name = serializer.data['name']
if not check_name(OS, os_name, project):
return Response({'detail': unicode("Found same name OS, please check your OS name.")},
status=status.HTTP_409_CONFLICT)
new_os = OS.objects.create(name=os_name, project=get_project_object(project))
new_os.save()
new_serializer = TestexecutionOsSerializer(new_os)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project):
serializer = TestexecutionPlatformSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
platform_name = serializer.data['name']
if not check_name(Platform, platform_name, project):
return Response({'detail': unicode("Found same name platform, please check your platform name.")},
status=status.HTTP_409_CONFLICT)
new_platform = Platform.objects.create(name=platform_name, project=get_project_object(project))
new_platform.save()
new_serializer = TestexecutionPlatformSerializer(new_platform)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project):
serializer = TestsuiteSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
try:
suite_name = serializer.validated_data['name']
suite_subsystem = serializer.validated_data['subsystem']
suite_description = serializer.validated_data['description']
plan_list = serializer.validated_data['testplan']
except KeyError:
return Response({'detail': unicode("The lack of required parameters.")},
status=status.HTTP_400_BAD_REQUEST)
perf = serializer.validated_data.get('performance', False)
app = serializer.validated_data.get('app', None)
if perf and not app:
return Response({'detail': unicode("parameter app must provide when performance=True")},
status=status.HTTP_400_BAD_REQUEST)
if not perf and app:
return Response({'detail': unicode("parameter app can not be set when performance=False")},
status=status.HTTP_400_BAD_REQUEST)
if not check_name(TestSuite, suite_name, project, check_flag=True):
return Response({'detail': unicode("Found same name testsuite, "
"please check your testsuite name.")},
status=status.HTTP_409_CONFLICT)
for plan in plan_list:
if plan.performance != perf or plan.app != app:
return Response({'detail': unicode("plan:{0} not match test suite of "
"performance type".format(plan.id))},
status=status.HTTP_409_CONFLICT)
new_suite = TestSuite.objects.create(
name=suite_name,
subsystem=suite_subsystem,
performance=perf,
app=app,
description=suite_description,
project=get_project_object(project)
)
for plan in plan_list:
new_suite.testplan.add(plan)
new_suite.save()
new_serializer = TestsuiteSerializer(new_suite)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project):
serializer = TestcaseTypeSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
type_name = serializer.data['name']
if not check_name(TestCaseType, type_name, project):
return Response({'detail': unicode("Found same name type, please check your type name.")},
status=status.HTTP_409_CONFLICT)
new_type = TestCaseType.objects.create(
name=type_name,
project=get_project_object(project)
)
new_serializer = TestcaseTypeSerializer(new_type)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project):
serializer = TestsuiteSubsystemSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
subsystem_name = serializer.data['name']
if not check_name(Subsystem, subsystem_name, project):
return Response({'detail': unicode("Found same name subsystem, "
"please check your subsystem name.")},
status=status.HTTP_409_CONFLICT)
new_subsystem = Subsystem.objects.create(
name=subsystem_name,
project=get_project_object(project)
)
new_serializer = TestsuiteSubsystemSerializer(new_subsystem)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def create(**kwargs):
try:
data = request.get_json()['params']
if not utils.check_name(data['name']):
return json.dumps({
'code': 1,
'errmsg': 'name must be string or num'
})
app.config['cursor'].execute_insert_sql('power', data)
utils.write_log('api').info(username,
"create power %s sucess" % data['name'])
return json.dumps({
'code': 0,
'result': 'create %s sucess' % data['name']
})
except Exception, e:
utils.write_log('api').error('create power error:%s' %
traceback.format_exc())
return json.dumps({'code': 1, 'errmsg': 'create power failed'})
def role_create(auth_info, **kwargs):
if auth_info['code'] == 1:
return json.dumps(auth_info)
username = auth_info['username']
if '1' not in auth_info['r_id']
return json.dumps({'code':1, 'errmsg': 'you are not admin, no power'})
try:
data = request.get_json()['params']
if not data.has_key('p_id'):
return json.dumps({"code":1, "errmsg":"must have a p_id!"})
if not app.config['db'].if_id_exist("power",data['p_id'].split(',')):
return json.dumps({"code":1, "errmsg":"p_id not exist!"})
if not utils.check_name(data['username']):
return json.dumps({"code":1, "errmsg":"username must be string or num!"})
app.config['db'].execute_insert_sql('role', data)
utils.write_log('api').info('%s create role %s success' % (username, data['name']))
return json.dumps({'code':0 , 'result': '%s create role %s success' % (username, data[name]}))
except:
utils.write_log('api').error('create role error' % traceback.format_exec())
return json.dumps({'code':1 , 'errmsg': 'create role failed' })
def post(self, request, project):
serializer = AppSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
app_name = serializer.data['name']
if not check_name(App, app_name, project):
return Response(
{
'detail':
unicode("Found same name app, please check your app name.")
},
status=status.HTTP_409_CONFLICT)
new_app = App.objects.create(name=app_name,
project=get_project_object(project))
new_app.save()
new_serializer = AppSerializer(new_app)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project):
serializer = TestPlanCategorySerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
category_name = serializer.data['name']
if not check_name(Category, category_name, project):
return Response(
{
'detail':
unicode("Found same name category, "
"please check your category name.")
},
status=status.HTTP_409_CONFLICT)
new_category = Category.objects.create(
name=category_name, project=get_project_object(project))
new_serializer = TestPlanCategorySerializer(new_category)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project):
auth_status, message = check_auth(request.user, project, 'writer')
if not auth_status:
return Response(message, status=status.HTTP_401_UNAUTHORIZED)
serializer = FeatureSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
try:
fea_name = serializer.data['name']
fea_owner = serializer.data['owner']
fea_component = serializer.data['component']
fea_requirement = serializer.data['requirement']
fea_description = serializer.data['description']
except KeyError:
return Response({'detail': unicode("The lack of required parameters.")},
status=status.HTTP_400_BAD_REQUEST)
if not check_name(Feature, fea_name, project):
return Response({'detail': unicode("Found same name feature, "
"please check your feature name.")},
status=status.HTTP_409_CONFLICT)
if not check_owner_runner(request.user, fea_owner):
return Response({'detail': unicode("The owner should be current user - {0}".format(request.user))},
status=status.HTTP_400_BAD_REQUEST)
new_fea = Feature.objects.create(
name=fea_name,
owner=fea_owner,
component_id=fea_component,
requirement_id=fea_requirement,
description=fea_description,
project=get_project_object(project)
)
new_serializer = FeatureSerializer(new_fea)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project):
auth_status, message = check_auth(request.user, project, 'writer')
if not auth_status:
return Response(message, status=status.HTTP_401_UNAUTHORIZED)
serializer = FeatureComponentSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
component_name = serializer.data['name']
if not check_name(Component, component_name, project):
return Response({'detail': unicode("Found same name componet, "
"please check your componet name.")},
status=status.HTTP_409_CONFLICT)
new_component = Component.objects.create(
name=component_name,
project=get_project_object(project)
)
new_serializer = FeatureComponentSerializer(new_component)
return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def create(auth_info, *arg, **kwargs):
if auth_info['code'] == 1:
return json.dumps(auth_info)
username = auth_info['username']
if '1' not in auth_info['r_id']:
return json.dumps({'code': 1, 'errmsg': 'you not admin,no power'})
try:
data = request.get_json()['params']
if not utils.check_name(data['name']):
return json.dumps({
'code': 1,
'errmsg': 'name must be string or num'
})
app.config['cursor'].execute_insert_sql('power', data)
utils.write_log('api').info(username,
"create power %s success" % data['name'])
return json.dumps({
'code': 0,
'result': 'create %s success' % data['name']
})
except:
utils.write_log('api').error('create power error:%s' %
traceback.format_exc())
return json.dumps({'code': 1, 'errmsg': 'create power failed'})
def post(self, request):
app_name = request.data['name']
check_name(app_name)
create_app(request.dev_name, app_name)
return HttpResponse(status=CREATED)
def test_check_name(self):
assert check_name('') is not None
assert check_name('# @') is not None
assert check_name('Ben Bitdiddle') is None
assert check_name('Ben 22 Bitdiddle') is None
else:
model = UNet(1 + (e2d*2), 1, residual=res, small=small, bias=bias, bn=bn)
if model_folder is not None:
path = glob.glob(os.path.join(model_folder, "*" + o + ".pt"))[0]
model.load_state_dict(torch.load(path))
models[o] = model
return models
results = {}
for basename in bnames:
print(basename)
model_folder = os.path.join(basepath, basename)
print("Save point: {}".format(model_folder))
bias = not check_name("nobias", basename)
e2d = check_name("E2D", basename)
res = check_name("RES", basename)
small = check_name("SMALL", basename)
adam = check_name("ADAM", basename)
bn = not check_name("NOBN", basename)
dunet = check_name("DUNET", basename)
mixed = check_name("MIXED", basename)
# Main volumetric performance test
if volume:
print("Calculating performance in volume")
if db_name == "cc359":
def save_doc_photo_end(bot, update):
Bot.get_file(Bot(TG_TOKEN), bot.message.photo[0].file_id).download(
os.path.join(FILES_PATH, check_name('new.jpg')))
bot.message.reply_text('Ваше фото сохранено', reply_markup=get_keyboard())
return ConversationHandler.END
def post(self, request):
app_name = request.data['name']
check_name(app_name)
create_app(request.dev_name, app_name)
return HttpResponse(status=CREATED)
def save_doc_document_end(bot, update):
Bot.get_file(Bot(TG_TOKEN), bot.message.document.file_id).download(
os.path.join(FILES_PATH, check_name(bot.message.document.file_name)))
bot.message.reply_text('Ваш документ сохранен',
reply_markup=get_keyboard())
return ConversationHandler.END
def _check_name(self): utils.check_name(self.name)
def _check_name(self):
utils.check_name(self.name)
