public Job(IConfiguration configuration, IDbHelper dbHelper, IFtpService ftpService, ILogs logs)
{
_configuration = configuration;
_dbHelper = dbHelper;
_ftpService = ftpService;
_logs = logs;
}
public void Setup()
{
_firestoreService = new FirestoreService(ConfigurationService);
_ftpService = new FtpService(ConfigurationService);
_storageService = new StorageService(UnitTestLoggerFactory, ConfigurationService);
_igcReaderService = new IgcReaderService();
}
public MainWin()
{
InitializeComponent();
getSessionKeyForChatWorker.DoWork += getSessionKeyWorker_DoWork;
getSessionKeyForChatWorker.RunWorkerCompleted += getSessionKeyWorker_RunWorkerCompleted;
getSessionKeyForFtpWorker.DoWork += getSessionKeyForFtpWorker_DoWork;
ClientKdcCallBack.Instance.newConnectedUserEvnt += (sender, message_contant) =>
{
Dispatcher.Invoke(() => addUserToPartnerUsers(message_contant));
};
ClientKdcCallBack.Instance.openChatWindowEvnt += (sender, userPort) =>
{
Dispatcher.Invoke(() => openChatWindow(userPort));
};
kdcProxy = KdcProxy.Instance.GetProxy();
List <string> allUsers = kdcProxy.getAllConnectedUsers();
allUsers.Remove(ClientAllData.Instance.getMyUsername());
addUserToPartnerUsers(allUsers);
ftpProxy = FtpProxy.Instance.GetFtpProxy();
ClientFtpCallBack.Instance.finishRequstConnectionProcessEvent += (sender, finishedProcess) =>
{
Dispatcher.Invoke(() => finishRequstConnectionProcessUI(finishedProcess));
};
}
public EtlService(IAmazonService amazonService, ICsvService csvService, IFtpService ftpService, ISqlService sqlService)
{
_amazonService = amazonService;
_csvService = csvService;
_ftpService = ftpService;
_sqlService = sqlService;
}
public TestableManager(
ILogger logger,
IFtpService ftpService,
bool indicatesError = false) : base(logger, ftpService)
{
_indicatesError = indicatesError;
}
public MainWindowViewModel(IDatabaseService databaseService, IMessenger messenger, IImageService imageService,
IDataService dataService, IJsonService jsonService, IFtpService ftpService, IConfigService configService)
{
_databaseService = databaseService;
_messenger = messenger;
_imageService = imageService;
_dataService = dataService;
_jsonService = jsonService;
_ftpService = ftpService;
_configService = configService;
//register for messages
_messenger.Register <ChooseFilesConfirmMsg>(this, OnChooseFilesConfirmMsg);
_messenger.Register <ImportConfirmMsg>(this, OnImportConfirmMsg);
_messenger.Register <ExportViewClosedMsg>(this, OnExportviewClosedMsg);
_messenger.Register <ChooseFilesGoogleDriveConfirmMsg>(this, OnChooseFilesGoogleDriveConfirmMsg);
_messenger.Register <FileProcessFinishedMsg>(this, OnFileProcessFinishedMsg);
IsGoogleDriveEnabled =
Convert.ToBoolean(_configService.GetAppSettingsValue(AppSettingConstants.IsGoogleDriveEnabled));
_mobileKey = _configService.GetAppSettingsValue(AppSettingConstants.MobileKey);
if (!string.IsNullOrEmpty(_mobileKey))
{
HasMobileKey = true;
}
if (IsGoogleDriveEnabled)
{
_googleDriveService = Container.Resolve <IGoogleDriveService>();
_googleDriveService.DownloadCompleted += GoogleDriveService_DownloadCompleted;
}
}
/// <summary>
/// Executes the node.
/// </summary>
/// <param name="runtime"></param>
/// <param name="scope"></param>
/// <returns></returns>
public override bool Execute(IFlowRuntimeService runtime, DataPinScope scope)
{
if (ftpServerService == null)
{
ftpServerService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IFtpServerConfigurationService>();
}
var servername = scope.GetValue <string>(InPinServer);
var server = ftpServerService.GetByName(servername);
if (serviceCache.Keys.Contains(server.Type.ToString()))
{
ftpService = serviceCache[server.Type.ToString()];
}
else
{
ftpService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IFtpService>(server.Type.ToString());
serviceCache.Add(server.Type.ToString(), ftpService);
}
var filename = scope.GetValue <string>(InPinFileName);
var newFilename = scope.GetValue <string>(InPinNewFileName);
var path = scope.GetValue <string>(InPinPath);
ftpService.RenameFile(server, path + filename, newFilename);
runtime.EnqueueNode(OutNodeSuccess, scope);
return(true);
}
/// <summary>
/// Executes the node.
/// </summary>
/// <param name="runtime"></param>
/// <param name="scope"></param>
/// <returns></returns>
public override bool Execute(IFlowRuntimeService runtime, DataPinScope scope)
{
if (ftpServerService == null)
{
ftpServerService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IFtpServerConfigurationService>();
}
var servername = scope.GetValue <string>(InPinServer);
var server = ftpServerService.GetByName(servername);
if (serviceCache.Keys.Contains(server.Type.ToString()))
{
ftpService = serviceCache[server.Type.ToString()];
}
else
{
ftpService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IFtpService>(server.Type.ToString());
serviceCache.Add(server.Type.ToString(), ftpService);
}
var directory = scope.GetValue <string>(InPinDirectory);
var dir = ftpService.GetDirectoryContent(server, directory);
scope.SetValue(OutPinDirectory, dir);
runtime.EnqueueNode(OutNodeSuccess, scope);
return(true);
}
/// <summary>
/// Executes the node.
/// </summary>
/// <param name="runtime"></param>
/// <param name="scope"></param>
/// <returns></returns>
public override bool Execute(IFlowRuntimeService runtime, DataPinScope scope)
{
if (ftpServerService == null)
{
ftpServerService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IFtpServerConfigurationService>();
}
var servername = scope.GetValue <string>(InPinServer);
var server = ftpServerService.GetByName(servername);
if (serviceCache.Keys.Contains(server.Type.ToString()))
{
ftpService = serviceCache[server.Type.ToString()];
}
else
{
ftpService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IFtpService>(server.Type.ToString());
serviceCache.Add(server.Type.ToString(), ftpService);
}
var file = scope.GetValue <byte[]>(InPinFile);
var path = scope.GetValue <string>(InPinPath);
var fileName = scope.GetValue <string>(InPinFileName);
try
{
ftpService.UploadFile(server, file, path, fileName);
runtime.EnqueueNode(OutNodeSuccess, scope);
}
catch (Exception ex)
{
runtime.EnqueueNode(OutNodeFaield, scope);
Console.WriteLine(ex);
}
return(true);
}
public FtpDeployRunner(IFileSystem fileSystem, ICakeEnvironment environment, IProcessRunner processRunner, IToolLocator tools, IFtpService ftpService) : base(fileSystem, environment, processRunner, tools)
{
_fileSystem = fileSystem;
_environment = environment;
_processRunner = processRunner;
_tools = tools;
_ftpService = ftpService;
}
public Program()
{
System.Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", "D:\\llauner\\GoogleCloud_Credentials\\Service_Account_Key-igcheatmap-f012be117f9c.json");
_firestoreService = new FirestoreService(ConfigurationService);
_ftpService = new FtpService(ConfigurationService);
_storageService = new StorageService(ConfigurationService);
_igcReaderService = new IgcReaderService();
}
public SslCommunicationInfo(
[NotNull] IFtpService transmitterService,
[NotNull] IPausableFtpService receiverService,
[NotNull] Stream sslStream)
{
TransmitterService = transmitterService;
ReceiverService = receiverService;
SslStream = sslStream;
}
public PopupService(VmmDbContext dbContext,
IFtpService ftpService,
IFileCacheService fileCacheService,
IConfigurationProvider configurationProvider)
{
this.dbContext = dbContext;
this.ftpService = ftpService;
this.fileCacheService = fileCacheService;
this.configurationProvider = configurationProvider;
}
public ExportWorker(IFtpService ftpService,
IExportService exportService,
IServiceProvider serviceProvider,
ILogger <ExportWorker> logger)
{
_ftpService = ftpService;
_exportService = exportService;
_serviceProvider = serviceProvider;
_logger = logger;
}
public NeoLoader(IFtpService ftpService = null)
{
if (ftpService == null)
{
_ftpService = new FtpService();
}
else
{
_ftpService = ftpService;
}
}
public NetworkStreamFeature(
[NotNull] IFtpSecureConnectionAdapter secureConnectionAdapter,
[NotNull] IFtpService streamReaderService,
[NotNull] IFtpService streamWriterService,
[NotNull] PipeWriter output)
{
StreamReaderService = streamReaderService;
StreamWriterService = streamWriterService;
Output = output;
SecureConnectionAdapter = secureConnectionAdapter;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="fileSystem">The filesystem.</param>
/// <param name="environment">The cake environment.</param>
/// <param name="ftpService">The FTP Service.</param>
public FtpClient(IFileSystem fileSystem, ICakeEnvironment environment, IFtpService ftpService)
{
fileSystem.NotNull(nameof(fileSystem));
environment.NotNull(nameof(environment));
ftpService.NotNull(nameof(ftpService));
_fileSystem = fileSystem;
_environment = environment;
_ftpService = ftpService;
_comparison = environment.Platform.IsUnix() ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
}
public DocumentService(VmmDbContext dbContext,
IDocumentTypeService documentTypeService,
IFtpService ftpService,
IFileCacheService fileCacheService,
IConfigurationProvider configurationProvider)
{
this.dbContext = dbContext;
this.documentTypeService = documentTypeService;
this.configurationProvider = configurationProvider;
this.ftpService = ftpService;
this.fileCacheService = fileCacheService;
}
public Application(
IConfigService configService,
IFtpService ftpService,
ILogger logger,
IWildCardService wildCardService,
AppConfig appConfig)
{
this.configService = configService;
this.ftpService = ftpService;
this.logger = logger;
this.wildCardService = wildCardService;
this.appConfig = appConfig;
}
public PhotoService(IFtpService ftpService,
IUnitOfWork unitOfWork,
IAlbumService albumService,
IClock clock,
IGuid guid,
IPermissionsService permissionsService)
{
_ftpService = ftpService;
_unitOfWork = unitOfWork;
_albumService = albumService;
_clock = clock;
_guid = guid;
_permissionsService = permissionsService;
}
public FtpController(
IExcelManager excelManager,
ICacheManager cacheManager,
IWorkContext workContext,
IWebEventService webLogger,
IFsuService fsuService,
IFtpService ftpService)
{
this._excelManager = excelManager;
this._cacheManager = cacheManager;
this._workContext = workContext;
this._webLogger = webLogger;
this._fsuService = fsuService;
this._ftpService = ftpService;
}
public AggregatorService(ILoggerFactory loggerFactory,
IConfigurationService configuration,
IFtpService ftpService,
IFirestoreService fireStoreService,
IStorageService storageService,
IIgcReaderService igcReaderService,
INetcoupeService netcoupeService)
{
_logger = loggerFactory.CreateLogger <AggregatorService>();
_configuration = configuration;
_ftpService = ftpService;
_firestoreService = fireStoreService;
_storageService = storageService;
_igcReaderService = igcReaderService;
_netcoupeService = netcoupeService;
}
/// <summary>
/// Initializes a new instance of the <see cref="PassThroughConnectionAdapter"/> class.
/// </summary>
/// <param name="socketPipe">The pipe for the socket.</param>
/// <param name="connectionPipe">The pipe for the <see cref="IFtpConnection"/>.</param>
/// <param name="connectionClosed">A cancellation token for a closed connection.</param>
/// <param name="loggerFactory">The logger factory.</param>
public PassThroughConnectionAdapter(
[NotNull] IDuplexPipe socketPipe,
[NotNull] IDuplexPipe connectionPipe,
CancellationToken connectionClosed,
[CanBeNull] ILoggerFactory loggerFactory = null)
{
_receiverService = new NonClosingNetworkPassThrough(
socketPipe.Input,
connectionPipe.Output,
connectionClosed,
loggerFactory?.CreateLogger(typeof(PassThroughConnectionAdapter).FullName + ":Receiver"));
_transmitService = new NonClosingNetworkPassThrough(
connectionPipe.Input,
socketPipe.Output,
connectionClosed,
loggerFactory?.CreateLogger(typeof(PassThroughConnectionAdapter).FullName + ":Transmitter"));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="fileSystem">The filesystem.</param>
/// <param name="environment">The cake environment.</param>
/// <param name="ftpService">The FTP Service.</param>
public FtpClient(IFileSystem fileSystem, ICakeEnvironment environment, IFtpService ftpService)
{
if (fileSystem == null)
{
throw new ArgumentNullException(nameof(fileSystem));
}
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
if (ftpService == null)
{
throw new ArgumentNullException(nameof(ftpService));
}
_fileSystem = fileSystem;
_environment = environment;
_ftpService = ftpService;
_comparison = environment.Platform.IsUnix() ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
}
public FtpHelperTest()
{
_ftp = new FtpService(new MyFtpService1(), new MyConfiguration1());
}
private FtpProxy()
{
// creat a channel to comunicate with the game server
channel = new DuplexChannelFactory <IFtpService>(ClientFtpCallBack.Instance, "FtpServiceEndpoint");
proxy = channel.CreateChannel();
}
internal Manager(ILogger logger, IFtpService ftpService)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_ftpService = ftpService ?? throw new ArgumentNullException(nameof(ftpService));
}
public InventoryService(IFtpService ftpService, string localPath)
{
FtpService = ftpService;
LocalPath = localPath;
}
public PhotoServiceBuilder WithFtpService(IFtpService ftpService)
{
_ftpService = ftpService;
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="FtpConnection"/> class.
/// </summary>
/// <param name="socketAccessor">The accessor to get the socket used to communicate with the client.</param>
/// <param name="options">The options for the FTP connection.</param>
/// <param name="portOptions">The <c>PORT</c> command options.</param>
/// <param name="connectionAccessor">The accessor to get the connection that is active during the <see cref="FtpCommandHandler.Process"/> method execution.</param>
/// <param name="catalogLoader">The catalog loader for the FTP server.</param>
/// <param name="serverCommandExecutor">The executor for server commands.</param>
/// <param name="serviceProvider">The service provider for the connection.</param>
/// <param name="secureDataConnectionWrapper">Wraps a data connection into an SSL stream.</param>
/// <param name="sslStreamWrapperFactory">The SSL stream wrapper factory.</param>
/// <param name="logger">The logger for the FTP connection.</param>
public FtpConnection(
TcpSocketClientAccessor socketAccessor,
IOptions <FtpConnectionOptions> options,
IOptions <PortCommandOptions> portOptions,
IFtpConnectionAccessor connectionAccessor,
IFtpCatalogLoader catalogLoader,
IServerCommandExecutor serverCommandExecutor,
IServiceProvider serviceProvider,
SecureDataConnectionWrapper secureDataConnectionWrapper,
ISslStreamWrapperFactory sslStreamWrapperFactory,
ILogger <FtpConnection>?logger = null)
{
var socket = socketAccessor.TcpSocketClient ?? throw new InvalidOperationException("The socket to communicate with the client was not set");
ConnectionServices = serviceProvider;
ConnectionId = "FTP-" + Guid.NewGuid().ToString("N");
_dataPort = portOptions.Value.DataPort;
var remoteEndPoint = _remoteEndPoint = (IPEndPoint)socket.Client.RemoteEndPoint;
#pragma warning disable 618
RemoteAddress = new Address(remoteEndPoint.Address.ToString(), remoteEndPoint.Port);
#pragma warning restore 618
var properties = new Dictionary <string, object?>
{
["RemoteAddress"] = remoteEndPoint.ToString(),
["RemoteIp"] = remoteEndPoint.Address.ToString(),
["RemotePort"] = remoteEndPoint.Port,
["ConnectionId"] = ConnectionId,
};
_loggerScope = logger?.BeginScope(properties);
_socket = socket;
_connectionAccessor = connectionAccessor;
_serverCommandExecutor = serverCommandExecutor;
_secureDataConnectionWrapper = secureDataConnectionWrapper;
_serverCommandChannel = Channel.CreateBounded <IServerCommand>(new BoundedChannelOptions(3));
_logger = logger;
var parentFeatures = new FeatureCollection();
var connectionFeature = new ConnectionFeature(
(IPEndPoint)socket.Client.LocalEndPoint,
remoteEndPoint);
var secureConnectionFeature = new SecureConnectionFeature();
var applicationInputPipe = new Pipe();
var applicationOutputPipe = new Pipe();
var socketPipe = new DuplexPipe(_socketCommandPipe.Reader, _socketResponsePipe.Writer);
var connectionPipe = new DuplexPipe(applicationOutputPipe.Reader, applicationInputPipe.Writer);
var originalStream = socketAccessor.TcpSocketStream ?? socket.GetStream();
_streamReaderService = new ConnectionClosingNetworkStreamReader(
originalStream,
_socketCommandPipe.Writer,
_cancellationTokenSource);
_streamWriterService = new StreamPipeWriterService(
originalStream,
_socketResponsePipe.Reader,
_cancellationTokenSource.Token);
_networkStreamFeature = new NetworkStreamFeature(
new SecureConnectionAdapter(
socketPipe,
connectionPipe,
sslStreamWrapperFactory,
_cancellationTokenSource.Token),
applicationOutputPipe.Writer);
parentFeatures.Set <IConnectionFeature>(connectionFeature);
parentFeatures.Set <ISecureConnectionFeature>(secureConnectionFeature);
parentFeatures.Set <IServerCommandFeature>(new ServerCommandFeature(_serverCommandChannel));
parentFeatures.Set <INetworkStreamFeature>(_networkStreamFeature);
var features = new FeatureCollection(parentFeatures);
#pragma warning disable 618
Data = new FtpConnectionData(
options.Value.DefaultEncoding ?? Encoding.ASCII,
features,
catalogLoader);
#pragma warning restore 618
Features = features;
_commandReader = ReadCommandsFromPipeline(
applicationInputPipe.Reader,
_ftpCommandChannel.Writer,
_cancellationTokenSource.Token);
}