def find_group(request, grouptitle, pgSz):

    # TIMESTAMP = time.strftime("%b %d %Y %H:%M:%S", time.localtime())

    asquery = '%s?as=%s_common%%3Atitle%%3D%%27%s%%27&wf_deleted=false&pgSz=%s' % ('groups', 'groups', grouptitle, pgSz)

    # Make authenticated connection to cspace server...
    (groupurl, grouprecord, dummy, elapsedtime) = getfromCSpace(asquery, request)
    if grouprecord is None:
        return(None, None, 0, [], 'Error: the search for group \'%s.\' failed.' % grouptitle)
    grouprecordtree = fromstring(grouprecord)
    groupcsid = grouprecordtree.find('.//csid')
    if groupcsid is None:
        return(None, None, 0, [], None)
    groupcsid = groupcsid.text

    uri = 'collectionobjects?rtObj=%s&pgSz=%s' % (groupcsid, pgSz)
    try:
        (groupurl, groupmembers, dummy, elapsedtime) = getfromCSpace(uri, request)
        groupmembers = fromstring(groupmembers)
        totalItems = groupmembers.find('.//totalItems')
        totalItems = int(totalItems.text)
        objectcsids = [e.text for e in groupmembers.findall('.//csid')]
    except urllib2.HTTPError, e:
        return (None, None, 0, [], 'Error: we could not make list of group members')

	def __init__(self, firstArgument, robotAddr='', responseValue='', comment=''):
	# single-argument: build from XML
	# multiple-argument: build this class from its component data with optional  comment
		if (robotAddr == '' and responseValue == '' and comment == ''):
			tree = fromstring(firstArgument)
			ts = SubElement(tree, 't')
			ts.text = microtime()
			self.XML = tree

			self.driverAddr = self.XML.findtext('d')
			self.robotAddr = self.XML.findtext('r')
			self.responseValue = self.XML.findtext('re')
 			self.comment = self.XML.findtext('co')
		else:
			self.driverAddr = firstArgument
			self.robotAddr = robotAddr
			self.responseValue = responseValue
 			self.comment = comment
			
			tree = fromstring('<m></m>')
			ts = SubElement(tree, 't')
			ts.text = microtime()
			ds = SubElement(tree, 'd')
			ds.text = self.driverAddr
			rs = SubElement(tree, 'r')
			rs.text = self.robotAddr
			res = SubElement(tree, 're')
			res.text = self.responseValue
			cos = SubElement(tree, 'co')
			cos.text = self.comment
			self.XML = tree
