public string runUpload(string uploadFile, string uploadMappingFile)
{
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
var result = "";
var baseURI = $"{Configuration["DvelopInfos:BaseURL"]}";
var apiKey = $"{Configuration["DvelopInfos:API_Key"]}";
var repoId = $"{Configuration["DvelopInfos:repoId"]}";
var sessionId = new DvelopAccessHandler().Authenticate(baseURI, apiKey);
if (null != sessionId)
{
try
{
var documentLink = new FileHandlers(Configuration).UploadFile(baseURI, sessionId, repoId, uploadFile, uploadMappingFile).Result;
result = documentLink;
}
catch (Exception ex)
{
result = "Couldn't upload the file to D3";
Console.WriteLine(ex);
}
}
else
{
result = "D3 sessionId error";
}
return(result);
}
public Task <string> GetFileNameFromUserForOpen()
{
var fileSpecifications = FileHandlers.Where(fr => fr.Metadata.CanRead).Select(fr => new FileSpecification(fr.Metadata.DisplayName, fr.Metadata.FileExtensions));
var filter = string.Join("|",
from r in fileSpecifications.OrderBy(f => f.DisplayName)
let exts = string.Join(";", r.FileExtensions.Select(x => "*" + x))
select string.Format("{0}|{1}", r.DisplayName, exts));
var all = string.Format("{0}|{1}",
"All supported types",
string.Join(";", fileSpecifications.SelectMany(f => f.FileExtensions).Select(x => "*" + x).OrderBy(x => x)));
filter = string.Join("|", all, filter);
var dialog = new OpenFileDialog();
dialog.DefaultExt = fileSpecifications.First().FileExtensions.First();
dialog.Filter = filter;
var result = dialog.ShowDialog();
if (result != true)
{
return(Task.FromResult <string>(null));
}
return(Task.FromResult(dialog.FileName));
}
/// <summary>
/// Create a sample stream from an MP3, MP2, MP1, OGG, WAV, AIFF or plug-in supported file via user callback functions.
/// </summary>
/// <param name="handlers">The user defined file functions. </param>
/// <param name="configs">Configure of <see cref="AudioFileStream" />.</param>
/// <param name="systemType">File system to use.</param>
/// <param name="user">User instance data to pass to the callback functions. </param>
public AudioFileStream(FileHandlers handlers, StreamCreateFileUserConfig configs,
StreamFileSystemType systemType, IntPtr user)
{
Handle =
AudioStreamModule.StreamCreateFileUserFunction.CheckResult(
AudioStreamModule.StreamCreateFileUserFunction.Delegate(systemType, configs,
ref handlers, user));
}
/// <summary>
/// Create a sample stream from a WMA file via user callback functions.
/// </summary>
/// <param name="handlers">The user defined file functions. </param>
/// <param name="configs">Configure of <see cref="WmaStream" />.</param>
/// <param name="systemType">File system to use.</param>
/// <param name="user">User instance data to pass to the callback functions. </param>
public WmaStream(FileHandlers handlers, WmaStreamCreateConfig configs,
StreamFileSystemType systemType, IntPtr user)
{
Handle =
WmaModule.WmaStreamCreateFileUserFunction.CheckResult(
WmaModule.WmaStreamCreateFileUserFunction.Delegate(systemType, configs,
ref handlers, user));
}
private IFileHandler ReaderFromExtension(string extension)
{
var reader = FileHandlers.FirstOrDefault(r => r.Metadata.FileExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase) && r.Metadata.CanRead);
if (reader == null)
{
return(null);
}
return(reader.Value);
}
private ImportStats DoImport(Profile profile)
{
var stats = new ImportStats();
AddProtocol($"profile {profile.Name}");
foreach (var file in Files)
{
try
{
if (Importer.CancellationPending)
{
return(stats);
}
if (checkBoxOnlyAfterLastImport.Checked && file.LastWriteTime < OnlyAfter)
{
stats.Skipped++;
}
else if (FileHandlers[file.Extension](file))
{
stats.Copied++;
}
else
{
stats.Skipped++;
}
}
catch (Exception exception)
{
AddProtocol($"failed - {file.FullName}");
AddProtocol($" {exception.Message}");
stats.Failed++;
}
Invoke((MethodInvoker) delegate
{
progressBar.Value++;
});
}
return(stats);
}
/// <summary>
/// Release all resource.
/// </summary>
public void Dispose()
{
_fileCloseHandle.Free();
_fileLengthHandle.Free();
_fileReadHandle.Free();
_fileSeekHandle.Free();
_fileCloseHandler = null;
_fileLengthHandler = null;
_fileReadHandler = null;
_fileSeekHandler = null;
StreamHandlers = new FileHandlers();
}
private async Task OpenInnerAsync(string fileName, Func <TDocument> ifNotExists = null)
{
string ext = Path.GetExtension(fileName);
string openFile = fileName;
if (FileHandlers.ContainsKey(ext))
{
openFile = FileHandlers[ext].Invoke(fileName);
}
Document = await JsonFile.LoadAsync(openFile, ifNotExists);
Filename = openFile;
FileOpened?.Invoke(this, new EventArgs());
}
/// <summary>
/// Create a <see cref="BassStream"/> form a <see cref="Stream"/>.
/// </summary>
/// <param name="stream">Stream to wrap.</param>
public BassStream(Stream stream)
{
_stream = stream;
_streamPosition = _stream.Position;
_fileCloseHandler = OnFileClose;
_fileLengthHandler = OnFileLength;
_fileReadHandler = OnFileRead;
_fileSeekHandler = OnFileSeek;
_fileCloseHandle = GCHandle.Alloc(_fileCloseHandler);
_fileLengthHandle = GCHandle.Alloc(_fileLengthHandler);
_fileReadHandle = GCHandle.Alloc(_fileReadHandler);
_fileSeekHandle = GCHandle.Alloc(_fileSeekHandler);
StreamHandlers = new FileHandlers
{
CloseHandler = _fileCloseHandler,
LengthHandler = _fileLengthHandler,
ReadHandler = _fileReadHandler,
SeekHandler = _fileSeekHandler
};
}
private List <FileInfo> DoScan(DirectoryInfo directory)
{
if (directory == null)
{
return(null);
}
var files = new List <FileInfo>();
foreach (var file in directory.EnumerateFiles("*.*", SearchOption.AllDirectories))
{
if (Scanner.CancellationPending)
{
return(null);
}
if (FileHandlers.ContainsKey(file.Extension))
{
files.Add(file);
}
}
return(files);
}
public Task <string> GetFileNameFromUserForSave()
{
var x = FileHandlers.Where(fw => fw.Metadata.CanWrite).Select(fw => new FileSpecification(fw.Metadata.DisplayName, fw.Metadata.FileExtensions));
return(GetFileNameFromUserForWrite(x));
}
