def AssetType_add(request):
assettypeform = AssetTypeForm(request.POST)
if assettypeform.is_valid():
type_id = assettypeform.cleaned_data.get('type_id')
if AssetType.objects.filter(type_id=type_id).count() > 0:
error_message = '{} 已存在!'.format(
assettypeform.cleaned_data.get('type_id'))
return JsonResponse({"code": 400, "err": error_message})
assettype = AssetType()
assettype.type_name = assettypeform.cleaned_data.get('type_name')
assettype.type_id = assettypeform.cleaned_data.get('type_id')
assettype.save()
name = "新增资产类型"
event_type = 9
asset = None
new_asset = None
component = None
detail = "新增资产类型：{0}-{1}".format(assettype.type_id,
assettype.type_name)
username = request.session.get('username')
user = User.objects.get(username=username)
address = request.META.get('REMOTE_ADDR', None)
useragent = request.META.get('HTTP_USER_AGENT', None)
event_log(name, event_type, asset, new_asset, component, detail, user,
address, useragent)
return JsonResponse({"code": 200, "pk": assettype.pk, "err": ""})
else:
error_message = '请检查填写的内容!'
return JsonResponse({"code": 401, "err": error_message})
def setUp(self):
article = AssetType(type_name="article",
schema={
"title": 1,
"content": [self.at("block").pk]
})
article.save()
def test_unknown_enum(self):
enum_test_type = EnumType(items=["a", "b", "c"])
enum_test_type.save()
enum_test_asset_type = AssetType(
type_name="enum-test", schema={"enum": {
"3": enum_test_type.pk
}})
enum_test_asset_type.save()
response = self.client.post(reverse('save_asset'),
data={
"type": "enum-test",
"enum": "d"
},
content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertJSONEqual(
response.content, {
"Error":
"The Schema of AssetType 'enum-test' demands the content for key 'enum' "
+ "to be the enum_type with id=%d." % enum_test_type.pk,
"Asset": {
"type": "enum-test",
"enum": "d"
}
})
def test_no_raw_template(self):
insufficient_type = AssetType(type_name="insufficient_type",
schema={"text": 1},
templates={})
insufficient_type.save()
t = Text(text="Foobar!")
t.save()
asset = Asset(t=insufficient_type, content_ids={"text": t.pk})
asset.save()
self.assertEqual(asset.render_template(), "")
def setUp(self) -> None:
self.client = Client()
article = AssetType(type_name="article",
schema={
"title":
1,
"subtitle":
1,
"author":
1,
"abstract":
1,
"content":
[AssetType.objects.get(type_name="block").pk]
})
article.save()
def test_unknown_enum_type(self):
enum_test_asset_type = AssetType(type_name="enum-test",
schema={"enum": {
"3": 3
}})
enum_test_asset_type.save()
response = self.client.post(reverse('save_asset'),
data={
"type": "enum-test",
"enum": "tuiornuidtaeosuien"
},
content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertJSONEqual(
response.content, {
"Error": "Unknown EnumType: tuiornuidtaeosuien.",
"Asset": {
"type": "enum-test",
"enum": "tuiornuidtaeosuien"
}
})
def test_text_list_template(self):
ul = AssetType(
type_name="ul",
schema={"texts": [1]},
templates={
"raw": "{{for(texts)}} - {{texts}}\n{{endfor}}",
"html":
"<ul>{{for(texts)}}\n <li>{{texts}}</li>{{endfor}}\n</ul>"
})
ul.save()
t1 = Text(text="Foo")
t1.save()
t2 = Text(text="Bar")
t2.save()
t3 = Text(text="Baz")
t3.save()
asset = Asset(t=ul, content_ids={"texts": [t1.pk, t2.pk, t3.pk]})
asset.save()
self.assertEqual(
asset.render_template("html"),
"<ul>\n <li>Foo</li>\n <li>Bar</li>\n <li>Baz</li>\n</ul>")
self.assertEqual(asset.render_template(), " - Foo\n - Bar\n - Baz\n")
def test_asset_all_types_template(self):
all_type = AssetType(type_name="all_type",
schema={
"text": 1,
"url": 2,
"enum": {
"3": 2
},
"asset": 4,
"texts": [1],
"urls": [2],
"enums": [{
"3": 2
}],
"assets": [4]
},
templates={
"raw":
"""
text: {{text}}
url: {{url}}
enum: {{enum}}
asset: {{asset}}
texts:{{for(texts)}}
- {{texts}}{{endfor}}
urls:{{for(urls)}}
- {{urls}}{{endfor}}
enums:{{for(enums)}}
- {{enums}}{{endfor}}
assets:{{for(assets)}}
- {{assets}}{{endfor}}
"""
})
all_type.save()
t1 = Text(text="Foo")
t1.save()
t2 = Text(text="Bar")
t2.save()
l1 = UriElement(uri="http://ct.de/a")
l1.save()
l2 = UriElement(uri="http://ct.de/b")
l2.save()
e1 = Enum(t=EnumType.objects.get(pk=2), item="python")
e1.save()
e2 = Enum(t=EnumType.objects.get(pk=2), item="c")
e2.save()
e3 = Enum(t=EnumType.objects.get(pk=2), item="d")
e3.save()
a1 = Asset(t=AssetType.objects.get(type_name="span-regular"),
content_ids={"text": t2.pk})
a1.save()
a2 = Asset(t=AssetType.objects.get(type_name="span-emphasized"),
content_ids={"text": t1.pk})
a2.save()
asset = Asset(t=all_type,
content_ids={
"text": t1.pk,
"url": l1.pk,
"enum": e1.pk,
"asset": str(a1.pk),
"texts": [t1.pk, t2.pk],
"urls": [l1.pk, l2.pk],
"enums": [e1.pk, e2.pk, e3.pk],
"assets": [str(a1.pk), str(a2.pk)]
})
asset.save()
self.maxDiff = None
self.assertJSONEqual(
json.dumps(asset.content),
json.dumps({
"id":
str(asset.pk),
"type":
"all_type",
"text":
"Foo",
"url":
"http://ct.de/a",
"enum":
"python",
"asset": {
"id": str(a1.pk),
"type": "span-regular",
"text": "Bar"
},
"texts": ["Foo", "Bar"],
"urls": ["http://ct.de/a", "http://ct.de/b"],
"enums": ["python", "c", "d"],
"assets": [{
"id": str(a1.pk),
"type": "span-regular",
"text": "Bar"
}, {
"id": str(a2.pk),
"type": "span-emphasized",
"text": "Foo"
}]
}))
self.assertIsNone(asset.raw_content_cache)
self.assertEqual(
asset.render_template(), """
text: Foo
url: http://ct.de/a
enum: python
asset: Bar
texts:
- Foo
- Bar
urls:
- http://ct.de/a
- http://ct.de/b
enums:
- python
- c
- d
assets:
- Bar
- Foo
""")
self.assertIsNotNone(asset.raw_content_cache)
self.assertEqual(
asset.render_template(), """
text: Foo
url: http://ct.de/a
enum: python
asset: Bar
texts:
- Foo
- Bar
urls:
- http://ct.de/a
- http://ct.de/b
enums:
- python
- c
- d
assets:
- Bar
- Foo
""")
def test_listless_sub_asset_change(self):
block_singleblock = AssetType(
type_name="block-singleblock",
schema={"block": 5},
parent_type=AssetType.objects.get(type_name="block"))
block_singleblock.save()
response = self.client.post(reverse('save_asset'),
data={
"type": "block-singleblock",
"block": {
"type": "block-listing",
"language": "python",
"code": "print(1)"
}
},
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content, {
"success": True,
"id": json.loads(response.content)["id"]
})
asset = Asset.objects.get(pk=json.loads(response.content)["id"])
self.assertEqual(asset.t, block_singleblock)
self.assertJSONEqual(
json.dumps(asset.content),
json.dumps({
"id": str(asset.pk),
"type": "block-singleblock",
"block": {
"id": asset.content_ids["block"],
"type": "block-listing",
"language": "python",
"code": "print(1)"
}
}))
tree = asset.content.copy()
tree["block"]["language"] = "kotlin"
response = self.client.post(reverse('save_asset'),
data=tree,
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content, {
"success": True,
"id": str(asset.pk)
})
asset_reloaded = Asset.objects.get(pk=asset.pk)
listing_block = Asset.objects.get(
pk=asset_reloaded.content_ids["block"])
self.assertJSONEqual(
json.dumps(asset_reloaded.content),
json.dumps({
"type": "block-singleblock",
"id": str(asset_reloaded.pk),
"block": {
"type": "block-listing",
"id": str(listing_block.pk),
"code": "print(1)",
"language": "kotlin"
}
}))
self.assertIsNone(asset_reloaded.revision_chain)
self.assertIsNotNone(listing_block.revision_chain)
self.assertEqual(listing_block.content_ids["language"],
Enum.objects.get(item="kotlin").pk)
tree["block"] = {
"type": "block-paragraph",
"spans": [{
"type": "span-regular",
"text": "Foobar Baz!"
}]
}
response = self.client.post(reverse('save_asset'),
data=tree,
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content, {
"success": True,
"id": str(asset.pk)
})
asset_reloaded2 = Asset.objects.get(pk=asset.pk)
paragraph_block = Asset.objects.get(
pk=asset_reloaded2.content_ids["block"])
self.assertIsNotNone(asset_reloaded2.revision_chain)
self.assertJSONEqual(
json.dumps(asset_reloaded2.content),
json.dumps({
"id": str(asset_reloaded2.pk),
"type": "block-singleblock",
"block": {
"id":
str(paragraph_block.pk),
"type":
"block-paragraph",
"spans": [{
"id": paragraph_block.content_ids["spans"][0],
"type": "span-regular",
"text": "Foobar Baz!"
}]
}
}))
for row in r:
print row
assets = Asset.objects.filter(no=row[4])
if not assets:
asset = Asset()
asset.no = row[4]
asset.sub_no = row[5]
dt = datetime.datetime.strptime(row[10], '%d/%m/%Y').date()
asset.capitalized = dt
types = AssetType.objects.filter(name=row[3])
print types
if types:
asset.asset_type = types.first()
else:
s = AssetType(name=row[3])
s.save()
asset.asset_type = s
asset.descr = row[11]
asset.add_descr = row[12]
asset.serial = row[14]
asset.office_id = 6
if "huuk" in row[17]:
asset.office_id = 2
elif "pei" in row[17]:
asset.office_id = 1
elif "osra" in row[17]:
asset.office_id = 5
elif "j" in row[17]:
asset.office_id = 4
elif "ap" in row[17]:
asset.office_id = 3