# endclass messageFromRobot

 def resolve(self, item, captcha_cb=None, select_cb=None):
     result = []
     item = item.copy()
     url = item['url']
     if url.endswith('live.html'):
         channel = re.search(r'http://(\w+)\.joj\.sk', url).group(1)
         for original, replacement in {'www': 'joj', 'plus': 'jojplus'}.items():
             if channel == original:
                 channel = replacement
                 break
         for quality, resolution in {'lq': '180p', 'mq': '360p', 'hq': '540p'}.items():
             item = self.video_item()
             item['quality'] = resolution
             item['url'] = 'http://http-stream.joj.sk/joj/' + channel + '/index-' + quality + '.m3u8'
             result.append(item)
     else:
         data = util.request(url)
         playerdata = re.search(r'<div\ class=\"jn-player\"(.+?)>', data).group(1)
         pageid = re.search(r'data-pageid=[\'\"]([^\'\"]+)', playerdata).group(1)
         basepath = re.search(r'data-basepath=[\'\"]([^\'\"]+)', playerdata).group(1)
         videoid = re.search(r'data-id=[\'\"]([^\'\"]+)', playerdata).group(1)
         playlisturl = basepath + 'services/Video.php?clip=' + videoid + 'pageId=' + pageid
         playlist = fromstring(util.request(playlisturl))
         balanceurl = basepath + 'balance.xml?nc=%d' % random.randint(1000, 9999)
         balance = fromstring(util.request(balanceurl))
         for video in playlist.find('files').findall('file'):
             item = self.video_item()
             item['img'] = playlist.attrib.get('large_image')
             item['length'] = playlist.attrib.get('duration')
             item['quality'] = video.attrib.get('quality')
             item['url'] = self.rtmp_url(video.attrib.get('path'), playlist.attrib.get('url'),
                                         video.attrib.get('type'), balance)
             result.append(item)
         result.reverse()
     return select_cb(result)

 def test_compareElement2 (self) :
     clearGlobals()
     x = fromstring("<red><blue></blue></red>")
     iterElement(x)
     y = fromstring("<red><green><blue></blue><yellow></yellow></green></red>")
     z = compareElement(y,x)
     self.assertTrue(z == [])

 def test_searchFunction (self) :
     x = [("mez", 1),("mer", 2)]
     clearGlobals()
     xx = fromstring("<mez><mer></mer></mez>")
     y = fromstring("<mez><mer></mer></mez>")
     z = searchFunction(y,xx, x)
     self.assertTrue(z == True)

    def test_proxy_validate_view_pt_success(self):
        """
        When called with a valid ``ProxyTicket``, a ``GET`` request to
        the view should return a validation success and the
        ``ProxyTicket`` should be consumed and invalid for future
        validation attempts.
        """
        query_str = "?service=%s&ticket=%s" % (self.service_url, self.pt.ticket)
        response = self.client.get(reverse("cas_proxy_validate") + query_str)
        tree = ElementTree(fromstring(response.content))
        elem = tree.find(XMLNS + "authenticationSuccess/" + XMLNS + "user")
        self.assertIsNotNone(elem)
        self.assertEqual(elem.text, "ellen")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.get("Content-Type"), "text/xml")
        elem = tree.find(XMLNS + "authenticationSuccess/" + XMLNS + "proxies")
        proxy = list(elem.getiterator(XMLNS + "proxy"))
        self.assertEqual(len(proxy), 1)
        self.assertEqual(proxy[0].text, "http://www.example.com")

        # This request should fail as the ticket was consumed in the preceeding test
        response = self.client.get(reverse("cas_proxy_validate") + query_str)
        tree = ElementTree(fromstring(response.content))
        elem = tree.find(XMLNS + "authenticationFailure")
        self.assertIsNotNone(elem)
        self.assertEqual(elem.get("code"), "INVALID_TICKET")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.get("Content-Type"), "text/xml")

def process(fc):
	root = fromstring(fc)
	ns = "{http://www.yworks.com/xml/graphml}"

	new_node_code = \
	"""<?xml version="1.0" encoding="UTF-8" standalone="no"?>
	<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:y="http://www.yworks.com/xml/graphml" xmlns:yed="http://www.yworks.com/xml/yed/3" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd">
		<y:StyleProperties>
		    <y:Property class="com.yworks.yfiles.bpmn.view.TaskTypeEnum" name="com.yworks.bpmn.taskType" value="TASK_TYPE_ABSTRACT"/>
		    <y:Property class="com.yworks.yfiles.bpmn.view.ActivityTypeEnum" name="com.yworks.bpmn.activityType" value="ACTIVITY_TYPE_TASK"/>
		    <y:Property class="java.awt.Color" name="com.yworks.bpmn.icon.fill2" value="#d4d4d4"/>
		    <y:Property class="java.awt.Color" name="com.yworks.bpmn.icon.fill" value="#ffffff"/>
		    <y:Property class="com.yworks.yfiles.bpmn.view.BPMNTypeEnum" name="com.yworks.bpmn.type" value="ACTIVITY_TYPE"/>
		    <y:Property class="java.awt.Color" name="com.yworks.bpmn.icon.line.color" value="#000000"/>
		</y:StyleProperties>
	</graphml>
	"""
	new_node = fromstring(new_node_code).find("{}StyleProperties".format(ns))

	for node in root.findall('.//{}ShapeNode'.format(ns)):
		node.tag = "{}GenericNode".format(ns)
		node.attrib['configuration'] = "com.yworks.bpmn.Activity.withShadow"

		color = node.find("{}Fill".format(ns))
		del color.attrib['color']
		color.attrib['color1'] = "#FFFFFFE6"
		color.attrib['color2'] = "#D4D4D4CC"
		del color

		node.find("{}BorderStyle".format(ns)).attrib['color'] = '#123EA2'
		node.remove(node.find("{}Shape".format(ns)))

		node.append(new_node)

	return tostring(root, "UTF-8")

