def test_revise_one_parent_post_unselected(self):
"""
Tests a post request to revise a part which has one parent.
This parent is not selected, and so its bom should not change.
"""
parent = PartController.create("RefParent", "Part", "a", self.user,
self.DATA)
parent.add_child(self.controller, 10, 25, "-")
link = parent.get_children(1)[0].link
data = {
"revision": "b",
"parents-TOTAL_FORMS": "1",
"parents-INITIAL_FORMS": "1",
"parents-0-selected": "",
"parents-0-link": link.id,
"parents-0-new_parent": parent.id,
"children-TOTAL_FORMS": "0",
"children-INITIAL_FORMS": "0",
"documents-TOTAL_FORMS": "0",
"documents-INITIAL_FORMS": "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the old revision is still a child of the parent
children = parent.get_children(1)
self.assertEqual([(1, link)], children)
self.assertFalse(PartController(rev, self.user).get_parents())
def test_revise_one_child_post_unselected(self):
"""
Tests a post request to revise a part with child which is not selected.
"""
child = PartController.create("RefChild", "Part", "a", self.user,
self.DATA)
self.controller.add_child(child, 10, 25, "-")
link = self.controller.get_children(1)[0].link
data = {
"revision": "b",
"parents-TOTAL_FORMS": "0",
"parents-INITIAL_FORMS": "0",
"children-TOTAL_FORMS": "1",
"children-INITIAL_FORMS": "1",
"children-0-selected": "",
"children-0-link": link.id,
"documents-TOTAL_FORMS": "0",
"documents-INITIAL_FORMS": "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the part is still a child of the old revision
children = self.controller.get_children(1)
self.assertEqual([(1, link)], children)
# ensure the part is not a child of the new revision
children = PartController(rev, self.user).get_children(1)
self.assertEqual(0, len(children))
def test_parents(self):
p1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
p1.add_child(self.controller, 10, 20)
p2 = PartController.create("c2", "Part", "a", self.user, self.DATA)
p2.add_child(self.controller, 10, 20)
response = self.get(self.base_url + "parents/", page="parents")
self.assertEqual(2, len(list(response.context["parents"])))
def get_all_geometry_files(self, doc_file):
if self.PartDecompose is not None:
pctrl = PartController(self.PartDecompose, self._user)
if self._stps is None:
children_ids = [
c.link.child_id
for c in pctrl.get_children(-1,
related=("child__id"),
only=(
"child__id",
"parent__id",
))
]
if children_ids:
docs = pmodels.DocumentPartLink.objects.now().filter(
document__type="Document3D",
part__in=children_ids).values_list("document",
flat=True)
dfs = pmodels.DocumentFile.objects.filter(document__in=docs, deprecated=False)\
.filter(is_stp).values_list("id", flat=True)
self._stps = dfs
else:
self._stps = pmodels.DocumentFile.objects.none(
).values_list("id", flat=True)
q = Q(stp=doc_file)
stps = list(self._stps)
if stps:
q |= Q(stp__in=stps)
gfs = GeometryFile.objects.filter(q)
else:
gfs = GeometryFile.objects.filter(stp=doc_file)
return gfs.values_list("file", flat=True)
def test_parents(self):
p1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
p1.add_child(self.controller, 10, 20)
p2 = PartController.create("c2", "Part", "a", self.user, self.DATA)
p2.add_child(self.controller, 10, 20)
response = self.get(self.base_url + "parents/", page="parents")
self.assertEqual(2, len(list(response.context["parents"])))
def test_revise_two_childrens_get(self):
"""
Tests a get request to revise a part with two children.
"""
child1 = PartController.create("RefChild1", "Part", "a", self.user,
self.DATA)
self.controller.add_child(child1, 10, 25, "-")
child2 = PartController.create("RefChild2", "Part", "a", self.user,
self.DATA)
self.controller.add_child(child2, 10, 55, "-")
response = self.get(self.base_url + "revisions/")
# checks that it is necessary to confirm the revision
self.assertTrue(response.context["confirmation"])
formset = response.context["children_formset"]
self.assertEqual(2, formset.total_form_count())
form1, form2 = formset.forms
self.assertTrue(form1.fields["selected"].initial)
self.assertTrue(form1.initial["link"].child_id in (child1.id,
child2.id))
self.assertTrue(form2.fields["selected"].initial)
self.assertTrue(form2.initial["link"].child_id in (child1.id,
child2.id))
self.assertNotEqual(form2.initial["link"], form1.initial["link"])
def test_navigate_parents(self):
"""
Tests a navigate with the "parents" option set.
"""
data = self.DATA.copy()
data["name"] = "Coffee"
parent1 = PartController.create("c1", "Part", "k",
self.user, data, True, True)
parent1.add_child(self.controller, 15, 789, "kg")
for osr, results in ((False, ()), (True, (parent1.object, ))):
self.get_graph_data({"parents" : True, OSR : osr }, results)
self.assertCount(2, 1)
main, parent_node = self.nodes
self.assertTrue("789" in self.edges[0].text_content())
self.assertTrue("15" in self.edges[0].text_content())
self.assertTrue("kg" in self.edges[0].text_content())
text = parent_node.text_content().strip()
self.assertTrue(data["name"] in text)
# add another parent to parent1
parent2 = PartController.create("c2", "Part", "k",
self.user, data, True, True)
parent2.add_child(parent1, 15, 789, "kg")
for osr, results in ((False, ()), (True, (parent1.object, parent2.object))):
self.get_graph_data({"parents" : True, OSR : osr }, results)
self.assertCount(3, 2)
self.get_graph_data({"parents" : True, OSR : True }, (parent2.object,))
self.assertCount(1, 0)
# add the controller to parent2
parent2.add_child(self.controller, 5, 79, "kg")
for osr, results in ((False, ()), (True, (parent1.object, parent2.object))):
self.get_graph_data({"parents" : True, OSR : osr }, results)
self.assertCount(3, 3)
for result in (self.cie, self.group, self.user, self.controller.object):
self.get_graph_data({"parents" : True, OSR : True }, (result,))
self.assertCount(1, 0)
def test_children(self):
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
self.controller.add_child(child1, 10 , 20)
child2 = PartController.create("c2", "Part", "a", self.user, self.DATA)
self.controller.add_child(child2, 10, 20)
response = self.get(self.base_url + "BOM-child/", page="BOM-child")
self.assertEqual(2, len(list(response.context["children"])))
form = response.context["display_form"]
def test_children(self):
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
self.controller.add_child(child1, 10, 20)
child2 = PartController.create("c2", "Part", "a", self.user, self.DATA)
self.controller.add_child(child2, 10, 20)
response = self.get(self.base_url + "BOM-child/", page="BOM-child")
self.assertEqual(2, len(list(response.context["children"])))
form = response.context["display_form"]
def test_update_no_checkin(self):
ctrl = self.create("d1", "Document3D")
natives = get_natives("test.native_asm", "NBA_ASM.native_asm",
"NUT.native", "BOLT.native", "L-BRACKET.native")
steps = get_steps("bolt.step", "l-bracket.step", "nut.step")
builder = AssemblyBuilder(ctrl)
builder.build_assembly(_ASSEMBLY1, natives, steps, False)
tree = copy.deepcopy(_UPDATED_ASSEMBLY1)
tree["children"][0]["document"]["checkin"] = False
natives = get_natives("test.native_asm", "NBA_ASM.native_asm",
"NUT.native", "BOLT.native")
steps = get_steps("bolt.step", "nut.step")
builder = AssemblyBuilder(ctrl)
builder.update_assembly(tree, natives, steps)
self.assertEqual(5, models.Part.objects.all().count())
self.assertEqual(5, models.Document.objects.all().count())
# root
root = PartController(ctrl.PartDecompose, self.user)
self.assertDoc(root.object, "test.step", "test.native_asm")
self.assertEqual("test", root.name)
children = root.get_children(-1)
self.assertEqual(4, len(children))
# l-bracket
pcl = children[0].link
child = pcl.child
self.assertLink(pcl, "L-BRACKET", root.object, 1, 1)
self.assertDoc(child, u"l-bracket.step", u"L-BRACKET.native")
# nba_asm
pcl = children[1].link
child = nba_asm = pcl.child
self.assertLink(pcl, "NBA_ASM", root.object, 2, 3)
self.assertDoc(child, u"NBA_ASM.step", u"NBA_ASM.native_asm")
# bolt
pcl = children[2].link
child = pcl.child
self.assertLink(pcl, "BOLT", nba_asm, 1, 2)
self.assertDoc(child, u"bolt.step", u"BOLT.native")
# nut
pcl = children[3].link
child = pcl.child
self.assertLink(pcl, "NUT", nba_asm, 2, 1)
self.assertDoc(child, u"nut.step", u"NUT.native")
# minor revisions of document files
for doc in models.Document.objects.all():
for f in doc.files:
if doc.name == "L-BRACKET":
self.assertEqual(1, f.revision)
else:
self.assertEqual(2, f.revision)
# check product is valid
self.assertProduct(ctrl)
def test_update_no_checkin(self):
ctrl = self.create("d1", "Document3D")
natives = get_natives("test.native_asm", "NBA_ASM.native_asm",
"NUT.native", "BOLT.native", "L-BRACKET.native")
steps = get_steps("bolt.step", "l-bracket.step", "nut.step")
builder = AssemblyBuilder(ctrl)
builder.build_assembly(_ASSEMBLY1, natives, steps, False)
tree = copy.deepcopy(_UPDATED_ASSEMBLY1)
tree["children"][0]["document"]["checkin"] = False
natives = get_natives("test.native_asm", "NBA_ASM.native_asm",
"NUT.native", "BOLT.native")
steps = get_steps("bolt.step", "nut.step")
builder = AssemblyBuilder(ctrl)
builder.update_assembly(tree, natives, steps)
self.assertEqual(5, models.Part.objects.all().count())
self.assertEqual(5, models.Document.objects.all().count())
# root
root = PartController(ctrl.PartDecompose, self.user)
self.assertDoc(root.object, "test.step", "test.native_asm")
self.assertEqual("test", root.name)
children = root.get_children(-1)
self.assertEqual(4, len(children))
# l-bracket
pcl = children[0].link
child = pcl.child
self.assertLink(pcl, "L-BRACKET", root.object, 1, 1)
self.assertDoc(child, u"l-bracket.step", u"L-BRACKET.native")
# nba_asm
pcl = children[1].link
child = nba_asm = pcl.child
self.assertLink(pcl, "NBA_ASM", root.object, 2, 3)
self.assertDoc(child, u"NBA_ASM.step", u"NBA_ASM.native_asm")
# bolt
pcl = children[2].link
child = pcl.child
self.assertLink(pcl, "BOLT", nba_asm, 1, 2)
self.assertDoc(child, u"bolt.step", u"BOLT.native")
# nut
pcl = children[3].link
child = pcl.child
self.assertLink(pcl, "NUT", nba_asm, 2, 1)
self.assertDoc(child, u"nut.step", u"NUT.native")
# minor revisions of document files
for doc in models.Document.objects.all():
for f in doc.files:
if doc.name == "L-BRACKET":
self.assertEqual(1, f.revision)
else:
self.assertEqual(2, f.revision)
# check product is valid
self.assertProduct(ctrl)
def test_revise_one_parent_post_selected(self):
"""
Tests a post request to revise a part which has one parent.
This parent is selected, and so its bom must be updated.
"""
parent = PartController.create("RefParent", "Part", "a", self.user, self.DATA)
parent.add_child(self.controller, 10, 25, "-")
link = parent.get_children(1)[0].link
data = { "revision" : "b",
"parents-TOTAL_FORMS" : "1",
"parents-INITIAL_FORMS" : "1",
"parents-0-selected" : "on",
"parents-0-link" : link.id,
"parents-0-new_parent" : parent.id,
"children-TOTAL_FORMS" : "0",
"children-INITIAL_FORMS" : "0",
"documents-TOTAL_FORMS" : "0",
"documents-INITIAL_FORMS" : "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the old revision is still a child of the parent
children = parent.get_children(1)
self.assertNotEqual([(1, link)], children)
self.assertEqual(1, len(children))
level, link2 = children[0]
self.assertEqual(parent.id, link2.parent_id)
self.assertEqual(link.order, link2.order)
self.assertEqual(link.quantity, link2.quantity)
self.assertEqual(link.unit, link2.unit)
self.assertEqual(rev.id, link2.child_id)
self.assertFalse(self.controller.get_parents())
def test_add_child(self):
response = self.get(self.base_url + "BOM-child/add/", link=True)
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
response = self.client.post(self.base_url + "BOM-child/add/",
{"type": "Part", "reference":"c1", "revision":"a",
"quantity" : 10, "order" : 10, "unit" : "m"})
self.assertEquals(1, len(self.controller.get_children()))
def test_revise_one_parent_post_unselected(self):
"""
Tests a post request to revise a part which has one parent.
This parent is not selected, and so its bom should not change.
"""
parent = PartController.create("RefParent", "Part", "a", self.user, self.DATA)
parent.add_child(self.controller, 10, 25, "-")
link = parent.get_children(1)[0].link
data = { "revision" : "b",
"parents-TOTAL_FORMS" : "1",
"parents-INITIAL_FORMS" : "1",
"parents-0-selected" : "",
"parents-0-link" : link.id,
"parents-0-new_parent" : parent.id,
"children-TOTAL_FORMS" : "0",
"children-INITIAL_FORMS" : "0",
"documents-TOTAL_FORMS" : "0",
"documents-INITIAL_FORMS" : "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the old revision is still a child of the parent
children = parent.get_children(1)
self.assertEqual([(1, link)], children)
self.assertFalse(PartController(rev, self.user).get_parents())
def test_attached_parts_two_parts(self):
doc = DocumentController.create("Doc", "Document", "a", self.user,
self.DATA)
doc.attach_to_part(self.controller)
part2 = PartController.create("Part2", "Part", "a", self.user, self.DATA)
doc.attach_to_part(part2)
wanted = [
{
"id": self.controller.id,
"reference": self.controller.reference,
"type": self.controller.type,
"revision": self.controller.revision,
"name": self.controller.name,
},
{
"id": part2.id,
"reference": part2.reference,
"type": part2.type,
"revision": part2.revision,
"name": part2.name,
},
]
key = lambda x: x["id"]
url = "/api/object/%d/attached_parts/" % doc.id
data = self.get(url)
self.assertEqual(sorted(data["parts"], key=key), sorted(wanted, key=key))
def test_revise_one_child_post_unselected(self):
"""
Tests a post request to revise a part with child which is not selected.
"""
child = PartController.create("RefChild", "Part", "a", self.user, self.DATA)
self.controller.add_child(child, 10, 25, "-")
link = self.controller.get_children(1)[0].link
data = { "revision" : "b",
"parents-TOTAL_FORMS" : "0",
"parents-INITIAL_FORMS" : "0",
"children-TOTAL_FORMS" : "1",
"children-INITIAL_FORMS" : "1",
"children-0-selected" : "",
"children-0-link" : link.id,
"documents-TOTAL_FORMS" : "0",
"documents-INITIAL_FORMS" : "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the part is still a child of the old revision
children = self.controller.get_children(1)
self.assertEqual([(1, link)], children)
# ensure the part is not a child of the new revision
children = PartController(rev, self.user).get_children(1)
self.assertEqual(0, len(children))
def test_update_assembly_locations(self):
ctrl = self.create("d1", "Document3D")
natives = get_natives("test.native_asm", "NBA_ASM.native_asm",
"NUT.native", "BOLT.native", "L-BRACKET.native")
steps = get_steps("bolt.step", "l-bracket.step", "nut.step")
builder = AssemblyBuilder(ctrl)
builder.build_assembly(_ASSEMBLY1, natives, steps, False)
tree = copy.deepcopy(_UPDATED_ASSEMBLY1)
m1 = [1, 7, 5, 9, 5, 4, 3, 2, 2, 0, 5, 1]
tree["children"][0]["local_matrix"] = m1
steps = get_steps("bolt.step", "l-bracket.step", "nut.step")
builder = AssemblyBuilder(ctrl)
builder.update_assembly(tree, natives, steps)
self.assertEqual(5, models.Document.objects.all().count())
self.assertEqual(5, models.Part.objects.all().count())
# root
root = PartController(ctrl.PartDecompose, self.user)
self.assertDoc(root.object, "test.step", "test.native_asm")
self.assertEqual("test", root.name)
children = root.get_children(-1)
self.assertEqual(4, len(children))
# l-bracket
pcl = children[0].link
child = pcl.child
self.assertLink(pcl, "L-BRACKET", root.object, 1, 1)
self.assertEqual(m1, pcl.extensions[0].to_array())
self.assertDoc(child, u"l-bracket.step", u"L-BRACKET.native")
# nba_asm
pcl = children[1].link
child = nba_asm = pcl.child
self.assertLink(pcl, "NBA_ASM", root.object, 2, 3)
self.assertDoc(child, u"NBA_ASM.step", u"NBA_ASM.native_asm")
# bolt
pcl = children[2].link
child = pcl.child
self.assertLink(pcl, "BOLT", nba_asm, 1, 2)
self.assertDoc(child, u"bolt.step", u"BOLT.native")
# nut
pcl = children[3].link
child = pcl.child
self.assertLink(pcl, "NUT", nba_asm, 2, 1)
self.assertDoc(child, u"nut.step", u"NUT.native")
# check product is valid
self.assertProduct(ctrl)
def test_update_assembly_locations(self):
ctrl = self.create("d1", "Document3D")
natives = get_natives("test.native_asm", "NBA_ASM.native_asm",
"NUT.native", "BOLT.native", "L-BRACKET.native")
steps = get_steps("bolt.step", "l-bracket.step", "nut.step")
builder = AssemblyBuilder(ctrl)
builder.build_assembly(_ASSEMBLY1, natives, steps, False)
tree = copy.deepcopy(_UPDATED_ASSEMBLY1)
m1 = [1, 7, 5, 9, 5, 4, 3, 2, 2, 0, 5, 1]
tree["children"][0]["local_matrix"] = m1
steps = get_steps("bolt.step", "l-bracket.step", "nut.step")
builder = AssemblyBuilder(ctrl)
builder.update_assembly(tree, natives, steps)
self.assertEqual(5, models.Document.objects.all().count())
self.assertEqual(5, models.Part.objects.all().count())
# root
root = PartController(ctrl.PartDecompose, self.user)
self.assertDoc(root.object, "test.step", "test.native_asm")
self.assertEqual("test", root.name)
children = root.get_children(-1)
self.assertEqual(4, len(children))
# l-bracket
pcl = children[0].link
child = pcl.child
self.assertLink(pcl, "L-BRACKET", root.object, 1, 1)
self.assertEqual(m1, pcl.extensions[0].to_array())
self.assertDoc(child, u"l-bracket.step", u"L-BRACKET.native")
# nba_asm
pcl = children[1].link
child = nba_asm = pcl.child
self.assertLink(pcl, "NBA_ASM", root.object, 2, 3)
self.assertDoc(child, u"NBA_ASM.step", u"NBA_ASM.native_asm")
# bolt
pcl = children[2].link
child = pcl.child
self.assertLink(pcl, "BOLT", nba_asm, 1, 2)
self.assertDoc(child, u"bolt.step", u"BOLT.native")
# nut
pcl = children[3].link
child = pcl.child
self.assertLink(pcl, "NUT", nba_asm, 2, 1)
self.assertDoc(child, u"nut.step", u"NUT.native")
# check product is valid
self.assertProduct(ctrl)
def _add_children(self, component, root):
pctrl = PartController(root, self.user)
pctrl.check_readable()
children = pctrl.get_children(-1)
if not children:
return
components = { root.id: component, }
links = [c.link for c in children]
locations = defaultdict(list) # pcl -> locations
for loc in Location_link.objects.filter(link__in=links):
locations[loc.link_id].append(loc)
parts = [l.child_id for l in links]
part2doc = {}
for doc in Document3D.objects.filter(PartDecompose__in=parts):
key = doc.PartDecompose_id
# if two revisions are present, takes the newest one
otherdoc = part2doc.get(key)
if otherdoc is None or otherdoc.ctime < doc.ctime:
part2doc[key] = doc
visited_links = set()
mtime = root.ctime
for link in links:
if link.id in visited_links:
pass
try:
comp = components[link.parent_id]
part = link.child
doc = part2doc[part.id]
locs = locations[link.id]
except KeyError:
# it is not an interessing link
pass
else:
mtime = max(mtime, link.ctime)
child_comp = self._get_component(doc, part)
locs = [{"local_name": l.name, "local_matrix": l.to_array()} for l in locs]
comp["children"].append({
"component": child_comp,
"locations": locs,
})
components[part.id] = child_comp
visited_links.add(link.id)
self._allowed_checkout = self._get_checkout(mtime)
def test_build_assembly(self):
self.assertEqual(0, models.PLMObject.objects.all().count())
ctrl = self.create("d1", "Document3D")
natives = get_natives("test.native_asm", "NBA_ASM.native_asm",
"NUT.native", "BOLT.native", "L-BRACKET.native")
steps = get_steps("bolt.step", "l-bracket.step", "nut.step")
builder = AssemblyBuilder(ctrl)
df = builder.build_assembly(_ASSEMBLY1, natives, steps, False)
self.assertEqual(5, models.Document.objects.all().count())
self.assertEqual(5, models.Part.objects.all().count())
# root
self.assertEqual("test.native_asm", df.filename)
root = PartController(ctrl.PartDecompose, self.user)
self.assertDoc(root.object, "test.step", "test.native_asm")
self.assertEqual("test", root.name)
children = root.get_children(-1)
self.assertEqual(4, len(children))
# l-bracket
pcl = children[0].link
child = pcl.child
self.assertLink(pcl, "L-BRACKET", root.object, 1, 1)
self.assertEqual(
[4.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
pcl.extensions[0].to_array())
self.assertDoc(child, u"l-bracket.step", u"L-BRACKET.native")
# nba_asm
pcl = children[1].link
child = nba_asm = pcl.child
self.assertLink(pcl, "NBA_ASM", root.object, 2, 3)
self.assertDoc(child, u"NBA_ASM.step", u"NBA_ASM.native_asm")
# bolt
pcl = children[2].link
child = pcl.child
self.assertLink(pcl, "BOLT", nba_asm, 1, 1)
self.assertDoc(child, u"bolt.step", u"BOLT.native")
# nut
pcl = children[3].link
child = pcl.child
self.assertLink(pcl, "NUT", nba_asm, 2, 1)
self.assertDoc(child, u"nut.step", u"NUT.native")
# check product is valid
self.assertProduct(ctrl)
def test_attach(self):
expected = []
result_part = []
result_doc = []
for pstate, dstate, powner, downer, can_attach in self.MATRICE:
self.part.object.state = self.states[pstate]
self.part.object.lifecycle = self.lifecycles[pstate]
self.doc.object.state = self.states[dstate]
self.doc.object.lifecycle = self.lifecycles[dstate]
self.part.set_owner(self.user if powner else self.other_owner, True)
self.doc.set_owner(self.user if downer else self.other_owner, True)
expected.append(can_attach)
pctrl = PartController(self.part.object, self.user)
result_part.append(pctrl.can_attach_document(self.doc.object))
dctrl = DocumentController(self.doc.object, self.user)
result_doc.append(dctrl.can_attach_part(self.part.object))
self.assertEqual(expected, result_part)
self.assertEqual(expected, result_doc)
def test_build_assembly(self):
self.assertEqual(0, models.PLMObject.objects.all().count())
ctrl = self.create("d1", "Document3D")
natives = get_natives("test.native_asm", "NBA_ASM.native_asm",
"NUT.native", "BOLT.native", "L-BRACKET.native")
steps = get_steps("bolt.step", "l-bracket.step", "nut.step")
builder = AssemblyBuilder(ctrl)
df = builder.build_assembly(_ASSEMBLY1, natives, steps, False)
self.assertEqual(5, models.Document.objects.all().count())
self.assertEqual(5, models.Part.objects.all().count())
# root
self.assertEqual("test.native_asm", df.filename)
root = PartController(ctrl.PartDecompose, self.user)
self.assertDoc(root.object, "test.step", "test.native_asm")
self.assertEqual("test", root.name)
children = root.get_children(-1)
self.assertEqual(4, len(children))
# l-bracket
pcl = children[0].link
child = pcl.child
self.assertLink(pcl, "L-BRACKET", root.object, 1, 1)
self.assertEqual([4.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
pcl.extensions[0].to_array())
self.assertDoc(child, u"l-bracket.step", u"L-BRACKET.native")
# nba_asm
pcl = children[1].link
child = nba_asm = pcl.child
self.assertLink(pcl, "NBA_ASM", root.object, 2, 3)
self.assertDoc(child, u"NBA_ASM.step", u"NBA_ASM.native_asm")
# bolt
pcl = children[2].link
child = pcl.child
self.assertLink(pcl, "BOLT", nba_asm, 1, 1)
self.assertDoc(child, u"bolt.step", u"BOLT.native")
# nut
pcl = children[3].link
child = pcl.child
self.assertLink(pcl, "NUT", nba_asm, 2, 1)
self.assertDoc(child, u"nut.step", u"NUT.native")
# check product is valid
self.assertProduct(ctrl)
def test_revise_two_childrens_post(self):
"""
Tests a post request to revise a part with two children.
Only one child is selected.
"""
child1 = PartController.create("RefChild1", "Part", "a", self.user,
self.DATA)
self.controller.add_child(child1, 10, 25, "-")
child2 = PartController.create("RefChild2", "Part", "a", self.user,
self.DATA)
self.controller.add_child(child2, 10, 55, "-")
link1, link2 = [c.link for c in self.controller.get_children(1)]
data = {
"revision": "b",
"parents-TOTAL_FORMS": "0",
"parents-INITIAL_FORMS": "0",
"children-TOTAL_FORMS": "1",
"children-INITIAL_FORMS": "1",
"children-0-selected": "on",
"children-0-link": link1.id,
"children-1-selected": "",
"children-1-link": link2.id,
"documents-TOTAL_FORMS": "0",
"documents-INITIAL_FORMS": "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the part is still a child of the old revision
children = self.controller.get_children(1)
self.assertEqual(set(((1, link1), (1, link2))), set(children))
children = PartController(rev, self.user).get_children(1)
self.assertEqual(1, len(children))
link = children[0].link
self.assertEqual(link1.child, link.child)
self.assertEqual(link1.order, link.order)
self.assertEqual(link1.quantity, link.quantity)
self.assertEqual(link1.unit, link.unit)
def test_navigate_children(self):
"""
Tests a navigate with the "child" option set.
"""
data = self.DATA.copy()
data["name"] = "Coffee"
child1 = PartController.create("c1", "Part", "k", self.user, data,
True, True)
self.controller.add_child(child1, 15, 789, "kg")
for osr, results in ((False, ()), (True, (child1.object, ))):
self.get_graph_data({"child": True, OSR: osr}, results)
self.assertCount(2, 1)
main, child_node = self.nodes
# check the edge
self.assertTrue("15" in self.edges[0].text_content())
self.assertTrue("kg" in self.edges[0].text_content())
text = child_node.text_content().strip()
self.assertTrue(data["name"] in text)
# add another child to child1
child2 = PartController.create("c2", "Part", "k", self.user, data,
True, True)
child1.add_child(child2, 15, 789, "kg")
for osr, results in ((False, ()), (True, (child1.object,
child2.object))):
self.get_graph_data({"child": True, OSR: osr}, results)
self.assertCount(3, 2)
# empty graph is child1 is not found
self.get_graph_data({"child": True, OSR: True}, (child2.object, ))
self.assertCount(1, 0)
# add child2 to the controller
# we should have 3 nodes (controller, child1, child2)
# and 3 edges (controller -> child1, controller -> child2 and
# child1 -> child2)
self.controller.add_child(child2, 15, 789, "kg")
for osr, results in ((False, ()), (True, (child1.object,
child2.object))):
self.get_graph_data({"child": True, OSR: osr}, results)
self.assertCount(3, 3)
for result in (self.cie, self.group, self.user,
self.controller.object):
self.get_graph_data({"child": True, OSR: True}, (result, ))
self.assertCount(1, 0)
def test_attach(self):
expected = []
result_part = []
result_doc = []
for pstate, dstate, powner, downer, can_attach in self.MATRICE:
self.part.object.state = self.states[pstate]
self.part.object.lifecycle = self.lifecycles[pstate]
self.doc.object.state = self.states[dstate]
self.doc.object.lifecycle = self.lifecycles[dstate]
self.part.set_owner(self.user if powner else self.other_owner,
True)
self.doc.set_owner(self.user if downer else self.other_owner, True)
expected.append(can_attach)
pctrl = PartController(self.part.object, self.user)
result_part.append(pctrl.can_attach_document(self.doc.object))
dctrl = DocumentController(self.doc.object, self.user)
result_doc.append(dctrl.can_attach_part(self.part.object))
self.assertEqual(expected, result_part)
self.assertEqual(expected, result_doc)
def test_revise_one_revised_parent_post2(self):
"""
Tests a post request to revise a part which has one parent which has been
revised before the bom was built.
"""
parent = PartController.create("RefParent", "Part", "a", self.user,
self.DATA)
parent2 = parent.revise("the game")
parent.add_child(self.controller, 10, 25, "-")
link = parent.get_children(1)[0].link
response = self.get(self.base_url + "revisions/")
# checks that it is necessary to confirm the revision
self.assertTrue(response.context["confirmation"])
formset = response.context["parents_formset"]
self.assertEqual(2, formset.total_form_count())
data = {
"revision": "b",
"parents-TOTAL_FORMS": "2",
"parents-INITIAL_FORMS": "2",
"parents-0-selected": "",
"parents-0-link": link.id,
"parents-0-new_parent": parent.id,
"parents-1-selected": "on",
"parents-1-link": link.id,
"parents-1-new_parent": parent2.id,
"children-TOTAL_FORMS": "0",
"children-INITIAL_FORMS": "0",
"documents-TOTAL_FORMS": "0",
"documents-INITIAL_FORMS": "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the old revision is still a child of the parent
children = parent.get_children(1)
self.assertEqual(1, len(children))
level, link2 = children[0]
self.assertEqual(parent.id, link2.parent_id)
self.assertEqual(link.order, link2.order)
self.assertEqual(link.quantity, link2.quantity)
self.assertEqual(link.unit, link2.unit)
self.assertEqual(self.controller.id, link2.child_id)
# ensure the new revisison is a child of the parent
children = parent2.get_children(1)
self.assertEqual(1, len(children))
level, link2 = children[0]
self.assertEqual(parent2.id, link2.parent_id)
self.assertEqual(link.order, link2.order)
self.assertEqual(link.quantity, link2.quantity)
self.assertEqual(link.unit, link2.unit)
self.assertEqual(rev.id, link2.child_id)
def test_revise_two_childrens_get(self):
"""
Tests a get request to revise a part with two children.
"""
child1 = PartController.create("RefChild1", "Part", "a", self.user, self.DATA)
self.controller.add_child(child1, 10, 25, "-")
child2 = PartController.create("RefChild2", "Part", "a", self.user, self.DATA)
self.controller.add_child(child2, 10, 55, "-")
response = self.get(self.base_url + "revisions/")
# checks that it is necessary to confirm the revision
self.assertTrue(response.context["confirmation"])
formset = response.context["children_formset"]
self.assertEqual(2, formset.total_form_count())
form1, form2 = formset.forms
self.assertTrue(form1.fields["selected"].initial)
self.assertTrue(form1.initial["link"].child_id in (child1.id, child2.id))
self.assertTrue(form2.fields["selected"].initial)
self.assertTrue(form2.initial["link"].child_id in (child1.id, child2.id))
self.assertNotEqual(form2.initial["link"], form1.initial["link"])
def get_all_geometry_files(self, doc_file):
if self.PartDecompose is not None:
pctrl = PartController(self.PartDecompose, self._user)
if self._stps is None:
children_ids = [c.link.child_id for c in pctrl.get_children(-1, related=("child__id"),
only=("child__id", "parent__id",))]
if children_ids:
docs = pmodels.DocumentPartLink.objects.now().filter(document__type="Document3D",
part__in=children_ids).values_list("document", flat=True)
dfs = pmodels.DocumentFile.objects.filter(document__in=docs, deprecated=False)\
.filter(is_stp).values_list("id", flat=True)
self._stps = dfs
else:
self._stps = pmodels.DocumentFile.objects.none().values_list("id", flat=True)
q = Q(stp=doc_file)
stps = list(self._stps)
if stps:
q |= Q(stp__in=stps)
gfs = GeometryFile.objects.filter(q)
else:
gfs = GeometryFile.objects.filter(stp=doc_file)
return gfs.values_list("file", flat=True)
def test_add_child(self):
response = self.get(self.base_url + "BOM-child/add/", link=True)
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
response = self.client.post(
self.base_url + "BOM-child/add/", {
"type": "Part",
"reference": "c1",
"revision": "a",
"quantity": 10,
"order": 10,
"unit": "m"
})
self.assertEquals(1, len(self.controller.get_children()))
def test_navigate_children(self):
"""
Tests a navigate with the "child" option set.
"""
data = self.DATA.copy()
data["name"] = "Coffee"
child1 = PartController.create("c1", "Part", "k",
self.user, data, True, True)
self.controller.add_child(child1, 15, 789, "kg")
for osr, results in ((False, ()), (True, (child1.object,))):
self.get_graph_data({"child" : True, OSR : osr }, results)
self.assertCount(2, 1)
main, child_node = self.nodes
# check the edge
self.assertTrue("15" in self.edges[0].text_content())
self.assertTrue("kg" in self.edges[0].text_content())
text = child_node.text_content().strip()
self.assertTrue(data["name"] in text)
# add another child to child1
child2 = PartController.create("c2", "Part", "k",
self.user, data, True, True)
child1.add_child(child2, 15, 789, "kg")
for osr, results in ((False, ()), (True, (child1.object, child2.object))):
self.get_graph_data({"child" : True, OSR : osr }, results)
self.assertCount(3, 2)
# empty graph is child1 is not found
self.get_graph_data({"child" : True, OSR : True }, (child2.object,))
self.assertCount(1, 0)
# add child2 to the controller
# we should have 3 nodes (controller, child1, child2)
# and 3 edges (controller -> child1, controller -> child2 and
# child1 -> child2)
self.controller.add_child(child2, 15, 789, "kg")
for osr, results in ((False, ()), (True, (child1.object, child2.object))):
self.get_graph_data({"child" : True, OSR : osr }, results)
self.assertCount(3, 3)
for result in (self.cie, self.group, self.user, self.controller.object):
self.get_graph_data({"child" : True, OSR : True }, (result,))
self.assertCount(1, 0)
def test_revise_two_childrens_post(self):
"""
Tests a post request to revise a part with two children.
Only one child is selected.
"""
child1 = PartController.create("RefChild1", "Part", "a", self.user, self.DATA)
self.controller.add_child(child1, 10, 25, "-")
child2 = PartController.create("RefChild2", "Part", "a", self.user, self.DATA)
self.controller.add_child(child2, 10, 55, "-")
link1, link2 = [c.link for c in self.controller.get_children(1)]
data = { "revision" : "b",
"parents-TOTAL_FORMS" : "0",
"parents-INITIAL_FORMS" : "0",
"children-TOTAL_FORMS" : "1",
"children-INITIAL_FORMS" : "1",
"children-0-selected" : "on",
"children-0-link" : link1.id,
"children-1-selected" : "",
"children-1-link" : link2.id,
"documents-TOTAL_FORMS" : "0",
"documents-INITIAL_FORMS" : "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the part is still a child of the old revision
children = self.controller.get_children(1)
self.assertEqual(set(((1, link1), (1, link2))), set(children))
children = PartController(rev, self.user).get_children(1)
self.assertEqual(1, len(children))
link = children[0].link
self.assertEqual(link1.child, link.child)
self.assertEqual(link1.order, link.order)
self.assertEqual(link1.quantity, link.quantity)
self.assertEqual(link1.unit, link.unit)
def test_revise_one_revised_parent_post2(self):
"""
Tests a post request to revise a part which has one parent which has been
revised before the bom was built.
"""
parent = PartController.create("RefParent", "Part", "a", self.user, self.DATA)
parent2 = parent.revise("the game")
parent.add_child(self.controller, 10, 25, "-")
link = parent.get_children(1)[0].link
response = self.get(self.base_url + "revisions/")
# checks that it is necessary to confirm the revision
self.assertTrue(response.context["confirmation"])
formset = response.context["parents_formset"]
self.assertEqual(2, formset.total_form_count())
data = { "revision" : "b",
"parents-TOTAL_FORMS" : "2",
"parents-INITIAL_FORMS" : "2",
"parents-0-selected" : "",
"parents-0-link" : link.id,
"parents-0-new_parent" : parent.id,
"parents-1-selected" : "on",
"parents-1-link" : link.id,
"parents-1-new_parent" : parent2.id,
"children-TOTAL_FORMS" : "0",
"children-INITIAL_FORMS" : "0",
"documents-TOTAL_FORMS" : "0",
"documents-INITIAL_FORMS" : "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the old revision is still a child of the parent
children = parent.get_children(1)
self.assertEqual(1, len(children))
level, link2 = children[0]
self.assertEqual(parent.id, link2.parent_id)
self.assertEqual(link.order, link2.order)
self.assertEqual(link.quantity, link2.quantity)
self.assertEqual(link.unit, link2.unit)
self.assertEqual(self.controller.id, link2.child_id)
# ensure the new revisison is a child of the parent
children = parent2.get_children(1)
self.assertEqual(1, len(children))
level, link2 = children[0]
self.assertEqual(parent2.id, link2.parent_id)
self.assertEqual(link.order, link2.order)
self.assertEqual(link.quantity, link2.quantity)
self.assertEqual(link.unit, link2.unit)
self.assertEqual(rev.id, link2.child_id)
def test_navigate_parents(self):
"""
Tests a navigate with the "parents" option set.
"""
data = self.DATA.copy()
data["name"] = "Coffee"
parent1 = PartController.create("c1", "Part", "k", self.user, data,
True, True)
parent1.add_child(self.controller, 15, 789, "kg")
for osr, results in ((False, ()), (True, (parent1.object, ))):
self.get_graph_data({"parents": True, OSR: osr}, results)
self.assertCount(2, 1)
main, parent_node = self.nodes
self.assertTrue("789" in self.edges[0].text_content())
self.assertTrue("15" in self.edges[0].text_content())
self.assertTrue("kg" in self.edges[0].text_content())
text = parent_node.text_content().strip()
self.assertTrue(data["name"] in text)
# add another parent to parent1
parent2 = PartController.create("c2", "Part", "k", self.user, data,
True, True)
parent2.add_child(parent1, 15, 789, "kg")
for osr, results in ((False, ()), (True, (parent1.object,
parent2.object))):
self.get_graph_data({"parents": True, OSR: osr}, results)
self.assertCount(3, 2)
self.get_graph_data({"parents": True, OSR: True}, (parent2.object, ))
self.assertCount(1, 0)
# add the controller to parent2
parent2.add_child(self.controller, 5, 79, "kg")
for osr, results in ((False, ()), (True, (parent1.object,
parent2.object))):
self.get_graph_data({"parents": True, OSR: osr}, results)
self.assertCount(3, 3)
for result in (self.cie, self.group, self.user,
self.controller.object):
self.get_graph_data({"parents": True, OSR: True}, (result, ))
self.assertCount(1, 0)
def test_revise_one_child_get(self):
"""
Tests a get request to revise a part which has one child.
This child must be suggested when the user revises the part.
"""
child = PartController.create("RefChild", "Part", "a", self.user, self.DATA)
self.controller.add_child(child, 10, 25, "-")
response = self.get(self.base_url + "revisions/")
# checks that it is necessary to confirm the revision
self.assertTrue(response.context["confirmation"])
formset = response.context["children_formset"]
self.assertEqual(1, formset.total_form_count())
form = formset.forms[0]
self.assertTrue(form.fields["selected"].initial)
self.assertEqual(child.id, form.initial["link"].child_id)
def test_plmobjects(self):
response = self.get(self.group_url + "objects/", page="objects")
objects = response.context["objects"]
self.assertEqual([self.part_controller.plmobject_ptr], list(objects.object_list))
# create a new group
group = m.GroupInfo(name="grp2", owner=self.user, creator=self.user,
description="grp")
group.save()
self.user.groups.add(group)
# create another part which bellows to another group
p2 = PartController.create("Part2", "Part", "a", self.user,
dict(group=group))
response = self.get(self.group_url + "objects/", page="objects")
objects = response.context["objects"]
self.assertEqual([self.part_controller.plmobject_ptr], list(objects.object_list))
def test_revise_one_child_get(self):
"""
Tests a get request to revise a part which has one child.
This child must be suggested when the user revises the part.
"""
child = PartController.create("RefChild", "Part", "a", self.user,
self.DATA)
self.controller.add_child(child, 10, 25, "-")
response = self.get(self.base_url + "revisions/")
# checks that it is necessary to confirm the revision
self.assertTrue(response.context["confirmation"])
formset = response.context["children_formset"]
self.assertEqual(1, formset.total_form_count())
form = formset.forms[0]
self.assertTrue(form.fields["selected"].initial)
self.assertEqual(child.id, form.initial["link"].child_id)
def setUp(self):
super(PartDocControllerTestCase, self).setUp()
self.other_owner = self.get_contributor("Otherowner")
self.other_owner.groups.add(self.group)
self.other_owner.save()
lcl = LifecycleList("dpop", "official", "draft", "proposed", "official", "deprecated")
lc = models.Lifecycle.from_lifecyclelist(lcl)
self.states = dict((s, models.State.objects.get(name=s)) for s in lcl)
self.states["cancelled"] = models.get_cancelled_state()
self.lifecycles = dict.fromkeys(lcl, lc)
self.lifecycles["cancelled"] = models.get_cancelled_lifecycle()
data = self.DATA.copy()
data["lifecycle"] = lc
self.part = PartController.create("p1", "Part", "a", self.user, data, True, True)
self.doc = DocumentController.create("d1", "Document", "a", self.user, data, True, True)
def test_navigate_documents2(self):
"""
Tests a navigate with the "doc" and "child" options set, both
parts are attached to the same document.
"""
data = self.DATA.copy()
data["name"] = "Coffee"
child1 = PartController.create("c1", "Part", "k", self.user, data,
True, True)
self.controller.add_child(child1, 4, 8, "m")
doc = DocumentController.create("doc", "Document", "d", self.user,
data, True, True)
self.controller.attach_to_document(doc)
child1.attach_to_document(doc)
for osr, results in ((False, ()), (True, (doc.object, child1.object))):
self.get_graph_data({"doc": True, "child": True})
self.assertCount(3, 3)
def test_navigate_documents2(self):
"""
Tests a navigate with the "doc" and "child" options set, both
parts are attached to the same document.
"""
data = self.DATA.copy()
data["name"] = "Coffee"
child1 = PartController.create("c1", "Part", "k",
self.user, data, True, True)
self.controller.add_child(child1, 4, 8, "m")
doc = DocumentController.create("doc", "Document", "d",
self.user, data, True, True)
self.controller.attach_to_document(doc)
child1.attach_to_document(doc)
for osr, results in ((False, ()), (True, (doc.object, child1.object))):
self.get_graph_data({"doc" : True, "child" : True})
self.assertCount(3, 3)
def test_revise_one_revised_parent_get(self):
"""
Tests a get request to revise a part which has one parent which has been
revised.
"""
parent = PartController.create("RefParent", "Part", "a", self.user, self.DATA)
parent.add_child(self.controller, 10, 25, "-")
parent2 = parent.revise("the game")
response = self.get(self.base_url + "revisions/")
# checks that it is necessary to confirm the revision
self.assertTrue(response.context["confirmation"])
formset = response.context["parents_formset"]
self.assertEqual(1, formset.total_form_count())
form = formset.forms[0]
self.assertFalse(form.fields["selected"].initial)
self.assertEqual(parent2.id, form.initial["link"].parent_id)
self.assertEqual(parent2.id, form.initial["new_parent"].id)
def test_navigate_part(self):
"""
Tests a navigate with the "doc" option set.
"""
data = self.DATA.copy()
data["name"] = "Coffee"
part = PartController.create("part", "Part", "d",
self.user, data, True, True)
self.controller.attach_to_part(part)
for osr, results in ((False, ()), (True, (part.object,))):
self.get_graph_data({"part" : True, OSR: osr}, results)
self.assertCount(2, 1)
main, part_node = self.nodes
text = part_node.text_content().strip()
self.assertTrue(data["name"] in text)
for result in (self.cie, self.group, self.user, self.controller.object):
self.get_graph_data({"part" : True, OSR : True }, (result,))
self.assertCount(1, 0)
def test_revise_one_revised_parent_get(self):
"""
Tests a get request to revise a part which has one parent which has been
revised.
"""
parent = PartController.create("RefParent", "Part", "a", self.user,
self.DATA)
parent.add_child(self.controller, 10, 25, "-")
parent2 = parent.revise("the game")
response = self.get(self.base_url + "revisions/")
# checks that it is necessary to confirm the revision
self.assertTrue(response.context["confirmation"])
formset = response.context["parents_formset"]
self.assertEqual(1, formset.total_form_count())
form = formset.forms[0]
self.assertFalse(form.fields["selected"].initial)
self.assertEqual(parent2.id, form.initial["link"].parent_id)
self.assertEqual(parent2.id, form.initial["new_parent"].id)
def test_navigate_part(self):
"""
Tests a navigate with the "doc" option set.
"""
data = self.DATA.copy()
data["name"] = "Coffee"
part = PartController.create("part", "Part", "d", self.user, data,
True, True)
self.controller.attach_to_part(part)
for osr, results in ((False, ()), (True, (part.object, ))):
self.get_graph_data({"part": True, OSR: osr}, results)
self.assertCount(2, 1)
main, part_node = self.nodes
text = part_node.text_content().strip()
self.assertTrue(data["name"] in text)
for result in (self.cie, self.group, self.user,
self.controller.object):
self.get_graph_data({"part": True, OSR: True}, (result, ))
self.assertCount(1, 0)
def setUp(self):
super(PartDocControllerTestCase, self).setUp()
self.other_owner = self.get_contributor("Otherowner")
self.other_owner.groups.add(self.group)
self.other_owner.save()
lcl = LifecycleList("dpop", "official", "draft", "proposed",
"official", "deprecated")
lc = models.Lifecycle.from_lifecyclelist(lcl)
self.states = dict((s, models.State.objects.get(name=s)) for s in lcl)
self.states["cancelled"] = models.get_cancelled_state()
self.lifecycles = dict.fromkeys(lcl, lc)
self.lifecycles["cancelled"] = models.get_cancelled_lifecycle()
data = self.DATA.copy()
data["lifecycle"] = lc
self.part = PartController.create("p1", "Part", "a", self.user, data,
True, True)
self.doc = DocumentController.create("d1", "Document", "a", self.user,
data, True, True)
def test_select_pdf_chidlren_part_pdf(self):
child = PartController.create("Child", "Part", "f",
self.user, self.DATA, True, True)
self.doc.attach_to_part(child)
self.controller.add_child(child, 1, 1, 'm')
df = self.doc.add_file(self.get_file("hello.pdf", data=PDF))
prefix = "pdf_%d_%d" % (self.controller.get_children()[0].link.id,
self.doc.id)
data = {
"Download" : "download",
prefix + '-TOTAL_FORMS': '1',
prefix + '-INITIAL_FORMS': '1',
prefix + '-0-id' : df.id,
prefix + '-0-document' : self.doc.id,
prefix + '-0-selected' : 'on',
}
response = self.client.get(self.base_url + "pdf/", data=data)
content = self.check_pdf(response, 2)
self.assertTrue("world" in content)
def test_plmobjects(self):
response = self.get(self.group_url + "objects/", page="objects")
objects = response.context["objects"]
self.assertEqual([self.part_controller.plmobject_ptr],
list(objects.object_list))
# create a new group
group = m.GroupInfo(name="grp2",
owner=self.user,
creator=self.user,
description="grp")
group.save()
self.user.groups.add(group)
# create another part which bellows to another group
p2 = PartController.create("Part2", "Part", "a", self.user,
dict(group=group))
response = self.get(self.group_url + "objects/", page="objects")
objects = response.context["objects"]
self.assertEqual([self.part_controller.plmobject_ptr],
list(objects.object_list))
def _add_part(self, doc, name):
data = {
"lifecycle": self.controller.lifecycle,
"group": self.controller.group,
"name": name,
}
ref = get_new_reference(self.controller._user, Part,
len(self.created_parts), self._inbulk_cache)
part = PartController.create(ref, "Part", "a", self.controller._user, data,
not self._send_mails, True)
self._parts[name] = part
self._parts[part.id] = part
doc.attach_to_part(part)
doc.object.PartDecompose = part.object
doc.object.save()
self.created_parts.append(part)
if self._send_mails:
part.block_mails()
return part
def test_children_last_level(self):
"""
Tests the children view, shows only the last level.
self
-> c1
-> c4
-> c6
-> c5
-> c2
-> c3
-> c7
-> c8
last level: (c4 -> c6), (c1 -> c5), (self -> c2), (c3 -> c7), (c3 -> c8)
"""
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
ls1 = self.controller.add_child(child1, 10, 20)
child2 = PartController.create("c2", "Part", "a", self.user, self.DATA)
ls2 = self.controller.add_child(child2, 10, 21)
child3 = PartController.create("c3", "Part", "a", self.user, self.DATA)
self.controller.add_child(child3, 10, 22)
child4 = PartController.create("c4", "Part", "a", self.user, self.DATA)
l14 = child1.add_child(child4, 10, 23)
child5 = PartController.create("c5", "Part", "a", self.user, self.DATA)
l15 = child1.add_child(child5, 10, 24)
child6 = PartController.create("c6", "Part", "a", self.user, self.DATA)
l46 = child4.add_child(child6, 10, 25)
child7 = PartController.create("c7", "Part", "a", self.user, self.DATA)
l37 = child3.add_child(child7, 10, 26)
child8 = PartController.create("c8", "Part", "a", self.user, self.DATA)
l38 = child3.add_child(child8, 10, 27)
response = self.get(self.base_url + "BOM-child/", {
"level": "last",
"state": "all"
},
page="BOM-child")
children = response.context["children"]
self.assertEqual(5, len(children))
self.assertEqual([l46, l15, ls2, l37, l38], [c.link for c in children])
def test_edit_children(self):
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
self.controller.add_child(child1, 10, 20)
response = self.get(self.base_url + "BOM-child/edit/")
formset = response.context["children_formset"]
data = {
'form-TOTAL_FORMS': u'1',
'form-INITIAL_FORMS': u'1',
'form-MAX_NUM_FORMS': u'',
'form-0-child': child1.id,
'form-0-id': self.controller.get_children()[0].link.id,
'form-0-order': 45,
'form-0-parent': self.controller.id,
'form-0-quantity': '45.0',
'form-0-unit': 'cm',
}
response = self.post(self.base_url + "BOM-child/edit/", data)
link = self.controller.get_children()[0].link
self.assertEquals(45, link.order)
self.assertEquals(45.0, link.quantity)
self.assertEquals('cm', link.unit)
def test_edit_children(self):
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
self.controller.add_child(child1, 10, 20)
response = self.get(self.base_url + "BOM-child/edit/")
formset = response.context["children_formset"]
data = {
"form-TOTAL_FORMS": u"1",
"form-INITIAL_FORMS": u"1",
"form-MAX_NUM_FORMS": u"",
"form-0-child": child1.id,
"form-0-id": self.controller.get_children()[0].link.id,
"form-0-order": 45,
"form-0-parent": self.controller.id,
"form-0-quantity": "45.0",
"form-0-unit": "cm",
}
response = self.post(self.base_url + "BOM-child/edit/", data)
link = self.controller.get_children()[0].link
self.assertEquals(45, link.order)
self.assertEquals(45.0, link.quantity)
self.assertEquals("cm", link.unit)
def test_edit_children(self):
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
self.controller.add_child(child1, 10 , 20)
response = self.get(self.base_url + "BOM-child/edit/")
formset = response.context["children_formset"]
data = {
'form-TOTAL_FORMS': u'1',
'form-INITIAL_FORMS': u'1',
'form-MAX_NUM_FORMS': u'',
'form-0-child' : child1.id,
'form-0-id' : self.controller.get_children()[0].link.id,
'form-0-order' : 45,
'form-0-parent' : self.controller.id,
'form-0-quantity' : '45.0',
'form-0-unit' : 'cm',
}
response = self.post(self.base_url + "BOM-child/edit/", data)
link = self.controller.get_children()[0].link
self.assertEquals(45, link.order)
self.assertEquals(45.0, link.quantity)
self.assertEquals('cm', link.unit)
def test_children_last_level(self):
"""
Tests the children view, shows only the last level.
self
-> c1
-> c4
-> c6
-> c5
-> c2
-> c3
-> c7
-> c8
last level: (c4 -> c6), (c1 -> c5), (self -> c2), (c3 -> c7), (c3 -> c8)
"""
child1 = PartController.create("c1", "Part", "a", self.user, self.DATA)
ls1 = self.controller.add_child(child1, 10 , 20)
child2 = PartController.create("c2", "Part", "a", self.user, self.DATA)
ls2 = self.controller.add_child(child2, 10, 21)
child3 = PartController.create("c3", "Part", "a", self.user, self.DATA)
self.controller.add_child(child3, 10, 22)
child4 = PartController.create("c4", "Part", "a", self.user, self.DATA)
l14 = child1.add_child(child4, 10, 23)
child5 = PartController.create("c5", "Part", "a", self.user, self.DATA)
l15 = child1.add_child(child5, 10, 24)
child6 = PartController.create("c6", "Part", "a", self.user, self.DATA)
l46 = child4.add_child(child6, 10, 25)
child7 = PartController.create("c7", "Part", "a", self.user, self.DATA)
l37 = child3.add_child(child7, 10, 26)
child8 = PartController.create("c8", "Part", "a", self.user, self.DATA)
l38 = child3.add_child(child8, 10, 27)
response = self.get(self.base_url + "BOM-child/",
{"level":"last", "state" : "all"},
page="BOM-child")
children = response.context["children"]
self.assertEqual(5, len(children))
self.assertEqual([l46, l15, ls2, l37, l38], [c.link for c in children])
def test_revise_one_parent_post_selected(self):
"""
Tests a post request to revise a part which has one parent.
This parent is selected, and so its bom must be updated.
"""
parent = PartController.create("RefParent", "Part", "a", self.user,
self.DATA)
parent.add_child(self.controller, 10, 25, "-")
link = parent.get_children(1)[0].link
data = {
"revision": "b",
"parents-TOTAL_FORMS": "1",
"parents-INITIAL_FORMS": "1",
"parents-0-selected": "on",
"parents-0-link": link.id,
"parents-0-new_parent": parent.id,
"children-TOTAL_FORMS": "0",
"children-INITIAL_FORMS": "0",
"documents-TOTAL_FORMS": "0",
"documents-INITIAL_FORMS": "0",
}
response = self.post(self.base_url + "revisions/", data)
revisions = self.controller.get_next_revisions()
self.assertEqual(1, len(revisions))
rev = revisions[0].part
self.assertEqual("b", rev.revision)
# ensure the old revision is still a child of the parent
children = parent.get_children(1)
self.assertNotEqual([(1, link)], children)
self.assertEqual(1, len(children))
level, link2 = children[0]
self.assertEqual(parent.id, link2.parent_id)
self.assertEqual(link.order, link2.order)
self.assertEqual(link.quantity, link2.quantity)
self.assertEqual(link.unit, link2.unit)
self.assertEqual(rev.id, link2.child_id)
self.assertFalse(self.controller.get_parents())
def get_part(self, ref="P1"):
return PartController.create(ref, "Part", "a", self.user, self.DATA,
True, True)
def test_add_related_part_post(self):
part = PartController.create("RefPart", "Part", "a", self.user, self.DATA)
data = {"reference": part.reference, "type": part.type, "revision": part.revision}
response = self.post(self.base_url + "parts/add/", data)
self.assertEqual([part.id], [p.part.id for p in self.controller.get_attached_parts()])
def get_product(self, doc_file, recursive=False):
"""
Returns the :class:`.Product` associated to *doc_file*.
If *recursive* is True, it returns a complet product, built by browsing
the BOM of the attached part, if it has been decomposed.
"""
try:
af = ArbreFile.objects.get(stp=doc_file)
except:
return None
product = classes.Product.from_list(json.loads(af.file.read()))
if recursive and product:
if self.PartDecompose is not None:
# Here be dragons
# this code try to reduce the number of database queries:
# h queries (h: height of the BOM) to get children
# + 1 query to doc-part links
# + 1 query to get STP files
# + 1 query to get location links
# + 1 query to get ArbreFile
pctrl = PartController(self.PartDecompose, self._user)
children = pctrl.get_children(-1,
related=("child__id"),
only=(
"child__id",
"parent__id",
))
if not children:
return product
links, children_ids = zip(*[(c.link.id, c.link.child_id)
for c in children])
docs = []
part_to_docs = defaultdict(list)
for doc, part in pmodels.DocumentPartLink.current_objects.filter(
document__type="Document3D",
part__in=children_ids).values_list(
"document", "part").order_by("-ctime"):
# order by -ctime to test the most recently attached document first
part_to_docs[part].append(doc)
docs.append(doc)
if not docs:
return product
dfs = dict(pmodels.DocumentFile.objects.filter(document__in=docs, deprecated=False)\
.filter(is_stp).values_list("document", "id"))
# cache this values as it may be useful for get_all_geometry_files
self._stps = dfs.values()
locs = defaultdict(list)
for l in Location_link.objects.filter(link__in=links):
locs[l.link_id].append(l)
# read all jsons files
jsons = {}
for af in ArbreFile.objects.filter(stp__in=dfs.values()):
jsons[af.stp_id] = json.loads(af.file.read())
# browse the BOM and build product
previous_level = 0
products = [product]
for level, link in children:
if level <= previous_level:
del products[level:]
stp = None
for doc in part_to_docs[link.child_id]:
if doc in dfs:
stp = dfs[doc]
break
if stp is not None and stp in jsons:
pr = products[-1]
prod = classes.Product.from_list(
jsons[stp],
product=False,
product_root=product,
deep=level,
to_update_product_root=pr)
for location in locs[link.id]:
pr.links[-1].add_occurrence(
location.name, location)
products.append(prod)
previous_level = level
return product
