Architecture for RESTful API and a web admin

Q: For the functionalities that are similar for the mobile and web admin, how can avoid duplicating the code?

Essentially, encapsulating the domain and the business logic in their own components and modules so the web layer acts as a driver or facade. This is what web interfaces are meant to be, an extension which allows our business expand up to the WWW.

How we do it? Following the principle of stable dependency. In a nutshell, we turn the domain and the business into our stable dependency so all the dependencies point out toward these two.

[Web] -----> [Business] ----> [Domain] 

This way we could add more facades or UIs

[MVC web]  --------+
[REST web] --------+-->[Business] ----> [Domain] 
[Command Line] ----+

_{Note: The arrows show the direction of dependency, not data flows.}

Q: How can I maintain the database?

As you would in any other application, encapsulating and decoupling the persistence from the domain and the business. How? Making persistence to point out toward stable dependencies.

               [Domain] 
                  ^
                  |
[Web] ---> [Business] <---- [Persistence] 

Q: I will be using an ORM, does this mean I have to write the DB models twice? One for the RESTful API and one for the Web Admin that will be directly talking to the database.

No, if you decouple the persistence from anything else, you could have a single persistence data model for the business. This model, ideally should not be accessible to outer layers. It's a lot of work I know. Different data models for different layers is costly and involves several mappings.

As for the web layer, my advice is different. Implement two different view data models. One for the MVC interface and one for the REST interface. The reason is simple, both interfaces are going to evolve at different rates, time and in different directions due to different reasons and actors. Canonical data models rarely works in software engineering. They work for a while but they don't last for too long because UI layers are volatile. A single view model will constraint the way both web interfaces evolve.

Even if we start with a single view model, my experience on the field tell me that it will diverge eventually.

For the first answer, i'd suggest creating a "service layer" that can be called by both RESTful API methods and controllers methods for the web admin, if your plan was serve web pages directly by the server. However it's a better practice to separate back-end and front-end. In this case, the back-end will have only to expose RESTful API that will be called by both web admin and app.

For the latter question: in general, orm objects should be distinct from domain objects, but if want to use them as also for domain, then you won't have to duplicate them as the web admin and the app will interact only with the api (or the web controller)