def main(argv):
    hostn = 'http://localhost:8080' #localhost at default port
    output = 'odfdump.xml' #default file
    try:
        opts, args = getopt.getopt(argv,"ho:")
    except getopt.GetoptError:
        print('getAllData.py -o <outputfile> host')
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print('getAllData.py -o <outputfile> host')
            sys.exit()
        elif opt == '-o':
            output = arg
    if len(args) >= 1:
        hostn = args[0]

    #request for odf hierarchy
    hierarchyRequest = """<omiEnvelope xmlns="http://www.opengroup.org/xsd/omi/1.0/"  version="1.0" ttl="0">
  <read msgformat="odf">
    <msg>
      <Objects xmlns="http://www.opengroup.org/xsd/odf/1.0/"/>
    </msg>
  </read>
</omiEnvelope>"""
    #request for 9000 newest values(should be enough for now) 
    fullRequest = """<omiEnvelope xmlns="http://www.opengroup.org/xsd/omi/1.0/" version="1.0" ttl="0">
  <read msgformat="odf" newest="9000">
    <msg>
    </msg>
  </read>
</omiEnvelope>"""


    #register namespaces so that we don't get wrong namespaces in the request
    register_namespace("omi","omi.xsd")
    register_namespace("odf", "odf.xsd")
    register_namespace("", "http://www.w3.org/2001/XMLSchema-instance")
    headers = {'Content-Type': 'application/xml'}

    #current hierarchy
    r = requests.post(hostn, data = hierarchyRequest, headers = headers).text

    root = fromstring(r)
    
    objects = root.find(".//{http://www.opengroup.org/xsd/odf/1.0/}Objects")
    #remove values and add metadata and description tags
    update_odf(objects)

    fullRoot = fromstring(fullRequest)

    fullRoot.find(".//{http://www.opengroup.org/xsd/omi/1.0/}msg").append(objects)

    #write result to file. note: result might be big so iterate over the result
    with open(output,'wb') as handle:
        r2 = requests.post(hostn, data = tostring(fullRoot, encoding="utf-8"), headers = headers, stream = True)
        if not r2.ok:
            print("INVALID RESPONSE")
        for block in r2.iter_content(1024):
            handle.write(block)

 def test_findMatches3(self):
     sourceElement = fromstring("<THU><Team><ACRush></ACRush><Jelly></Jelly><Cooly></Cooly></Team><JiaJia><Team><Ahyangyi></Ahyangyi><Dragon></Dragon><Cooly><Amber></Amber></Cooly></Team></JiaJia></THU>")
     searchPatternElement = fromstring("<Team><Cooly></Cooly></Team>")
     matches = []
     FindMatchesInElement(sourceElement, searchPatternElement, ReferenceType(1), matches)
     answer = [2, 7]
     self.assert_(len(answer) == len(matches) and all(answer[i] == matches[i] for i in range(len(answer)-1)))

 def test_findMatches2(self):
     sourceElement = fromstring("<red><green><blue></blue><yellow></yellow></green></red>")
     searchPatternElement = fromstring("<green><blue></blue></green>")
     matches = []
     FindMatchesInElement(sourceElement, searchPatternElement, ReferenceType(1), matches)
     answer = [2]
     self.assert_(len(answer) == len(matches) and all(answer[i] == matches[i] for i in range(len(answer)-1)))

 def test_eval_2 (self) :
     # Query tree have more than 2 layers
     a = fromstring("<a><b><c></c><d><f></f></d></b></a>")  
     b = fromstring("<b><d><f></f></d></b>")
     v = xmleval(a,b)
     print (str(v))
     self.assertTrue(v == [1,2])

 def test_xml_check (self) :
     s = "<A><B><C></C><D></D></B></A>"
     c = fromstring(s)
     t = "<A><B></B></A>"
     p = fromstring(t)
     r = xml_check(c, p)
     self.assertTrue(r == True)

 def test_eval_3 (self) :
     # Query tree does not exist in source tree
     a = fromstring("<a><b><c></c><d></d></b></a>")  
     b = fromstring("<b><e></e></b>")
     v = xmleval(a,b)
     print (str(v))
     self.assertTrue(v == [0])

 def test3_findPattern(self): # Verify that 2nd element is correct
     xmltree = "<xml><outer><middle><inner></inner></middle></outer></xml>"
     globals1 = StoreGlob1(fromstring(xmltree))
     xml_findPattern(globals1,fromstring(xmltree))
     pattern = globals1.curPattern
     testelement = fromstring("<middle></middle>")
     self.assertTrue(pattern[2].tag == testelement.tag)

