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))); }