anchor.diff:  %%
   
   action(user, add, Args) ->
  -    case getopt(["uid", "auth", "credential"], Args) of
  -        {[[Uid], [Auth], [Credential]], Metadata} ->
  -            case call(user, add, [#uce_user{uid=Uid,
  -                                            auth=Auth,
  -                                            credential=Credential,
  -                                            metadata=Metadata}]) of
  +    case getopt(["domain", "uid", "auth", "credential"], Args) of
  +        {[none, _, _, _], _Metadata} ->
  +            error(missing_parameter);
  +        {[_, none, _, _], _Metadata} ->
  +            error(missing_parameter);
  +        {[_, _, none, _], _Metadata} ->
  +            error(missing_parameter);
  +        {[_, _, _, none], _Metadata} ->
  +            error(missing_parameter);
  +        {[[Domain], [Uid], [Auth], [Credential]], Metadata} ->
  +            case call(user, add, [Domain, #uce_user{uid=Uid,
  +                                                    auth=Auth,
  +                                                    credential=Credential,
  +                                                    metadata=Metadata}]) of
                   {ok, created} ->
                       success(created);
                   {error, Reason} ->
                       error(Reason)
  -            end;
  -        {[_Uid, _Auth, _Credential], _Metadata} ->
  -            error(missing_parameter)
  +            end
       end;
   
   action(user, delete, Args) ->
  -    case getopt(["uid"], Args) of
  -        {[[Uid]], _} ->
  -            case call(user, delete, [Uid]) of
  +    case getopt(["domain", "uid"], Args) of
  +        {[none, _], _} ->
  +            error(missing_parameter);
  +        {[_, none], _} ->
  +            error(missing_parameter);
  +        {[[Domain], [Uid]], _} ->
  +            case call(user, delete, [Domain, Uid]) of
                   {ok, deleted} ->
                       success(deleted);
  +                {error, Reason} ->
  +                    error(Reason)
  +            end
  +    end;
  +
  +
  +action(user, get, Args) ->
  +    case getopt(["domain", "uid"], Args, [none, none]) of
  +        {[none, _], _} ->
  +            error(missing_parameter);
  +        {[_, none], _} ->
  +            error(missing_parameter);
  +        {[[Domain], [Uid]], _} ->
  +            case call(user, get, [Domain, Uid]) of
  +                {ok, Record} ->
  +                    display(json, Record, record_info(fields, uce_user));
                   {error, Reason} ->
                       error(Reason)
               end;
  
positive.code: %%
  %% Info
  %%
  action(infos, get, _Args) ->
      case call(infos, get, []) of
          {ok, Infos} ->
              display(erlang, Infos);
          {error, Reason} ->
              error(Reason)
      end;
  
  action(infos, update, Args) ->
      case getopt([], Args) of
          {[], Metadata} ->
              case call(infos, update, [Metadata]) of
                  {ok, updated} ->
                      success(updated);
                  {error, Reason} ->
  
negative.code: %% ACL
  %%
  action(acl, add, Args) ->
      case getopt(["domain", "uid", "meeting", "object", "action"],
                  Args, [none, none, [""], none, none]) of
          {[none, _, _, _, _], _} ->
              error(missing_parameter);
          {[_, none, _, _, _], _} ->
              error(missing_parameter);
          {[_, _, _, none, _], _} ->
              error(missing_parameter);
          {[_, _, _, _, none], _} ->
              error(missing_parameter);
          {[[Domain], [Uid], [Meeting], [Object], [Action]], Conditions} ->
              case call(acl, add, [Domain, #uce_acl{uid=Uid,
                                                    location=[Meeting],
                                                    object=Object,
                                                    action=Action,
                                                    conditions=Conditions}]) of
                  {ok, created} ->
                      success(created);
                  {error, Reason} ->
                      error(Reason)
              end
      end;
  
  action(acl, delete, Args) ->
      case getopt(["domain", "uid", "meeting", "object", "action"],
                  Args, [none, none, [""], none, none]) of
          {[none, _, _, _, _], _} ->
              error(missing_parameter);
          {[_, none, _, _, _], _} ->
              error(missing_parameter);
          {[_, _, _, none, _], _} ->
              error(missing_parameter);
          {[_, _, _, _, none], _} ->
              error(missing_parameter);
          {[[Domain], [Uid], [Meeting], [Object], [Action]], Conditions} ->
              case call(acl, delete, [Domain, Uid, Object, Action, [Meeting], Conditions]) of
                  {ok, deleted} ->
                      success(deleted);
                  {error, Reason} ->
                      error(Reason)
              end
      end;
  
  action(acl, check, Args) ->
      case getopt(["domain", "uid", "meeting", "object", "action"],
                  Args, [none, none, [""], none, none]) of
          {[none, _, _, _, _], _} ->
              error(missing_parameter);
          {[_, none, _, _, _], _} ->
              error(missing_parameter);
          {[_, _, _, none, _], _} ->
              error(missing_parameter);
          {[_, _, _, _, none], _} ->
              error(missing_parameter);
          {[[Domain], [Uid], [Meeting], [Object], [Action]], Conditions} ->
              case call(acl, check, [Domain, Uid, Object, Action, [Meeting], Conditions]) of
                  {ok, true} ->
                      success(true);
                  {ok, false} ->
                      success(false);
                  {error, Reason} ->
                      error(Reason)
              end
      end;
  
  %%
  