public class AutomapperRegistry : Registry
    {
        public AutomapperRegistry()
        {
            For<MapperConfiguration>().Use("", ctx =>
            {
                var config = new MapperConfiguration(cfg =>
                {
                    AutomapperConfig.setup(cfg, ctx);
                });

                config.AssertConfigurationIsValid();
                
                return config;

            }).Singleton();

            For<IMapper>()
                .HttpContextScoped()
                .Use(ctx => 
                    ctx.GetInstance<MapperConfiguration>().CreateMapper(ctx.GetInstance));
        }
        
    }

public static class AutomapperConfig
    {
        public static void setup(IMapperConfigurationExpression mappconfig, IContext ctx)
        {
            configureAutoMapper(mappconfig, ctx);
        }

        private static void configureAutoMapper(IMapperConfigurationExpression mappconfig, IContext ctx)
        {
            var profiles = ctx.GetAllInstances<AutoMapper.Profile>().ToList();
            foreach (var profile in profiles)
            {
                mappconfig.AddProfile(profile);
            }

            var types = Assembly.GetExecutingAssembly().GetExportedTypes();

            LoadStandardMappings(types, mappconfig);

            LoadCustomMappings(types, mappconfig);
        }

        private static void LoadStandardMappings(IEnumerable<Type> types, IMapperConfigurationExpression mapper)
        {
            var maps = (from t in types
                        from i in t.GetInterfaces()
                        where i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IMapFrom<>) && !t.IsAbstract && !t.IsInterface
                        select new
                        {
                            Source = i.GetGenericArguments()[0],
                            Destination = t
                        }).ToArray();

            foreach (var map in maps)
            {
                mapper.CreateMap(map.Source, map.Destination);
            }
        }

        private static void LoadCustomMappings(IEnumerable<Type> types, IMapperConfigurationExpression mapper)
        {
            var maps = (from t in types
                        from i in t.GetInterfaces()
                        where typeof(IHaveCustomMappings).IsAssignableFrom(t) && !t.IsAbstract && !t.IsInterface
                        select (IHaveCustomMappings)Activator.CreateInstance(t)).ToArray();

            foreach (var map in maps)
            {
                map.CreateMappings(mapper);
            }
        }
    }

gulp.task("templates", function () {
    return gulp.src(appFolder + "/**/*.html")
        //.pipe(minifyHTML())
        .pipe(gulp.dest(outFolder + "/app"));
});