public BundleRequestModel(IUrlManager urlManager, IActionContextAccessor accessor, IRequestHelper requestHelper, IBundleManager bundleManager, CacheBusterResolver cacheBusterResolver)
: base("bundle", urlManager, accessor, requestHelper)
{
//TODO: Pretty sure if we want to control the caching of the file, we'll have to retrieve the bundle definition here
// In reality we'll need to do that anyways if we want to support load balancing!
// https://github.com/Shazwazza/Smidge/issues/17
if (!ParsedPath.Names.Any())
{
throw new InvalidOperationException("The bundle route value does not contain a bundle name");
}
FileKey = ParsedPath.Names.Single();
Bundle bundle;
if (!bundleManager.TryGetValue(FileKey, out bundle))
{
throw new InvalidOperationException("No bundle found with key " + FileKey);
}
Bundle = bundle;
CacheBuster = cacheBusterResolver.GetCacheBuster(bundle.GetBundleOptions(bundleManager, Debug).GetCacheBusterType());
}
protected RequestModel(string valueName, IUrlManager urlManager, IActionContextAccessor accessor)
{
//default
LastFileWriteTime = DateTime.Now;
Compression = accessor.ActionContext.HttpContext.Request.GetClientCompression();
var bundleId = (string)accessor.ActionContext.RouteData.Values[valueName];
ParsedPath = urlManager.ParsePath(bundleId);
switch (ParsedPath.WebType)
{
case WebFileType.Js:
Extension = ".js";
Mime = "text/javascript";
break;
case WebFileType.Css:
default:
Extension = ".css";
Mime = "text/css";
break;
}
}
public CompositeFileModel(IHasher hasher, IUrlManager urlManager, IActionContextAccessor accessor, IRequestHelper requestHelper, IBundleManager bundleManager, CacheBusterResolver cacheBusterResolver)
: base("file", urlManager, accessor, requestHelper)
{
//Creates a single hash of the full url (which can include many files)
FileKey = hasher.Hash(string.Join(".", ParsedPath.Names));
CacheBuster = cacheBusterResolver.GetCacheBuster(bundleManager.GetDefaultBundleOptions(false).GetCacheBusterType());
}
public CardsController(ICardAppService cardAppService,
IUrlManager urlManager,
IApplicationUser applicationUser)
{
_cardAppService = cardAppService;
_urlManager = urlManager;
_applicationUser = applicationUser;
}
public TransfersController(ITransferAppService transferAppService,
IUrlManager urlManager,
IApplicationUser applicationUser)
{
_transferAppService = transferAppService;
_urlManager = urlManager;
_applicationUser = applicationUser;
}
public BlogContentCreator(IUrlManager urlManager, IModerationProcessor moderationProcessor)
{
if (urlManager == null || moderationProcessor == null)
{
throw new ArgumentNullException();
}
this._urlManager = urlManager;
this._moderationProcessor = moderationProcessor;
}
public BundleModel(IUrlManager urlManager, IActionContextAccessor accessor)
: base("bundle", urlManager, accessor)
{
if (!ParsedPath.Names.Any())
{
throw new InvalidOperationException("The bundle route value does not contain a bundle name");
}
_bundleName = ParsedPath.Names.Single();
}
public BundleModel(IUrlManager urlManager, IActionContextAccessor accessor)
: base("bundle", urlManager, accessor)
{
if (!ParsedPath.Names.Any())
{
throw new InvalidOperationException("The bundle route value does not contain a bundle name");
}
_bundleName = ParsedPath.Names.Single();
}
protected RequestModel(string valueName, IUrlManager urlManager, IActionContextAccessor accessor, IRequestHelper requestHelper)
{
if (string.IsNullOrWhiteSpace(valueName))
{
throw new ArgumentException("message", nameof(valueName));
}
if (urlManager is null)
{
throw new ArgumentNullException(nameof(urlManager));
}
if (accessor is null)
{
throw new ArgumentNullException(nameof(accessor));
}
if (requestHelper is null)
{
throw new ArgumentNullException(nameof(requestHelper));
}
//default
LastFileWriteTime = DateTime.Now;
Compression = requestHelper.GetClientCompression(accessor.ActionContext.HttpContext.Request.Headers);
var bundleId = (string)accessor.ActionContext.RouteData.Values[valueName];
ParsedPath = urlManager.ParsePath(bundleId);
if (ParsedPath == null)
{
throw new InvalidOperationException($"Could not parse {bundleId} as a valid smidge path");
}
Debug = ParsedPath.Debug;
switch (ParsedPath.WebType)
{
case WebFileType.Js:
Extension = ".js";
Mime = "text/javascript";
break;
case WebFileType.Css:
default:
Extension = ".css";
Mime = "text/css";
break;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="env"></param>
/// <param name="config"></param>
public SmidgeController(
IApplicationEnvironment env,
ISmidgeConfig config,
FileSystemHelper fileSystemHelper,
IHasher hasher,
BundleManager bundleManager,
IUrlManager urlManager)
{
_urlManager = urlManager;
_hasher = hasher;
_env = env;
_config = config;
_fileSystemHelper = fileSystemHelper;
_bundleManager = bundleManager;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="env"></param>
/// <param name="config"></param>
/// <param name="fileSystemHelper"></param>
/// <param name="hasher"></param>
/// <param name="bundleManager"></param>
/// <param name="urlManager"></param>
public SmidgeController(
IApplicationEnvironment env,
ISmidgeConfig config,
FileSystemHelper fileSystemHelper,
IHasher hasher,
BundleManager bundleManager,
IUrlManager urlManager)
{
_urlManager = urlManager;
_hasher = hasher;
_env = env;
_config = config;
_fileSystemHelper = fileSystemHelper;
_bundleManager = bundleManager;
}
public RequestModel(string valueName, IUrlManager urlManager, IScopedInstance<ActionContext> action)
{
//default
LastFileWriteTime = DateTime.Now;
Compression = action.Value.HttpContext.Request.GetClientCompression();
var bundleId = (string)action.Value.RouteData.Values[valueName];
ParsedPath = urlManager.ParsePath(bundleId);
switch (ParsedPath.WebType)
{
case WebFileType.Js:
Extension = ".js";
Mime = "text/javascript";
break;
case WebFileType.Css:
default:
Extension = ".css";
Mime = "text/css";
break;
}
}
public UrlController(IUrlManager urlManager)
{
this._urlManager = urlManager;
}
public ApiUrlController(IUrlManager urlManager)
{
this._urlManager = urlManager;
}
public ChargesController(IChargeAppService chargeAppService, IUrlManager urlManager, IApplicationUser applicationUser)
{
_chargeAppService = chargeAppService;
_urlManager = urlManager;
_applicationUser = applicationUser;
}
public UrlController(IUrlManager urlManager)
{
_urlManager = urlManager;
}
public HomeController(ILogger <HomeController> logger, IUrlManager urlManager, IKittenUrlClient urlClient)
{
_logger = logger;
_urlManager = urlManager;
_urlClient = urlClient;
}
public CompositeFileModel(IHasher hasher, IUrlManager urlManager, IActionContextAccessor accessor)
: base("file", urlManager, accessor)
{
//Creates a single hash of the full url (which can include many files)
_fileSetKey = hasher.Hash(string.Join(".", ParsedPath.Names));
}
// use it to parse key
// private readonly IKeyManager _keyManager;
public RerouteController(IUrlManager urlManager /*, IKeyManager keyManager*/) : base()
{
_urlManager = urlManager;
}
public SmidgeContext(IUrlManager urlCreator)
{
UrlCreator = urlCreator;
Files = new HashSet <IWebFile>();
}
public SmidgeContext(IUrlManager urlCreator)
{
UrlCreator = urlCreator;
Files = new HashSet<IWebFile>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="fileSetGenerator"></param>
/// <param name="dynamicallyRegisteredWebFiles"></param>
/// <param name="preProcessManager"></param>
/// <param name="fileSystemHelper"></param>
/// <param name="hasher"></param>
/// <param name="bundleManager"></param>
/// <param name="processorFactory"></param>
/// <param name="urlManager"></param>
/// <param name="requestHelper"></param>
/// <param name="httpContextAccessor"></param>
/// <param name="cacheBusterResolver"></param>
public SmidgeHelper(
IBundleFileSetGenerator fileSetGenerator,
DynamicallyRegisteredWebFiles dynamicallyRegisteredWebFiles,
PreProcessManager preProcessManager,
FileSystemHelper fileSystemHelper,
IHasher hasher,
IBundleManager bundleManager,
PreProcessPipelineFactory processorFactory,
IUrlManager urlManager,
IRequestHelper requestHelper,
IHttpContextAccessor httpContextAccessor,
CacheBusterResolver cacheBusterResolver)
{
if (fileSetGenerator == null)
{
throw new ArgumentNullException(nameof(fileSetGenerator));
}
if (dynamicallyRegisteredWebFiles == null)
{
throw new ArgumentNullException(nameof(dynamicallyRegisteredWebFiles));
}
if (preProcessManager == null)
{
throw new ArgumentNullException(nameof(preProcessManager));
}
if (fileSystemHelper == null)
{
throw new ArgumentNullException(nameof(fileSystemHelper));
}
if (bundleManager == null)
{
throw new ArgumentNullException(nameof(bundleManager));
}
if (processorFactory == null)
{
throw new ArgumentNullException(nameof(processorFactory));
}
if (urlManager == null)
{
throw new ArgumentNullException(nameof(urlManager));
}
if (requestHelper == null)
{
throw new ArgumentNullException(nameof(requestHelper));
}
if (httpContextAccessor == null)
{
throw new ArgumentNullException(nameof(httpContextAccessor));
}
if (cacheBusterResolver == null)
{
throw new ArgumentNullException(nameof(cacheBusterResolver));
}
_fileSetGenerator = fileSetGenerator;
_processorFactory = processorFactory;
_urlManager = urlManager;
_requestHelper = requestHelper;
_httpContextAccessor = httpContextAccessor;
_cacheBusterResolver = cacheBusterResolver;
_bundleManager = bundleManager;
_preProcessManager = preProcessManager;
_dynamicallyRegisteredWebFiles = dynamicallyRegisteredWebFiles;
_fileSystemHelper = fileSystemHelper;
_fileBatcher = new FileBatcher(_fileSystemHelper, _requestHelper, hasher);
}
public HomeController(IUrlManager urlManager)
{
this._urlManager = urlManager;
}
public UrlController(IUrlManager urlManager, IKeyManager keyManager) : base()
{
_urlManager = urlManager;
_keyManager = keyManager;
}
public CompositeFileModel(IHasher hasher, IUrlManager urlManager, IActionContextAccessor accessor)
: base("file", urlManager, accessor)
{
//Creates a single hash of the full url (which can include many files)
_fileSetKey = hasher.Hash(string.Join(".", ParsedPath.Names));
}
public ReturnUrlManager(IUrlManager urlManager)
{
_urlManager = urlManager;
}
