[SalesForce] Convert Apex XML response into JSON Format

At this time, Salesforce does not provide a way to automatically transform XML to JSON (nor the other way around).

If you need to do something with XML, you need to write code specifically tailored to that domain (in other words, specific to the structure and data contained in the XML).

There are more than a few questions on this topic, and I'd suggest that you use the search bar on the top of the page to find them. I've even answered a few (1) of (2) them (3) myself (4)

The general approach I take is to use the Dom.Document and Dom.XmlNode classes in a series of classes that mimic the schema (structure) of the XML that you're dealing with. This is a 'divide and conquer' type approach. It's a bit of a pain to test, but it keeps the XML that you need to work with in any single method small and manageable.

To help you get started...

public class MyXmlParser{
    Results result;

    // In the top-level (outer) class, the constructor takes an XML document as a string
    //   and we start parsing it
    public MyXmlParser(String inputXML){
        Dom.Document xml = new Dom.Document();
        xml.load(inputXML);

        process(xml.getRootElement());
    }

    public void process(Dom.XmlNode inputNode){
        String currentNodeName;

        // This general pattern, looping over child nodes, creating class instances,
        //   and passing XML nodes to them will be repeated multiple times
        for(Dom.XmlNode childNode :inputNode.getChildElements){
            currentNodeName = childNode.getName();
            if(currentNodeName == 'results'){
                result = new Results();

                // Each level only concerns itself with extracting data on its own
                //   level.
                // If you need to call getChildElements() again to get more data, then
                //   in most cases, it's time to pass the baton on to an inner class.
                // This is what keeps the 'parsing' we're doing split up into
                //   manageable chunks
                result.process(childNode);
            }
        }
    }

    // Each XML tag that doesn't contain primitive data types gets its own inner class
    public class Results{
        Status stat;

        // If a tag only contains a collection of child tags, then it makes sense
        //   to make that a collection.
        // You could have another class for this one (which in turn would hold a
        //   collection of events) instead.
        // That's your call.
        List<Event> myEvents;

        // The constructor for each class is pretty basic, we just need to initialize
        //   collections (and not much else)
        public Results(){
            myEvents = new List<Event>();
        }

        // Each inner class gets a "process" method
        public void process(Dom.XmlNode inputNode){
            String currentNodeName;

            for(Dom.XmlNode childNode :inputNode.getChildElements()){
                currentNodeName = childNode.getName();
                if(currentNodeName == 'status'){
                    stat = new Status();
                    stat.process(childNode);
                }else if(currentNodeName == 'my-events'){
                    // Dealing with collections of xml nodes requires just a little change
                    //   to our approach.
                    // Instead of passing the 'my-events' node down, we need to extract
                    //   the children of that node, loop over them, and add the results
                    //   to our collection one at a time
                    Event tempEvent;
                    for(Dom.XmlNode grandchildNode :childNode.getChildElements()){
                        tempEvent = new Event();

                        // Note that we only go as far deep into the XML as is absolutely
                        //   necessary.
                        // Once we get to a place where we can pass the processing
                        //   off to another inner class, we do just that.
                        tempEvent.process(grandchildNode);
                        myEvents.add(tempEvent);
                    }
                }
            }
        }
    }

    public class Status{
        // Tag attributes become class variables
        String code;

        public void process(Dom.XmlNode inputNode){
            // Getting attributes from tags is pretty easy
            // The second parameter is the namespace of the tag, which you'll probably
            //   need to play around with yourself (until you can extract the attribute
            //   value)
            code = inputNode.getAttributeValue('code', '');
        }
    }

    public class Event{
        String sco_id;
        String type;
        String icon;
        String permission_id;

        // Tags that contain primitive data types (Strings, Integers, Booleans, Dates,
        //   etc...) also become class variables
        String name;
        String domain_name;
        // ...and so on

        public Event(){
        }

        public void process(Dom.XmlNode inputNode){
            // I'm skipping over extracting the attributes here, since I've already
            //   shown how that's done.
            String currentNodeName;

            for(Dom.XmlNode childNode :inputNode.getChildElements){
            currentNodeName = childNode.getName();
            if(currentNodeName == 'name'){
                // For nodes that contain a value only (no other nodes), we can
                //   extract the value using getText().
                // Strings don't require any special treatment
                name = childNode.getText();
            }else if(currentNodeName == 'date-begin'){
                // Non-string values (like this node, which is a datetime) will
                //   require some special handling
                // Most primitive types have a valueOf() method that allow you to
                //   pass a string in, and get an instance of the appropriate class out
                dateBegin = DateTime.valueOf(childNode.getText());
            }
        }
    }
}

The above code is only an example to get you started. It will not compile as-is, and you will need to complete it yourself. The point of what I wrote for you is to demonstrate everything you'll need to finish writing it yourself.