ODE is already included in the Panda3D 1.7.0 distribution. The ODE classes are all under pandac.PandaModules, so since you've already imported everything from there into your program (using the '*'), you don't have to do anything to start using them.

1. The simulation actually takes place in two separate invisible simulation environments, one for the physics (called world) and another for collision handling (called space). So the first thing you do (you can do all of this in the constructor of your World class) is to instantiate and set up these two environments:

   self.world = ode.World()            # Create a physics/dynamics environment
   self.world.setGravity((0,0,-9.81))  # Add earth gravity in the negative z-dimension
   self.space = ode.Space()            # Create a collision environment

   For each object you want to be part of the physics simulation, you have to create a physical body. Here is how the physical body of the box is created (note that you still need your original Panda model of the box, that's the visible version of the box):

   self.boxbody = ode.Body(self.world)  # Instantiate a physical body in the physical environment
   self.boxbody.size = (0.3, 0.3, 0.3)  # Store the size of the body
   self.boxbody.setPosition((1,0,2))    # Place the body in the same location as in the Panda environment
   self.boxbody.addForce((0,0,1000))    # This is just for fun: give the box an upward kick at the beginning
   self.boxmass = ode.Mass()            # Define a physical mass for the box
   self.boxmass.setBox(500, *self.boxbody.size)  # The mass is defined as density and size
   self.boxbody.setMass(self.boxmass)   # Add the mass to the physical body of the box

   Now that you have a physical representation of the box, you still need to make an ODE collision solid for it and put into the collision environment. This is how:

   self.boxsolid = ode.GeomBox(self.space, self.boxbody.size)
   self.boxsolid.setBody(self.boxbody)

   To see the effect of gravity (and the kicking force) on the box, you will now have to start a task that copies the position of the physical box to the position of the visual box at every frame, and advances the physics simulation world by one step:

   taskMgr.add(self.simulate, 'ODE Simulation')  
   def simulate(self, task):
      x,y,z = self.boxbody.getPosition()  # Get position of the simulated physical box
      self.box.setPos(Vec3(x,y,z))        # Set the position of the visual box
      self.world.step(0.04)               # Increment time in the physical simulation
      return Task.cont                    # Keep this task running forever

   Test this and make sure gravity is working as expected. Make sure to comment out the LerpPosInterval for the box since you no longer need it! You should also change the left mouse button handler so that it sets the position of both the visual box and the physical box back to the original position (to maintain similar functionality as before). You will also want to set the linear velocity of the box to 0 like this self.boxbody.setLinearVel( (0,0,0) ), otherwise the box will keep going faster and faster
   

2. To introduce collision with the door, you will need to create both a physical body for the door and a ODE collision solid for the door, just like you did for the box. Try using size of (2,2,0.1) and density of 1000. Don't forget to update the door's visual position based on the physical position in the simulation task! In fact, this time, let's update both the position and the rotation of both objects. The problem is that ODE uses a matrix representation for rotation, so it needs to be converted into a format that Panda understands, which happens to be the quaternion format. Here is a function that will set the position and rotation of a Panda model, given position and rotation in ODE format (just add this as a utility function near the top of your program):

   def set_model_odeposrot(model, body):
       pos = body.getPosition()
       quat = body.getQuaternion()
       model.setPosQuat (VBase3(pos[0],pos[1],pos[2]), Quat(quat[0],quat[1],quat[2],quat[3])) 

   Your simulate task should now look like this:

   def simulate(self, task):
      set_model_odeposrot(self.box, self.boxbody.getPosition(), self.boxbody.getRotation())
      set_model_odeposrot(self.door, self.doorbody.getPosition(), self.doorbody.getRotation())
      self.world.step(0.04)
      return Task.cont

   You may notice that the door naturally falls down along with the box since there is nothing holding it up! We'll fix that next.
   

3. You need to attach the door to the environment so that it doesn't fall. In fact, the door is attached to the environment with a so-called slider joint because it can slide from side-to-side. ODE provides a number of joints for attaching objects to each other or to the environment. You create and attach the slider joint like this:

   self.doorslider = ode.SliderJoint(self.world)           # Instantiating a new slider joint
   self.doorslider.attach(self.doorbody, ode.environment)  # Using the joint to attach door body to environment
   self.doorslider.setAxis((1,0,0))                        # Slides along the x-axis
   self.doorslider.setParam(ode.paramFMax, 100)            # Sets the force of a motor attached to this joint

   The last line here actually attaches a little motor to the joint, which we can give a certain velocity whenever we want to move the joint autonomously. Try replacing the LerpPosInterval calls for opening and closing the door, with calls like this: self.doorslider.setParam(ode.paramVel, 0.3), where 0.3 is the velocity (can also be negative to go in the other direction).
   

4. Finally, let's add actual ODE collision handling. Comment out all of the previous collision handling code, since this will completely replace it. In World constructor, create the following member variable:

   self.contactgroup = ode.JointGroup()  # Holds a set of joints

   Inside the simulate task, you now have to ask the collision environment to check for near collisions like this:

   self.space.collide((self.world, self.contactgroup), self.near_callback)

   Where you then have a new member function called near_callback that looks like this:

   def near_callback(self, args, solid1, solid2):
      contacts = ode.collide(solid1, solid2)  # Returns the actual collisions between two solids
      world, contactgroup = args
      for c in contacts:
         c.setBounce(0.2)  # How much bounce should happen from this collision
         c.setMu(5000)     # How much friction there should be between the solids
         j = ode.ContactJoint(world, contactgroup, c)  # A temporary joint joins the solids together
         j.attach(solid1.getBody(), solid2.getBody())

   The very last thing to do is to call self.contactgroup.empty() right after you have called self.world.step(0.04) in order to start looking for fresh collisions after each iteration. Test to see if everything is working.
   

5. Play with various simulation values to see what effect they have on the object behavior. You could also try adding more boxes and have them pile on top of each other!