TypeError: function(...).then is not a function

If you're using a method .then, the object that precedes it is most likely a thenable (or an object that has a then method ). Usually who implements this type of method are the Promises . Looking at your code more closely we have

datosGrupos: function() {

    var getGrupos, infoGrupos;

    getGrupos = localStorage.getItem('GruposProf');
    infoGrupos = JSON.parse(getGrupos);

    return infoGrupos;

}

whom you then call

obtenerGruposProf.datosGrupos().then(//....

The error occurs because the function datosGruposdoes not return a promise and therefore there is no method .then. What that function returns as such is the data that you have in the localStorage, an ordinary object.

To get a promise back you should do something like

angular.module('gruposProfesor', ['ionic', 'ngCordova'])
    .factory('obtenerGruposProf', obtenerGruposProf);

obtenerGruposProf.$inject = ['$q'];

function obtenerGruposProf($q) {       
   return {    
    datosGrupos: function() {
        var defer = $q.defer(); 
        // creas un objeto Deferred que tiene un método resolve y reject   
        var getGrupos, infoGrupos;    
        getGrupos = localStorage.getItem('GruposProf');
        infoGrupos = JSON.parse(getGrupos);  
        // resuelves la promesa con el valor obtenido
        defer.resolve(infoGrupos) ;
        // devuelves el .promise que es el que tiene el método then 
        return defer.promise;    
    }    
  };    
}

You'd basically be returning a promise with the future result already resolved. This is an error for two reasons

1. You are creating asynchrony in an operation that is unavoidably synchronous.

   Operations on localStorage are synchronous. The getItem method immediately returns a string, which is the result of the operation, not a future result.

   It is much simpler to write

   var data = obtenerGruposProf.datosGrupos();
   console.log(data);
   

   what to write

   obtenerGruposProf.datosGrupos().then(function(data) {
       console.log(data);
   });
   

   since you are creating unnecessary nesting. This puts you one step closer to the callback-hell which is one of the reasons promises exist.

2. Usually writing promises that way is considered an anti -pattern since

   Promises are used to make asynchronous code retain most of the missing properties of synchronous code such as flat indentation and a single channel for errors.

   As you saw before you don't need to create indentation and in case of error you can use a simple try...catch

   In the Deferred anti-pattern, "deferred" objects are created for no reason, complicating the code.

There is a case in which it is convenient for you to write the code in this way and that is when, for example, you have to make an ajax call or return a stored result. Basically you have two options, one is synchronous and the other is asynchronous. In this case you can do this.

angular.module('gruposProfesor', ['ionic', 'ngCordova'])
    .factory('obtenerGruposProf', obtenerGruposProf);

obtenerGruposProf.$inject = ['$q', '$http'];

function obtenerGruposProf($q, $http) {       
   return {    
    datosGrupos: function() {
        var getGrupos, infoGrupos;    
        getGrupos = localStorage.getItem('GruposProf');
        if (getGrupos) {
            infoGrupos = JSON.parse(getGrupos);
            var defer = $q.defer();
            defer.resolve(infoGrupos);
            return defer.promise;
        } else {
            return $http.get('/miapi/gruposprof');    
        }    
    }    
  };    
}

Then you manipulate your data using

obtenerGruposProf.datosGrupos().then(function(data) {
    localStorage.setItem('GruposProf', JSON.stringify(data));
    console.log(data);
});

In this case deferred if necessary since you can't know for sure if the call will be asynchronous or not and the use of .thenis fully justified.

Finally keep in mind that if you want to cache the result of your ajax calls in localStorage there is already a service to do that.

Take a look at https://github.com/jmdobry/angular-cache .