private void ConfigureScopedServices(IServiceCollection services)
{
// Register service to seed test data
services.TryAddScoped <DataSeedHelper>();
// Register core scoped services
services.TryAddScoped <IUserService, UserService>();
services.TryAddScoped <IGraphQlService, GraphQlService>();
services.TryAddScoped <ICrudService, CrudService>();
services.TryAddScoped <ISecurityService, SecurityService>();
services.TryAddScoped <IIdentityService, IdentityService>();
services.TryAddScoped <IEmailService, EmailService>();
services.TryAddScoped <IAuditService, AuditService>();
services.TryAddScoped <IXsrfService, XsrfService>();
// Register context filters
services.TryAddScoped <AntiforgeryFilter>();
services.TryAddScoped <XsrfActionFilter>();
// Configure the file system provider to use
var storageOptions = new StorageProviderConfiguration();
Configuration.GetSection("StorageProvider").Bind(storageOptions);
switch (storageOptions.Provider)
{
case StorageProviders.S3:
services.TryAddScoped <IUploadStorageProvider, S3StorageProvider>();
break;
case StorageProviders.FILE_SYSTEM:
default:
services.TryAddScoped <IUploadStorageProvider, FileSystemStorageProvider>();
break;
}
}
public IFilePartyConfiguration AddModule <TModule>(StorageProviderConfiguration <TModule> defaultStorageProviderConfiguration)
where TModule : class, IFilePartyModule, new()
{
// register module config with core
var fpServiceCollection = GetServiceCollection();
var moduleConfig = new FilePartyModuleConfiguration <TModule>(defaultStorageProviderConfiguration);
fpServiceCollection.AddSingleton <IFilePartyModuleConfiguration>(moduleConfig);
fpServiceCollection.AddSingleton(x => moduleConfig);
// register module with module config
var module = new TModule();
moduleConfig.AttachModule(module);
// get module service collection and register dependencies
var dependencies = FileParty.GetModuleDependencies <TModule>();
var moduleServiceCollection = moduleConfig.GetServiceCollection();
foreach (var d in dependencies)
{
moduleServiceCollection.Add(d);
}
return(this);
}
public static void Main(string[] args)
{
IConfiguration conf = new ConfigurationBuilder()
.AddJsonFile($"appsettings.json")
.AddJsonFile($"appsettings.local.json", optional: true)
.Build();
StorageProviderConfiguration.Init(conf);
var _server = new FtpServer(new AzureFileSystemFactory(conf), conf);
_server.NewConnection += nId =>
Console.WriteLine("Connection: {0} accepted", nId);
// This is a sample worker implementation. Replace with your logic.
Console.WriteLine("Information: FTPRole entry point called");
while (true)
{
if (_server.Started)
{
Thread.Sleep(10000);
Console.WriteLine("Information: Server is alive");
}
else
{
_server.Start();
Console.WriteLine("Control: Server starting");
}
}
}
public AzureBlobStorageProvider(StorageProviderConfiguration <AzureModule> configuration)
{
if (configuration is AzureBlobBaseConfiguration config)
{
_connectionString = config.ConnectionString;
_containerName = config.ContainerName;
_allowModifications = config.AllowModificationsDuringRead;
}
DirectorySeparatorCharacter = configuration.DirectorySeparationCharacter;
}
public async Task <IAsyncStorageProvider> GetAsyncStorageProvider <TModule>(StorageProviderConfiguration <TModule> configuration) where TModule : class, IFilePartyModule, new()
{
if (!(_moduleConfigurations.LastOrDefault(f => f is FilePartyModuleConfiguration <TModule>)
is FilePartyModuleConfiguration <TModule> modCfg))
{
throw Errors.SPNotFound;
}
var storageProvider = await modCfg.GetAsyncStorageProvider(configuration);
storageProvider.WriteProgressEvent += _relay.RelayWriteProgressEvent;
return(storageProvider);
}
internal Task <IAsyncStorageProvider> GetAsyncStorageProvider(StorageProviderConfiguration <TModule> configuration)
{
var sc = new ServiceCollection {
GetServiceCollection()
};
var config = configuration ?? _defaultConfiguration;
sc.AddSingleton <StorageProviderConfiguration <TModule> >(x => config);
sc.AddSingleton <IStorageProviderConfiguration>(x => config);
using (var sp = sc.BuildServiceProvider())
{
var service = sp.GetRequiredService <IAsyncStorageProvider>();
return(Task.FromResult(service));
}
}
public void ChangeDefaultModuleConfig <TModule>(StorageProviderConfiguration <TModule> configuration = null)
where TModule : class, IFilePartyModule, new()
{
_filePartyConfiguration.DefaultModuleType = typeof(TModule);
if (configuration == null)
{
return;
}
if (!(_moduleConfigurations
.FirstOrDefault(f =>
f is FilePartyModuleConfiguration <TModule>)
is FilePartyModuleConfiguration <TModule> moduleConfiguration))
{
throw Errors.SPNotFound;
}
moduleConfiguration.SetDefaultConfiguration(configuration);
}
public TestStorageProvider2(StorageProviderConfiguration <TestModule2> configuration) : base(configuration)
{
}
public IStorageWriter GetStorageWriter <TModule>(StorageProviderConfiguration <TModule> configuration) where TModule : class, IFilePartyModule, new()
{
return(GetStorageProvider <TModule>());
}
/// <summary>
/// Constructor for Storage Provider.
/// </summary>
/// <param name="configuration">Configuration for storage providers (writers and readers) in a module</param>
protected BaseAsyncStorageProvider(StorageProviderConfiguration <TModule> configuration)
{
Debug.WriteLine($"{GetType().Name} - {_instanceId}: Created at {DateTime.UtcNow:O}");
Configuration = configuration;
}
public FileSystemStorageProvider(StorageProviderConfiguration <FileSystemModule> config)
{
_config = config;
DirectorySeparatorCharacter = config.DirectorySeparationCharacter;
}
public FTPStorageProvider(StorageProviderConfiguration <FTPModule> config)
{
_config = config;
}
public virtual void Dispose()
{
_config = null;
}
public TestAsyncStorageProvider(StorageProviderConfiguration <TestModule> configuration) : base(configuration)
{
}
internal void SetDefaultConfiguration(StorageProviderConfiguration <TModule> defaultConfiguration)
{
_defaultConfiguration = defaultConfiguration;
}
public FilePartyModuleConfiguration(StorageProviderConfiguration <TModule> defaultConfiguration)
{
SetDefaultConfiguration(defaultConfiguration);
}
public async Task <IAsyncStorageWriter> GetAsyncStorageWriter <TModule>(StorageProviderConfiguration <TModule> configuration) where TModule : class, IFilePartyModule, new()
{
return(await GetAsyncStorageProvider(configuration));
}
IPersistenceProvider Create(StorageProviderConfiguration configuration)
{
return(null);
}
public S3StorageProvider(StorageProviderConfiguration <AWS_S3Module> awsConfiguration)
{
_config = awsConfiguration;
}