def mergeLogs(fromFilePath, toFilePath, outputFilePath):
    utf8open = lambda s: open(s, 'r', 'utf8')

    outputDoc = E('html')

    with utf8open(fromFilePath) as fromFile, utf8open(toFilePath) as toFile:

        # the body and HTML tags are left open so the app can just append
        # when a new message comes in. we have to close them.
        # note: this could also be taken care of by BeautifulSoup or
        # perhaps lxml.html

        fromDoc = fromstring(fromFile.read() + '</BODY></HTML>')
        toDoc = fromstring(toFile.read() + '</BODY></HTML>')

        # copy the head tag so formatting and stuff is preserved in our new doc
        outputDoc.append(fromDoc.find('HEAD').copy())

        fromMessages = fromDoc.findall('./BODY/div')
        toMessages = toDoc.findall('./BODY/div')

        allMessages = list(fromMessages) + list(toMessages)
        allMessages.sort(key = lambda e: time.strptime(e.attrib['timestamp'], '%Y-%m-%d %H:%M:%S'))

        body = SE(outputDoc, 'BODY', attrib = fromDoc.find('BODY').attrib)
        body.extend(x.copy() for x in allMessages)

    ElementTree(outputDoc).write(outputFilePath, 'utf8')

    def test_proxy_validate_view_pt_success(self):
        """
        When called with a valid ``ProxyTicket``, a ``GET`` request to
        the view should return a validation success and the
        ``ProxyTicket`` should be consumed and invalid for future
        validation attempts.
        """
        query_str = "?service=%s&ticket=%s" % (self.service_url,
                                               self.pt.ticket)
        response = self.client.get(reverse('cas_proxy_validate') + query_str)
        tree = ElementTree(fromstring(response.content))
        elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user')
        self.assertIsNotNone(elem)
        self.assertEqual(elem.text, 'ellen')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.get('Content-Type'), 'text/xml')
        elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'proxies')
        proxy = list(elem.getiterator(XMLNS + 'proxy'))
        self.assertEqual(len(proxy), 1)
        self.assertEqual(proxy[0].text, 'http://www.example.com')

        # This second validation request attempt should fail as the
        # ticket was consumed in the preceeding test
        response = self.client.get(reverse('cas_proxy_validate') + query_str)
        tree = ElementTree(fromstring(response.content))
        elem = tree.find(XMLNS + 'authenticationFailure')
        self.assertIsNotNone(elem)
        self.assertEqual(elem.get('code'), 'INVALID_TICKET')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.get('Content-Type'), 'text/xml')

