2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

[DependsOn(typeof(AbpWebApiModule))] //We declare depended modules explicitly

public class SimpleTaskSystemWebApiModule : AbpModule

{

    public override void Initialize()

    {

        //This code is used to register classes to dependency injection system for this assembly using conventions.

        IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());

        //Creating dynamic Web Api Controllers for application services.

        //Thus, ‘web api layer‘ is created automatically by ABP.

        DynamicApiControllerBuilder

            .ForAll<IApplicationService>(Assembly.GetAssembly(typeof (SimpleTaskSystemApplicationModule)), "tasksystem")

            .Build();

    }

}

2

3

4

public static IBatchApiControllerBuilder<T> ForAll<T>(Assembly assembly, string servicePrefix)

{

    return new BatchApiControllerBuilder<T>(assembly, servicePrefix);

}

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

internal class ApiControllerBuilder<T> : IApiControllerBuilder<T>

{

    /// <summary>

    /// Name of the controller.

    /// </summary>

    private readonly string _serviceName;

    /// <summary>

    /// List of all action builders for this controller.

    /// </summary>

    private readonly IDictionary<string, ApiControllerActionBuilder<T>> _actionBuilders;

    /// <summary>

    /// Action Filters to apply to the whole Dynamic Controller.

    /// </summary>

    private IFilter[] _filters;

    /// <summary>

    /// Creates a new instance of ApiControllerInfoBuilder.

    /// </summary>

    /// <param name="serviceName">Name of the controller</param>

    public ApiControllerBuilder(string serviceName)

    {

        if (string.IsNullOrWhiteSpace(serviceName))

        {

            throw new ArgumentException("serviceName null or empty!", "serviceName");

        }

        if (!DynamicApiServiceNameHelper.IsValidServiceName(serviceName))

        {

            throw new ArgumentException("serviceName is not properly formatted! It must contain a single-depth namespace at least! For example: ‘myapplication/myservice‘.", "serviceName");

        }

        _serviceName = serviceName;

        _actionBuilders = new Dictionary<string, ApiControllerActionBuilder<T>>();

        foreach (var methodInfo in DynamicApiControllerActionHelper.GetMethodsOfType(typeof(T)))

        {

            _actionBuilders[methodInfo.Name] = new ApiControllerActionBuilder<T>(this, methodInfo);

        }

    }

    /// <summary>

    /// The adds Action filters for the whole Dynamic Controller

    /// </summary>

    /// <param name="filters"> The filters. </param>

    /// <returns>The current Controller Builder </returns>

    public IApiControllerBuilder<T> WithFilters(params IFilter[] filters)

    {

        _filters = filters;

        return this;

    }

    /// <summary>

    /// Used to specify a method definition.

    /// </summary>

    /// <param name="methodName">Name of the method in proxied type</param>

    /// <returns>Action builder</returns>

    public IApiControllerActionBuilder<T> ForMethod(string methodName)

    {

        if (!_actionBuilders.ContainsKey(methodName))

        {

            throw new AbpException("There is no method with name " + methodName + " in type " + typeof(T).Name);

        }

        return _actionBuilders[methodName];

    }

    /// <summary>

    /// Builds the controller.

    /// This method must be called at last of the build operation.

    /// </summary>

    public void Build()

    {

        var controllerInfo = new DynamicApiControllerInfo(_serviceName, typeof(DynamicApiController<T>), _filters);

        foreach (var actionBuilder in _actionBuilders.Values)

        {

            if (actionBuilder.DontCreate)

            {

                continue;

            }

            controllerInfo.Actions[actionBuilder.ActionName] = actionBuilder.BuildActionInfo();

        }

        IocManager.Instance.IocContainer.Register(

            Component.For<AbpDynamicApiControllerInterceptor<T>>().LifestyleTransient(),

            Component.For<DynamicApiController<T>>().Proxy.AdditionalInterfaces(new[] { typeof(T) }).Interceptors<AbpDynamicApiControllerInterceptor<T>>().LifestyleTransient()

            );

        DynamicApiControllerManager.Register(controllerInfo);

        LogHelper.Logger.DebugFormat("Dynamic web api controller is created for type ‘{0}‘ with service name ‘{1}‘.", typeof(T).FullName, controllerInfo.ServiceName);

    }

}