def isInternal(aot, attr):
'''
функция определяющая внутренний ли это атрибут
'''
#params
attr_prop = Attr_property(aot=aot, attr=attr)
internal = attr_prop.getInternal()
if internal:
return True
else:
return False
def test_update_prop_reference2reference_correct(self):
attr = ATTR.objects.get(id=self.attr_ref.id)
attr_type_def_old = copy(attr.type_def)
response = self.client.get(self.url, { \
'attr_schema': self.attr_schema2.id, \
'object_type': self.object_type1.id, \
'attr': self.attr_ref.id, \
'name': 'test1', \
'description': 'test1', \
'def_value': 'default value', \
'mask': 'YYYY-MM-DD', \
'type': self.attr_type_ref.id, \
'tags': self.tag2.id, \
'ref_object_type': self.object_type2.id, \
'displayed': 'false', \
'multiple': 'true', \
'read_only': 'false', \
'hidden': 'true', \
'required': 'false', \
'calculable': 'true' })
self.assertEqual(response.status_code, 200)
attr = ATTR.objects.get(id=self.attr_ref.id)
self.assertEqual(json.loads(response.content)['success'], True)
self.assertNotEqual(json.loads(response.content)['message'], None)
self.assertEqual(attr.name, 'test1')
self.assertEqual(attr.description, 'test1')
self.assertEqual(attr.def_value, 'default value')
self.assertEqual(attr.mask, 'YYYY-MM-DD')
self.assertEqual(attr.type, self.attr_type_ref)
#set Attr_property
aot = AOT.objects.get(object_type=self.object_type1, schema=self.attr_schema2, attr=self.attr_ref)
attr_prop = Attr_property(aot=aot, attr=attr)
self.assertEqual(attr_prop.getDisplayed(), False)
self.assertEqual(attr_prop.getMultiple(), True )
self.assertEqual(attr_prop.getReadOnly(), False)
self.assertEqual(attr_prop.getHidden(), True )
self.assertEqual(attr_prop.getRequired(), False)
self.assertEqual(attr_prop.getCalculable(), True )
#инициализируем Property
prop = Property(obj=attr)
#сравниваем Tag
self.assertEqual(attr.properties, 'admintool3_tag=%s' % self.tag2.id)
#убеждаемся что reference_old НЕ удалился, т.к. на него могут ссылаться другие атрибуты
attr_type_def_old = Type_def.objects.filter(id=attr_type_def_old.id)
self.assertEqual(attr_type_def_old.count(), 1)
#убеждаемся что reference_new появился
attr_type_def_new = Type_def.objects.get(type=self.attr_type_ref, object_type=self.object_type2, schema=self.attr_schema2)
self.assertEqual(attr.type_def, attr_type_def_new)
def test_update_prop_type_list2list_correct(self):
response = self.client.get(self.url, { \
'attr_schema': self.attr_schema2.id, \
'object_type': self.object_type1.id, \
'attr': self.attr_list.id, \
'name': 'test1', \
'description': 'test1', \
'def_value': 'default value', \
'mask': 'YYYY-MM-DD', \
'type': self.attr_type_list.id, \
'tags': self.tag1.id, \
'ref_list': self.list2.id, \
'displayed': 'true', \
'multiple': 'false', \
'read_only': 'true', \
'hidden': 'false', \
'required': 'true', \
'calculable': 'false' })
self.assertEqual(response.status_code, 200)
attr = ATTR.objects.get(id=self.attr_list.id)
self.assertEqual(json.loads(response.content)['success'], True)
self.assertNotEqual(json.loads(response.content)['message'], None)
self.assertEqual(attr.name, 'test1')
self.assertEqual(attr.description, 'test1')
self.assertEqual(attr.def_value, 'default value')
self.assertEqual(attr.mask, 'YYYY-MM-DD')
self.assertEqual(attr.type, self.attr_type_list)
self.assertEqual(attr.type_def, self.list2)
#set Attr_property
aot = AOT.objects.get(object_type=self.object_type1, schema=self.attr_schema2, attr=self.attr_list)
attr_prop = Attr_property(aot=aot, attr=attr)
self.assertEqual(attr_prop.getDisplayed(), True)
self.assertEqual(attr_prop.getMultiple(), False)
self.assertEqual(attr_prop.getReadOnly(), True)
self.assertEqual(attr_prop.getHidden(), False)
self.assertEqual(attr_prop.getRequired(), True)
self.assertEqual(attr_prop.getCalculable(), False)
#инициализируем Property
prop = Property(obj=attr)
#сравниваем Tag
self.assertEqual(attr.properties, 'admintool3_tag=%s' % self.tag1.id)
#убеждаемся что List остался
list = Type_def.objects.filter(id=self.list.id)
self.assertEqual(list.count(), 1)
#убеждаемся что List2 остался
list2 = Type_def.objects.filter(id=self.list2.id)
self.assertEqual(list2.count(), 1)
def test_create_reference_correct(self):
response = self.client.get(self.url, { \
'attr_schema': self.attr_schema.id, \
'object_type': self.object_type1.id, \
'attr_group': self.attr_group1.id, \
'name': 'Attr_new', \
'description': 'test1', \
'def_value': 'default value', \
'mask': 'YYYY-MM-DD', \
'type': self.attr_type_ref.id, \
'tags': self.tag2.id, \
'ref_object_type': self.object_type2.id, \
'displayed': 'false', \
'multiple': 'true', \
'read_only': 'true', \
'hidden': 'false', \
'required': 'false', \
'calculable': 'false' })
self.assertEqual(response.status_code, 200)
attr = ATTR.objects.get(name='Attr_new')
self.assertEqual(json.loads(response.content)['success'], True)
self.assertNotEqual(json.loads(response.content)['message'], None)
self.assertEqual(attr.description, 'test1')
self.assertEqual(attr.def_value, 'default value')
self.assertEqual(attr.mask, 'YYYY-MM-DD')
self.assertEqual(attr.type, self.attr_type_ref)
self.assertEqual(attr.group, self.attr_group1)
self.assertEqual(attr.schema, self.attr_schema)
aot = AOT.objects.get(schema=self.attr_schema, object_type=self.object_type1, attr=attr, options=0)
#set Attr_property
attr_prop = Attr_property(aot=aot, attr=attr)
self.assertEqual(attr_prop.getDisplayed(), False)
self.assertEqual(attr_prop.getMultiple(), True )
self.assertEqual(attr_prop.getReadOnly(), True )
self.assertEqual(attr_prop.getHidden(), False)
self.assertEqual(attr_prop.getRequired(), False)
self.assertEqual(attr_prop.getCalculable(), False)
attr_type_def = Type_def.objects.get(schema=self.attr_schema, object_type=self.object_type2, type=self.attr_type_ref)
self.assertEqual(attr.type_def, attr_type_def)
#инициализируем Property
prop = Property(obj=attr)
#сравниваем Tag
self.assertEqual(attr.properties, 'admintool3_tag=%s' % self.tag2.id)
def test_update_prop_blank_tag(self):
response = self.client.get(self.url, { \
'attr_schema': self.attr_schema.id, \
'object_type': self.object_type1.id, \
'attr': self.attr1.id, \
'name': 'test1', \
'description': 'test1', \
'def_value': 'default value', \
'mask': 'YYYY-MM-DD', \
'type': self.attr_type2.id, \
'tags': '', \
'displayed': 'true', \
'multiple': 'false', \
'read_only': 'true', \
'hidden': 'false', \
'required': 'true', \
'calculable': 'false' })
self.assertEqual(response.status_code, 200)
attr = ATTR.objects.get(id=self.attr1.id)
self.assertEqual(json.loads(response.content)['success'], True)
self.assertNotEqual(json.loads(response.content)['message'], None)
self.assertEqual(attr.name, 'test1')
self.assertEqual(attr.description, 'test1')
self.assertEqual(attr.def_value, 'default value')
self.assertEqual(attr.mask, 'YYYY-MM-DD')
self.assertEqual(attr.type, self.attr_type2)
#set Attr_property
aot = AOT.objects.get(object_type=self.object_type1, schema=self.attr_schema, attr=self.attr1)
attr_prop = Attr_property(aot=aot, attr=attr)
self.assertEqual(attr_prop.getDisplayed(), True )
self.assertEqual(attr_prop.getMultiple(), False)
self.assertEqual(attr_prop.getReadOnly(), True )
self.assertEqual(attr_prop.getHidden(), False)
self.assertEqual(attr_prop.getRequired(), True )
self.assertEqual(attr_prop.getCalculable(), False)
#инициализируем Property
prop = Property(obj=attr)
#сравниваем Tag
self.assertEqual(attr.properties, None)
def test_update_not_exist_mask(self):
response = self.client.get(self.url, {
'attr_schema': self.attr_schema.id, \
'attrs': [self.be_attr1.id], \
'name': 'test1', \
'description': 'test1', \
'def_value': 'default value', \
'type': self.attr_type2.id, \
'displayed': 'true', \
'multiple': 'false', \
'read_only': 'true', \
'hidden': 'false', \
'required': 'true', \
'calculable': 'false' })
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content)['success'], True)
#check attr1
attr1 = ATTR.objects.get(id=self.attr1.id)
self.assertEqual(attr1.name, 'test1')
self.assertEqual(attr1.description, 'test1')
self.assertEqual(attr1.def_value, 'default value')
self.assertEqual(attr1.mask, None)
self.assertEqual(attr1.type, self.attr_type2)
#set Attr_property
aots = AOT.objects.filter(schema=self.attr_schema, attr=attr1)
for aot in aots:
attr_prop = Attr_property(aot=aot, attr=attr1)
self.assertEqual(attr_prop.getDisplayed(), True )
self.assertEqual(attr_prop.getMultiple(), False)
self.assertEqual(attr_prop.getReadOnly(), True )
self.assertEqual(attr_prop.getHidden(), False)
self.assertEqual(attr_prop.getRequired(), True )
self.assertEqual(attr_prop.getCalculable(), False)
#check be_attr1
be_attr1 = Tree_bulk_edit.objects.get(id=self.be_attr1.id)
self.assertEqual(be_attr1.name, 'test1')
def prepare(schema, aot, attr):
"""
функция по навешиванию доп. свойств на атрибут
"""
if aot.options == 0: attr.origin = 'BIND' #атрибут привязан к данному OT в данной AS
if aot.options == 2: attr.origin = 'UNBIND' #наследованое атрибута прервано на данном OT в данной AS
if aot.options not in (0,2) or aot.options is None: attr.origin = 'UNKNOWN' #непонятный AOT не bind/unbind
attr.schema = schema
attr.binds = binds(attr)
#params
attr_prop = Attr_property(aot=aot, attr=attr)
attr.displayed = attr_prop.getDisplayed()
attr.required = attr_prop.getRequired()
attr.read_only = attr_prop.getReadOnly()
attr.hidden = attr_prop.getHidden()
attr.calculable = attr_prop.getCalculable()
attr.multiple = attr_prop.getMultiple()
return attr
def change_flag(**args):
'''смена флагов атрибута'''
#aot
schema = args['schema']
object_type = args['object_type']
attr = args['attr']
#flags
displayed = args['displayed']
multiple = args['multiple']
read_only = args['read_only']
hidden = args['hidden']
required = args['required']
calculable = args['calculable']
#search AOT
try:
aot = AOT.objects.get(schema=schema, object_type=object_type, attr=attr)
except ObjectDoesNotExist:
AOT().create(schema=schema, object_type=object_type, attr=attr, options=0)
aot = AOT.objects.get(schema=schema, object_type=object_type, attr=attr)
#set Attr_property
attr_prop = Attr_property(aot=aot, attr=attr)
attr_prop.setDisplayed(displayed)
attr_prop.setRequired(required)
attr_prop.setMultiple(multiple)
attr_prop.setReadOnly(read_only)
attr_prop.setHidden(hidden)
attr_prop.setCalculable(calculable)
def worker(req):
"""
получение потомков
"""
error = False
tree = []
schema = req.params()['attr_schema']
#получаем атрибуты
attrs = req.params()['attrs']
#получаем параметры
name = req.params()['name']
description = req.params()['description']
def_value = req.params()['def_value']
mask = req.params()['mask']
type = req.params()['type']
displayed = req.params()['displayed']
multiple = req.params()['multiple']
read_only = req.params()['read_only']
hidden = req.params()['hidden']
required = req.params()['required']
calculable = req.params()['calculable']
if name == None and description == None and def_value == None and \
mask == None and type == None and displayed == None and \
multiple == None and read_only == None and hidden == None and \
required == None and calculable == None:
error = True
reason = "Не отмечено ни одно свойство для изменения"
else:
#обновляем настоящие атрибуты
for attr in attrs:
if name != None: attr.name = name
if description != None: attr.description = description
if def_value != None: attr.def_value = def_value
if mask != None: attr.mask = mask
if type != None: attr.type = type
#set Attr_property
aots = AOT.objects.filter(schema=schema, attr=attr)
for aot in aots:
attr_prop = Attr_property(aot=aot, attr=attr)
attr_prop.setDisplayed(displayed)
attr_prop.setRequired(required)
attr_prop.setMultiple(multiple)
attr_prop.setReadOnly(read_only)
attr_prop.setHidden(hidden)
attr_prop.setCalculable(calculable)
#обновляем Bulk Edit атрибуты
if name:
attr = Tree_bulk_edit.objects.get(orig_id=attr.id.__int__(), type='attr')
attr.name = name
#сохраняем атрибут
attr.save()
if error:
return { "success": False, "errors": reason }
else:
return { "success": True, "message": "Атрибуты успешно отредактированы" }
def worker(req):
"""
функция модификации атрибута
"""
schema = req.params()["attr_schema"]
object_type = req.params()["object_type"]
group = req.params()["attr_group"]
name = req.params()["name"]
description = req.params()["description"]
type = req.params()["type"]
def_value = req.params()["def_value"]
mask = req.params()["mask"]
tags = req.params()["tags"]
displayed = req.params()["displayed"]
multiple = req.params()["multiple"]
read_only = req.params()["read_only"]
hidden = req.params()["hidden"]
required = req.params()["required"]
calculable = req.params()["calculable"]
# создаём атрибут
attr = ATTR.objects.create(
id=nc_id.get(),
group=group,
schema=schema,
type=type,
name=name,
description=description,
def_value=def_value,
mask=mask,
)
# создаём AOT
AOT().create(schema=schema, object_type=object_type, attr=attr, options=0)
aot = AOT.objects.get(schema=schema, object_type=object_type, attr=attr)
# set Attr_property
attr_prop = Attr_property(aot=aot, attr=attr)
attr_prop.setDisplayed(displayed)
attr_prop.setRequired(required)
attr_prop.setMultiple(multiple)
attr_prop.setReadOnly(read_only)
attr_prop.setHidden(hidden)
attr_prop.setCalculable(calculable)
# обновляем Tag если Tags пришли
if not tags == -1:
attr.set(tags=tags)
# TYPE
if attr.type.id == 7:
# это List
req = ListRequired(request=req.request, req_params=["ref_list"])
if req.success():
# создаём ссылку на List
attr.type_def = req.params()["ref_list"]
else:
return {"success": False, "errors": req.errors()}
if attr.type.id == 9:
# это Reference
req = OTRequired(request=req.request, req_params=["ref_object_type"])
if req.success():
# создаём Reference
attr.type_def = Type_def.objects.create(
id=nc_id.get(), type=attr.type, schema=schema, object_type=req.params()["ref_object_type"]
)
else:
return {"success": False, "errors": req.errors()}
# сохраняем атрибут
attr.save()
return {"success": True, "message": "Атрибут %s успешно создан" % str(attr.id)}