public ContentController(IContentTypeProvider contentTypeProvider, IClaimCheck claimCheck, IContentProvider ContentProvider, Microsoft.AspNetCore.Identity.UserManager <SIPx.API.Models.SipUser> userManager)
{
_contentTypeProvider = contentTypeProvider;
_claimCheck = claimCheck;
_contentProvider = ContentProvider;
_userManager = userManager;
}
public Server(
IHttpListener listener,
IEndpointProvider endpointProvider,
IOutput output,
ISoapDecoder soapDecoder,
ILogger logger,
IContentTypeProvider contentTypeProvider,
IWebRequestFactory webRequestFactory)
{
this.listener = listener;
this.endpointProvider = endpointProvider;
this.output = output;
this.soapDecoder = soapDecoder;
this.logger = logger;
this.contentTypeProvider = contentTypeProvider;
this.webRequestFactory = webRequestFactory;
try
{
listener.Prefixes.Add(endpointProvider.ServerBaseUrl);
}
catch (ArgumentException ex)
{
throw new FailException(
string.Format(
"While attempting to listen on URL '{1}': {0}",
ex.Message,
endpointProvider.ServerBaseUrl),
ex);
}
logger.Info("Listening on: {0}", endpointProvider.ServerBaseUrl);
}
public ImagesLibraryController(
IHostingEnvironment env,
IContentTypeProvider contentTypeProvider)
{
_env = env;
_contentTypeProvider = contentTypeProvider;
}
public FrontMatterContentSerializer(IContentTypeProvider contentTypeProvider)
{
_contentTypeProvider = contentTypeProvider;
_yamlDeserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention(), ignoreUnmatched: true);
_yamlSerializer = new Serializer(namingConvention: new CamelCaseNamingConvention());
_yamlSerializer.RegisterTypeConverter(new DateTimeConverter());
}
public PicturesController(
IContentTypeProvider contentTypeProvider,
ILogger <PicturesController> logger)
{
_contentTypeProvider = contentTypeProvider;
_logger = logger;
}
/// <inheritdoc />
public async Task SerializeResult(ISerializedResult toSerialize, IContentTypeProvider contentTypeProvider, CancellationToken cancellationToken)
{
switch (toSerialize.Result)
{
case Head head:
head.Headers["EntityCount"] = head.EntityCount.ToString();
return;
case Binary binary:
await binary.BinaryResult.WriteToStream(toSerialize.Body, cancellationToken).ConfigureAwait(false);
return;
case IEntities <object> entities and Content content:
await SerializeContentDataCollection((dynamic)entities, content, toSerialize, contentTypeProvider, cancellationToken).ConfigureAwait(false);
break;
case Report report:
await SerializeContentDataCollection((dynamic)report.ToAsyncSingleton(), report, toSerialize, contentTypeProvider, cancellationToken).ConfigureAwait(false);
break;
case Error error:
await SerializeError(error, toSerialize, contentTypeProvider, cancellationToken).ConfigureAwait(false);
break;
default: return;
}
}
/// <summary>
/// Initialize the Url Image Resizer middleware.
/// </summary>
/// <param name="next"></param>
/// <param name="provider"></param>
public UrlImageResizerMiddleware(RequestDelegate next, IUrlImageResizerProvider provider, IWebHostEnvironment hostingEnv, IOptions <StaticFileOptions> options, IOptions <UrlImageResizerOptions> urlImageResizerOptions, ILoggerFactory loggerFactory)
{
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (hostingEnv == null)
{
throw new ArgumentNullException("hostingEnv");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
if (loggerFactory == null)
{
throw new ArgumentNullException("loggerFactory");
}
this._next = next;
this._options = options.Value;
this._contentTypeProvider = options.Value.ContentTypeProvider ?? new FileExtensionContentTypeProvider();
this._matchUrl = this._options.RequestPath;
this._logger = loggerFactory.CreateLogger <UrlImageResizerMiddleware>();
_next = next;
_provider = provider;
this.urlImageResizerOptions = urlImageResizerOptions;
}
public IfModifiedMiddleware(RequestDelegate next, ICacheableSpecification cacheableSpecification)
{
_next = next;
_cacheableSpecification = cacheableSpecification;
_mimeTypeProvider = new FileExtensionContentTypeProvider();
}
public DocumentsController(
IMediator mediator,
ITempContentStorage tempContentStorage,
IUserService userService,
IDocumentStorage documentStorage,
IContentTypeProvider contentTypeProvider,
IFoldersStorage foldersStorage,
IDataProtectionProvider dataProtectionProvider)
{
if (dataProtectionProvider == null)
{
throw new ArgumentNullException(nameof(dataProtectionProvider));
}
this.mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
this.tempContentStorage = tempContentStorage ?? throw new ArgumentNullException(nameof(tempContentStorage));
this.userService = userService ?? throw new ArgumentNullException(nameof(userService));
this.documentStorage = documentStorage ?? throw new ArgumentNullException(nameof(documentStorage));
this.contentTypeProvider = contentTypeProvider ?? throw new ArgumentNullException(nameof(contentTypeProvider));
this.foldersStorage = foldersStorage ?? throw new ArgumentNullException(nameof(foldersStorage));
dataProtector = dataProtectionProvider
.CreateProtector(nameof(DocumentsController))
.ToTimeLimitedDataProtector();
}
public ContentRouteCreator(ILogger <ContentRouteCreator> logger, EndpointDataSource endpointDataSource, IContentTypeProvider contentTypeProvider, IContentTypeExpander contentTypeExpander)
{
Logger = logger;
EndpointDataSource = endpointDataSource;
ContentTypeProvider = contentTypeProvider;
ContentTypeExpander = contentTypeExpander;
}
public SingletonInserter(ISingletonProvider singletonProvider, IContentTypeProvider contentTypeProvider, IContentGetter contentGetter, IContentInserter contentInserter)
{
SingletonProvider = singletonProvider;
ContentTypeProvider = contentTypeProvider;
ContentGetter = contentGetter;
ContentInserter = contentInserter;
}
public PluginStaticFileMiddleware(RequestDelegate next, IHostingEnvironment hostingEnv, IOptions <StaticFileOptions> options, IPluginLoader pluginLoader)
{
_next = next;
_contentTypeProvider = options.Value.ContentTypeProvider ?? new FileExtensionContentTypeProvider();
_pluginLoader = pluginLoader;
_hostingEnvironment = hostingEnv;
}
public FrontUserPageSectionController(IContentTypeProvider contentTypeProvider
, IPageSectionTypeProvider pageSectionTypeProvider
, IPageSectionDataTypeProvider pageSectionDataTypeProvider
, IFrontUserPageSectionProvider frontUserPageSectionProvider
, IPageSectionProvider pageSectionProvider
, IFrontUserPageProvider frontUserPageProvider
, IMasterListProvider masterListProvider
, IMasterProvider masterProvider
, ICheckProvider checkProvider
, IClaimCheck claimCheck
, IPageProvider pageProvider
, Microsoft.AspNetCore.Identity.UserManager <SIPx.API.Models.SipUser> userManager)
{
_masterProvider = masterProvider;
_contentTypeProvider = contentTypeProvider;
_pageSectionTypeProvider = pageSectionTypeProvider;
_pageSectionDataTypeProvider = pageSectionDataTypeProvider;
_frontUserPageSectionProvider = frontUserPageSectionProvider;
_pageSectionProvider = pageSectionProvider;
_frontUserPageProvider = frontUserPageProvider;
_masterListProvider = masterListProvider;
_checkProvider = checkProvider;
_claimCheck = claimCheck;
_pageProvider = pageProvider;
_userManager = userManager;
}
public FrontContentController(IHostingEnvironment hostingEnvironment, ICheckProvider checkProvider, IClassificationProvider classificationProvider
, IClassificationValueProvider classificationValueProvider
, IContentTypeProvider contentTypeProvider
, ILanguageProvider languageProvider
, IContentStatusProvider contentStatusProvider
, ISecurityLevelProvider securityLevelProvider
, IOrganizationProvider organizationProvider
, IProjectProvider projectProvider
, IFrontContentProvider frontContentProvider
, IContentProvider contentProvider
, IClaimCheck claimCheck
, IFrontProvider frontProvider
, Microsoft.AspNetCore.Identity.UserManager <SIPx.API.Models.SipUser> userManager)
{
_hostingEnvironment = hostingEnvironment;
_checkProvider = checkProvider;
_classificationProvider = classificationProvider;
_classificationValueProvider = classificationValueProvider;
_contentTypeProvider = contentTypeProvider;
_languageProvider = languageProvider;
_contentStatusProvider = contentStatusProvider;
_securityLevelProvider = securityLevelProvider;
_organizationProvider = organizationProvider;
_projectProvider = projectProvider;
_frontContentProvider = frontContentProvider;
_contentProvider = contentProvider;
_claimCheck = claimCheck;
_frontProvider = frontProvider;
_userManager = userManager;
}
public ContentItemProvider(IContentTypeProvider contentTypeProvider, IDocumentFinder documentFinder, IContainerSpecificContentGetter containerSpecificContentGetter, IContentDeserializer contentDeserializer)
{
ContentTypeProvider = contentTypeProvider;
DocumentFinder = documentFinder;
ContainerSpecificContentGetter = containerSpecificContentGetter;
ContentDeserializer = contentDeserializer;
}
public RemoveContentController(IPrimaryKeyConverter primaryKeyConverter, IContentDeleter contentDeleter, IContentTypeProvider contentTypeProvider, IContentGetter contentGetter)
{
PrimaryKeyConverter = primaryKeyConverter;
ContentDeleter = contentDeleter;
ContentTypeProvider = contentTypeProvider;
ContentGetter = contentGetter;
}
public TaskModulesDownloadController(
IHostingEnvironment env,
IContentTypeProvider contentTypeProvider)
{
_env = env;
_contentTypeProvider = contentTypeProvider;
}
/// <summary>
/// Creates a new instance of the StaticFileMiddleware.
/// </summary>
/// <param name="next">The next middleware in the pipeline.</param>
/// <param name="hostingEnv">The <see cref="IWebHostEnvironment"/> used by this middleware.</param>
/// <param name="options">The configuration options.</param>
/// <param name="loggerFactory">An <see cref="ILoggerFactory"/> instance used to create loggers.</param>
public StaticFileMiddleware(RequestDelegate next, IWebHostEnvironment hostingEnv, IOptions <StaticFileOptions> options, ILoggerFactory loggerFactory)
{
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
if (hostingEnv == null)
{
throw new ArgumentNullException(nameof(hostingEnv));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_next = next;
_options = options.Value;
_contentTypeProvider = _options.ContentTypeProvider ?? new FileExtensionContentTypeProvider();
_fileProvider = _options.FileProvider ?? Helpers.ResolveFileProvider(hostingEnv);
_matchUrl = _options.RequestPath;
_logger = loggerFactory.CreateLogger <StaticFileMiddleware>();
}
public CommonController(IFileSystem fileSystem, IRepository <FileRecord> fileRepo, IContentTypeProvider contentTypeProvider, ILogger <CommonController> logger)
{
_fileSystem = fileSystem;
_fileRepo = fileRepo;
_contentTypeProvider = contentTypeProvider;
_logger = logger;
}
public static void UsePrecompressedStaticFiles(this IApplicationBuilder applicationBuilder,
IFileProvider fileProvider, IContentTypeProvider contentTypeProvider)
{
applicationBuilder.Use(async(context, next) => {
var reqPath = context.Request.Path;
var fileOnDisk = fileProvider.GetFileInfo(reqPath + ".gz");
if (fileOnDisk.Exists)
{
Console.WriteLine($"Serving {fileOnDisk.PhysicalPath}");
if (contentTypeProvider.TryGetContentType(reqPath, out var contentType))
{
context.Response.ContentType = contentType;
}
context.Items["IsPrecompressed"] = true;
context.Response.ContentLength = fileOnDisk.Length;
context.Response.Headers["Content-Encoding"] = "gzip";
using (var fs = fileOnDisk.CreateReadStream())
{
await fs.CopyToAsync(context.Response.Body);
}
}
else
{
await next();
}
});
}
public PropertyDefinitionProvider(IContentTypeProvider contentTypeProvider, IPropertyMappingProvider propertyMappingProvider, IPropertyDefinitionCreator propertyDefinitionCreator)
{
foreach (var contentType in contentTypeProvider.GetAll())
{
var propertyDefinitions = new List <PropertyDefinitionDescriptor>();
foreach (var property in contentType.Type.GetProperties())
{
var mapping = propertyMappingProvider.Get(property);
if (mapping.PropertyMappingType == PropertyMappingType.Ignored)
{
continue;
}
if (mapping.PropertyMappingType == PropertyMappingType.CoreInterface)
{
continue;
}
if (mapping.PropertyMappingType == PropertyMappingType.Incomplete)
{
continue;
}
propertyDefinitions.Add(propertyDefinitionCreator.Create(property));
}
Values[contentType.Id] = propertyDefinitions.AsReadOnly();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceFileMiddleware"/> class.
/// </summary>
/// <param name="loggerFactory">The factory used to create loggers.</param>
/// <param name="options">The <see cref="ResourceFileOptions"/> used to configure the middleware.</param>
public ResourceFileMiddleware(ILoggerFactory loggerFactory, ResourceFileOptions options)
{
//var rm = new System.Resources.ResourceManager("Bytewizer.TinyCLR.WebServer.Properties.Resources", _options.Assembly);
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_logger = loggerFactory.CreateLogger("Bytewizer.TinyCLR.Http");
_options = options;
_resources = _options.Resources ?? new Hashtable();
_resourceManager = _options.ResourceManager;
_contentTypeProvider = _options.ContentTypeProvider ?? new DefaultContentTypeProvider();
_lastModified = DateTime.Now;
if (_options.ResourceManager == null)
{
throw new ArgumentException("Missing Resource Manager implementation.");
}
}
public GetContentListController(IContentTypeProvider contentTypeRepository, IDocumentFinder documentFinder, IContentDeserializer contentDeserializer, IPropertyDefinitionProvider propertyDefinitionProvider)
{
ContentTypeProvider = contentTypeRepository;
DocumentFinder = documentFinder;
ContentDeserializer = contentDeserializer;
PropertyDefinitionProvider = propertyDefinitionProvider;
}
public void SetUp()
{
_contentTypeProvider = A.Fake <IContentTypeProvider>();
_gZipDecompressor = A.Fake <IGZipDecompressor>();
_zipDecompressor = A.Fake <IZipDecompressor>();
_attachmentStreamNormaliser = new AttachmentStreamNormaliser(_contentTypeProvider, _gZipDecompressor, _zipDecompressor, A.Fake <ILogger>());
}
public BlobFileStore(BlobStorageOptions options, IClock clock, IContentTypeProvider contentTypeProvider)
{
_options = options;
_clock = clock;
_contentTypeProvider = contentTypeProvider;
_storageAccount = CloudStorageAccount.Parse(_options.ConnectionString);
_blobClient = _storageAccount.CreateCloudBlobClient();
_blobContainer = _blobClient.GetContainerReference(_options.ContainerName);
_verifyContainerTask = Task.Run(async() =>
{
try
{
await _blobContainer.CreateIfNotExistsAsync();
await CreateBasePathIfNotExistsAsync();
await _blobContainer.SetPermissionsAsync(new BlobContainerPermissions()
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
catch (Exception ex)
{
throw new FileStoreException($"Error while creating or setting permissions on container {_options.ContainerName}.", ex);
}
});
}
public ContainerSpecificContentCreator(IDocumentCreator documentCreator, IIdGenerator idGenerator, IContentTypeProvider contentTypeRepository, IContentSerializer contentSerializer)
{
DocumentCreator = documentCreator;
IdGenerator = idGenerator;
ContentTypeRepository = contentTypeRepository;
ContentSerializer = contentSerializer;
}
public GetDocumentStreamQueryHandler(ILogger <GetDocumentStreamQueryHandler> logger,
IFileClient fileClient,
ISIOProjectionDbContextFactory projectionDbContextFactory,
IContentTypeProvider contentTypeProvider)
{
if (logger is null)
{
throw new ArgumentNullException(nameof(logger));
}
if (fileClient is null)
{
throw new ArgumentNullException(nameof(fileClient));
}
if (projectionDbContextFactory is null)
{
throw new ArgumentNullException(nameof(projectionDbContextFactory));
}
if (contentTypeProvider is null)
{
throw new ArgumentNullException(nameof(contentTypeProvider));
}
_logger = logger;
_fileClient = fileClient;
_projectionDbContextFactory = projectionDbContextFactory;
_contentTypeProvider = contentTypeProvider;
}
public StaticFileContext(HttpContext context, StaticFileOptions options, PathString matchUrl, ILogger logger, IFileProvider fileProvider, IContentTypeProvider contentTypeProvider)
{
_context = context;
_options = options;
_matchUrl = matchUrl;
_request = context.Request;
_response = context.Response;
_logger = logger;
_requestHeaders = _request.GetTypedHeaders();
_responseHeaders = _response.GetTypedHeaders();
_fileProvider = fileProvider;
_contentTypeProvider = contentTypeProvider;
_method = null;
_isGet = false;
_isHead = false;
_subPath = PathString.Empty;
_contentType = null;
_fileInfo = null;
_length = 0;
_lastModified = new DateTimeOffset();
_etag = null;
_ifMatchState = PreconditionState.Unspecified;
_ifNoneMatchState = PreconditionState.Unspecified;
_ifModifiedSinceState = PreconditionState.Unspecified;
_ifUnmodifiedSinceState = PreconditionState.Unspecified;
_range = null;
_isRangeRequest = false;
}
public ContentUpdater(IDocumentUpdater documentUpdater, IContentTypeProvider contentTypeRepository, ISaveListenerProvider saveListenerProvider, IContentSerializer contentSerializer)
{
DocumentUpdater = documentUpdater;
ContentTypeRepository = contentTypeRepository;
SaveListenerProvider = saveListenerProvider;
ContentSerializer = contentSerializer;
}
protected StaticResourceMapperBase(IDiskProvider diskProvider, Logger logger)
{
_diskProvider = diskProvider;
_logger = logger;
_mimeTypeProvider = new FileExtensionContentTypeProvider();
_caseSensitive = RuntimeInfo.IsProduction ? DiskProviderBase.PathStringComparison : StringComparison.OrdinalIgnoreCase;
}
public AttachmentStreamNormaliser(IContentTypeProvider contentTypeProvider,
IGZipDecompressor gZipDecompressor, IZipDecompressor zipDecompressor, ILogger log)
{
_contentTypeProvider = contentTypeProvider;
_gZipDecompressor = gZipDecompressor;
_zipDecompressor = zipDecompressor;
_log = log;
}
public SmtpEmailSender(IContentTypeProvider ctp, string Server, int Port, string SenderName, string SenderEmail, string UserName, string Password, bool SSL = false)
{
server = Server;
port = Port;
my_name = SenderName;
my_email = SenderEmail;
pwd = Password;
ssl = SSL;
username = UserName;
mime = ctp;
}
public Client(
IEndpointProvider endpointProvider,
ISoapDecoder soapDecoder,
IWebRequestFactory webRequestFactory,
ISecurityHeaderFactory securityHeaderFactory,
ILogger logger,
IContentTypeProvider contentTypeProvider)
{
this.endpointProvider = endpointProvider;
this.soapDecoder = soapDecoder;
this.webRequestFactory = webRequestFactory;
this.securityHeaderFactory = securityHeaderFactory;
this.logger = logger;
this.contentTypeProvider = contentTypeProvider;
}
public ThumbnailController(IThumbnailCacheService thumbnailCacheService,
IContentTypeProvider contentTypeProvider)
{
_thumbnailCacheService = thumbnailCacheService;
_contentTypeProvider = contentTypeProvider;
}
public ContentControllerResolver(IContentTypeProvider contentTypeProvider)
{
_contentTypeProvider = contentTypeProvider;
_controllers = new Lazy<List<Type>>(() => new ReflectionUtility().GetTypesImplementing(typeof(IController)));
}