def index(request):
    connection = cspace.connection.create_connection(mainConfig, request.user)
    (url, data, statusCode) = connection.make_get_request('cspace-services/reports')
    reportXML = fromstring(data)
    reportCsids = [csidElement.text for csidElement in reportXML.findall('.//csid')]
    reportNames = [csidElement.text for csidElement in reportXML.findall('.//name')]
    fileNames = []
    #print reportCsids
    for csid in reportCsids:
        try:
            (url, data, statusCode) = connection.make_get_request('cspace-services/reports/%s' % csid)
            reportXML = fromstring(data)
            fileName = reportXML.find('.//filename')
            fileName = fileName.text
            fileName = fileName.replace('.jasper','.jrxml')
            parms,displayReport,fileFound = getReportparameters(fileName)
            fileName = fileName if displayReport else 'CSpace only'
            fileName = fileName if fileFound else 'Found in CSpace, not configured for this webapp'
            fileNames.append(fileName)
            #print fileName
        except:
            fileNames.append('Error getting report payload from CSpace: %s' % csid)
    reportData = zip(reportCsids, reportNames, fileNames)
    reportData = sorted(reportData, key=itemgetter(1))
    context = {'reportData': reportData, 'labels': 'name file'.split(' '), 'apptitle': TITLE}
    context['additionalInfo'] = AdditionalInfo.objects.filter(live=True)
    return render(request, 'listReports.html', context)

 def test_get_child_title(self):
     e = fromstring("<a><title xmlns='http://www.w3.org/2005/Atom'>fred</title></a>")
     self.assertEqual("fred", model.get_child_title(e))
     e = fromstring("<a><title type='html' xmlns='http://www.w3.org/2005/Atom'>fred</title></a>")
     self.assertEqual("fred", model.get_child_title(e))
     e = fromstring("<a><title type='xhtml' xmlns='http://www.w3.org/2005/Atom'><div xmlns='http://www.w3.org/1999/xhtml'>fred <b>and</b> barney.</div></title></a>")
     self.assertEqual("fred and barney.", model.get_child_title(e))

    def test_service_validate_view_success(self):
        """
        When called with correct parameters, a ``GET`` request to the
        view should return a validation success and the
        ``ServiceTicket`` should be consumed and invalid for future
        validation attempts.
        """
        query_str = "?service=%s&ticket=%s" % (self.service_url,
                                               self.st.ticket)
        response = self.client.get(reverse('cas_service_validate') + query_str)
        tree = ElementTree(fromstring(response.content))
        elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user')
        self.assertIsNotNone(elem)
        self.assertEqual(elem.text, 'ellen')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.get('Content-Type'), 'text/xml')

        # This should fail as the ticket was consumed in the preceeding test
        response = self.client.get(reverse('cas_service_validate') + query_str)
        tree = ElementTree(fromstring(response.content))
        elem = tree.find(XMLNS + 'authenticationFailure')
        self.assertIsNotNone(elem)
        self.assertEqual(elem.get('code'), 'INVALID_TICKET')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.get('Content-Type'), 'text/xml')

def getOrganizations(root):
    """
    root is an ElementTree object
    for each object in the module, attributes are assigned to specified organization element and
    ElementTree is creating subelements to store data from the database module
    getOrganizations parses orgs from the ElementTree to xml
    """
    assert root is not None
    for o in Organization.objects.all():
        node = ET.SubElement(root, 'Organization')
        node.set('ID', o.id)
        node.set('Name', o.name)

        attr = ET.SubElement(node, 'Crises')
        for c in o.crises.all():
            ET.SubElement(attr, 'Crisis').set('ID', c.id)

        attr = ET.SubElement(node, 'People')
        for p in o.people.all():
            ET.SubElement(attr, 'Person').set('ID', p.id)

        if o.kind is not None:
            ET.SubElement(node, 'Kind').text = o.kind
        if len(o.location) > 0:
            ET.SubElement(node, 'Location').text = o.location
        if len(o.history) > 0:
            node.append(fromstring('<History>' + o.history + '</History>'))
        if len(o.contact) > 0:
            node.append(fromstring('<ContactInfo>' + o.contact + '</ContactInfo>'))
        getCommon(node, o)