/// <summary>
/// Initializes a new instance of the CompareFileData class and sets properties based on the FileData provided
/// </summary>
/// <param name="leftFile">First set of FileData to use in comparison</param>
/// <param name="rightFile">Second set of FileData to use in comparison</param>
public CompareFileData(FileData leftFile, FileData rightFile)
{
if (leftFile == null)
{
throw new ArgumentNullException("leftFile");
}
if (rightFile == null)
{
throw new ArgumentNullException("rightFile");
}
this.LeftFileData = leftFile;
this.RightFileData = rightFile;
this.FileCompareText = string.Format(Strings.CompareFilesHeader, Path.GetFileName(leftFile.FileName), Path.GetFileName(rightFile.FileName));
bool samePublicMetadata = true;
bool samePersonalMetadata = true;
this.PublicMetadata = CompareFileData.CompareMetadata(leftFile.PublicMetadata, rightFile.PublicMetadata, out samePublicMetadata);
this.PersonalMetadata = CompareFileData.CompareMetadata(leftFile.PersonalMetadata, rightFile.PersonalMetadata, out samePersonalMetadata);
this.Streams = CompareFileData.CompareStreams(leftFile.Streams, rightFile.Streams);
if (leftFile.PublicMetadata.Count == 0 && rightFile.PublicMetadata.Count == 0)
{
this.PublicMetadataCompareText = string.Format(Strings.PublicMetadataHeader, Strings.None);
}
else
{
this.PublicMetadataCompareText = string.Format(Strings.PublicMetadataHeader, samePublicMetadata ? Strings.Same : Strings.Different);
}
if (leftFile.PersonalMetadata.Count == 0 && rightFile.PersonalMetadata.Count == 0)
{
this.PersonalMetadataCompareText = string.Format(Strings.PersonalMetadataHeader, Strings.None);
}
else
{
this.PersonalMetadataCompareText = string.Format(Strings.PersonalMetadataHeader, samePersonalMetadata ? Strings.Same : Strings.Different);
}
if (leftFile.Streams.Count == 0 && rightFile.Streams.Count == 0)
{
this.StreamsCompareText = string.Format(Strings.StreamsHeader, Strings.None);
}
else
{
bool sameStreamData = this.Streams.All(data => data.Same);
this.StreamsCompareText = string.Format(Strings.StreamsHeader, sameStreamData ? Strings.Same : Strings.Different);
}
}
/// <summary>
/// Handles the click event for the 'Compare Files' button
/// </summary>
/// <param name="sender">sender object</param>
/// <param name="e">routed event args</param>
private void CompareFiles_Click(object sender, RoutedEventArgs e)
{
State previous = this.currentState;
this.WaitMessageText = Strings.WaitForCompareFiles;
this.CurrentState = State.Wait;
string file1 = string.Empty;
string file2 = string.Empty;
KStudioEventFile eventFile2 = null;
try
{
// open the first file, if not already opened for View
if (this.fileData == null)
{
// open a new file
file1 = this.OpenFileForInspection();
// if user cancels from OpenFileDialog, return to previous state
if (string.IsNullOrEmpty(file1))
{
this.CurrentState = previous;
return;
}
}
// open a second file to compare with the first
file2 = this.OpenFileForInspection();
// if the user cancels from OpenFileDialog, return to the previous state
if (string.IsNullOrEmpty(file2))
{
this.CurrentState = previous;
return;
}
// create a FileData object for the first file, unless one already exists
if (this.fileData == null)
{
this.eventFile = this.client.OpenEventFile(file1);
this.fileData = new FileData(this.eventFile);
}
// create a second FileData object for comparison
eventFile2 = this.client.OpenEventFile(file2);
FileData fileData2 = new FileData(eventFile2);
// compare data between files
CompareFileData compareData = new CompareFileData(this.fileData, fileData2);
this.ViewCompareFileDataGrid.DataContext = compareData;
// show comparison data
this.CurrentState = State.Compare;
}
catch (Exception ex)
{
this.ErrorMessageText = string.Format(Strings.ErrorCompareFilesFailed, ex.Message);
this.CurrentState = State.Error;
}
finally
{
if (eventFile2 != null)
{
eventFile2.Dispose();
eventFile2 = null;
}
}
}
/// <summary>
/// Handles the click event for the 'Compare Files' button
/// </summary>
/// <param name="sender">sender object</param>
/// <param name="e">routed event args</param>
private void CompareFiles_Click(object sender, RoutedEventArgs e)
{
State previous = this.currentState;
this.WaitMessageText = Strings.WaitForCompareFiles;
this.CurrentState = State.Wait;
string file1 = string.Empty;
string file2 = string.Empty;
KStudioEventFile eventFile2 = null;
try
{
// open the first file, if not already opened for View
if (this.fileData == null)
{
// open a new file
file1 = this.OpenFileForInspection();
// if user cancels from OpenFileDialog, return to previous state
if (string.IsNullOrEmpty(file1))
{
this.CurrentState = previous;
return;
}
}
// open a second file to compare with the first
file2 = this.OpenFileForInspection();
// if the user cancels from OpenFileDialog, return to the previous state
if (string.IsNullOrEmpty(file2))
{
this.CurrentState = previous;
return;
}
// create a FileData object for the first file, unless one already exists
if (this.fileData == null)
{
this.eventFile = this.client.OpenEventFile(file1);
this.fileData = new FileData(this.eventFile);
}
// create a second FileData object for comparison
eventFile2 = this.client.OpenEventFile(file2);
FileData fileData2 = new FileData(eventFile2);
// compare data between files
CompareFileData compareData = new CompareFileData(this.fileData, fileData2);
this.ViewCompareFileDataGrid.DataContext = compareData;
// show comparison data
this.CurrentState = State.Compare;
}
catch (Exception ex)
{
this.ErrorMessageText = string.Format(Strings.ErrorCompareFilesFailed, ex.Message);
this.CurrentState = State.Error;
}
finally
{
if (eventFile2 != null)
{
eventFile2.Dispose();
eventFile2 = null;
}
}
}
/// <summary>
/// Initializes a new instance of the CompareStreamData class and sets all properties based on the StreamData provided
/// </summary>
/// <param name="leftStream">First StreamData object to use for comparison</param>
/// <param name="rightStream">Second StreamData object to use for comparison</param>
public CompareStreamData(StreamData leftStream, StreamData rightStream)
{
if (leftStream == null && rightStream == null)
{
throw new InvalidOperationException(Strings.ErrorNoStreams);
}
this.StreamName = Strings.Unknown;
this.LeftPublicMetadataCount = 0;
this.RightPublicMetadataCount = 0;
this.LeftPersonalMetadataCount = 0;
this.RightPersonalMetadataCount = 0;
string dataTypeIdKey = Strings.DataTypeIdHeader;
string semanticIdKey = Strings.SemanticIdHeader;
string eventCountKey = Strings.EventCountHeader;
string startTimeKey = Strings.StreamStartTimeHeader;
string endTimeKey = Strings.StreamEndTimeHeader;
string leftSemanticId = string.Empty;
string rightSemanticId = string.Empty;
string leftEventCount = string.Empty;
string rightEventCount = string.Empty;
string leftStartTime = string.Empty;
string rightStartTime = string.Empty;
string leftEndTime = string.Empty;
string rightEndTime = string.Empty;
string leftDataTypeId = string.Empty;
string rightDataTypeId = string.Empty;
KStudioMetadata leftPublicMetadata = null;
KStudioMetadata rightPublicMetadata = null;
KStudioMetadata leftPersonalMetadata = null;
KStudioMetadata rightPersonalMetadata = null;
if (leftStream != null)
{
this.StreamName = leftStream.EventStream.DataTypeName;
leftSemanticId = leftStream.EventStream.SemanticId.ToString();
leftEventCount = leftStream.EventHeaders.Count.ToString();
leftStartTime = leftStream.StartTime.ToString();
leftEndTime = leftStream.EndTime.ToString();
leftDataTypeId = leftStream.EventStream.DataTypeId.ToString();
leftPublicMetadata = leftStream.PublicMetadata;
leftPersonalMetadata = leftStream.PersonalMetadata;
this.LeftPublicMetadataCount = leftStream.PublicMetadata.Count;
this.LeftPersonalMetadataCount = leftStream.PersonalMetadata.Count;
}
if (rightStream != null)
{
if (leftStream == null)
{
this.StreamName = rightStream.EventStream.DataTypeName;
}
rightSemanticId = rightStream.EventStream.SemanticId.ToString();
rightEventCount = rightStream.EventHeaders.Count.ToString();
rightStartTime = rightStream.StartTime.ToString();
rightEndTime = rightStream.EndTime.ToString();
rightDataTypeId = rightStream.EventStream.DataTypeId.ToString();
rightPublicMetadata = rightStream.PublicMetadata;
rightPersonalMetadata = rightStream.PersonalMetadata;
this.RightPublicMetadataCount = rightStream.PublicMetadata.Count;
this.RightPersonalMetadataCount = rightStream.PersonalMetadata.Count;
}
// compare stream metadata
bool samePublicMetadata = true;
bool samePersonalMetadata = true;
this.PublicMetadata = CompareFileData.CompareMetadata(leftPublicMetadata, rightPublicMetadata, out samePublicMetadata);
this.PersonalMetadata = CompareFileData.CompareMetadata(leftPersonalMetadata, rightPersonalMetadata, out samePersonalMetadata);
if (this.LeftPublicMetadataCount == 0 && this.RightPublicMetadataCount == 0)
{
this.StreamPublicMetadataCompareText = string.Format(Strings.PublicMetadataHeader, Strings.None);
}
else
{
this.StreamPublicMetadataCompareText = string.Format(Strings.PublicMetadataHeader, samePublicMetadata ? Strings.Same : Strings.Different);
}
if (this.LeftPersonalMetadataCount == 0 && this.RightPersonalMetadataCount == 0)
{
this.StreamPersonalMetadataCompareText = string.Format(Strings.PersonalMetadataHeader, Strings.None);
}
else
{
this.StreamPersonalMetadataCompareText = string.Format(Strings.PersonalMetadataHeader, samePersonalMetadata ? Strings.Same : Strings.Different);
}
// compare stream details
this.StreamDetails = new ObservableCollection <CompareData>();
this.StreamDetails.Add(new CompareData(dataTypeIdKey, leftDataTypeId, rightDataTypeId));
this.StreamDetails.Add(new CompareData(semanticIdKey, leftSemanticId, rightSemanticId));
this.StreamDetails.Add(new CompareData(eventCountKey, leftEventCount, rightEventCount));
this.StreamDetails.Add(new CompareData(startTimeKey, leftStartTime, rightStartTime));
this.StreamDetails.Add(new CompareData(endTimeKey, leftEndTime, rightEndTime));
bool sameDetails = this.StreamDetails.All(data => data.Same);
this.StreamDetailsCompareText = string.Format(Strings.StreamDetailsHeader, sameDetails ? Strings.Same : Strings.Different);
this.Same = (samePublicMetadata && samePersonalMetadata && sameDetails) ? true : false;
}
/// <summary>
/// Handles all command-line arguments
/// </summary>
/// <param name="args">Arguments array</param>
/// <returns>CommandLineResult to indicate if the operation was successful or not</returns>
private CommandLineResult ProcessCommandLine(string[] args)
{
string logFile = string.Empty;
List <string> streamList = new List <string>();
bool updatePersonalMetadata = false;
uint loopCount = 0;
Dictionary <string, List <string> > commands = new Dictionary <string, List <string> >();
try
{
if (args == null)
{
return(CommandLineResult.Succeeded);
}
if (args.Length == 0)
{
return(CommandLineResult.Succeeded);
}
// gather commands and support parameters
for (int i = 0; i < args.Length; i++)
{
string arg = args[i];
if (this.IsArgument(arg))
{
string key = arg.Substring(1).ToUpperInvariant();
if (!commands.ContainsKey(key))
{
commands.Add(key, new List <string>());
for (int j = i + 1; j < args.Length; j++)
{
string param = args[j];
if (!this.IsArgument(param))
{
commands[key].Add(param);
}
else
{
break;
}
}
}
}
}
// process all command args
if (commands.ContainsKey("?") || commands.ContainsKey(Strings.Command_Help))
{
this.RunCommandLine();
this.ShowCommandLineHelp();
return(CommandLineResult.SucceededExit);
}
// -log <filename>
if (commands.ContainsKey(Strings.Command_Log))
{
if (commands[Strings.Command_Log].Count != 1)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Log));
return(CommandLineResult.Invalid);
}
logFile = commands[Strings.Command_Log][0];
}
// -loop <count>
if (commands.ContainsKey(Strings.Command_Loop))
{
if (commands[Strings.Command_Loop].Count != 1)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Loop));
return(CommandLineResult.Invalid);
}
if (!uint.TryParse(commands[Strings.Command_Loop][0], out loopCount))
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Loop));
return(CommandLineResult.Invalid);
}
}
// -pii
if (commands.ContainsKey(Strings.Command_PII))
{
updatePersonalMetadata = true;
}
// -stream <stream1> <stream2> <stream3> ...
if (commands.ContainsKey(Strings.Command_Stream))
{
if (commands[Strings.Command_Stream].Count == 0)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Stream));
return(CommandLineResult.Invalid);
}
streamList = commands[Strings.Command_Stream];
}
// -view <filename>
if (commands.ContainsKey(Strings.Command_View))
{
this.RunCommandLine();
if (commands[Strings.Command_View].Count != 1)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_View));
return(CommandLineResult.Invalid);
}
string fileInfo = string.Empty;
string filePath = commands[Strings.Command_View][0];
this.CheckFile(filePath);
Console.WriteLine(Strings.WaitForViewFile);
using (KStudioClient client = KStudio.CreateClient())
{
if (filePath.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant()))
{
client.ConnectToService();
}
using (KStudioEventFile eventFile = client.OpenEventFile(filePath))
{
FileData data = new FileData(eventFile);
fileInfo = data.GetFileDataAsText();
Console.WriteLine(fileInfo);
}
}
if (!string.IsNullOrEmpty(logFile))
{
Logger.Start(logFile, true);
Logger.Log(fileInfo);
Logger.Stop();
}
Console.WriteLine(Strings.Done);
return(CommandLineResult.SucceededExit);
}
// -compare <filename1> <filename2>
if (commands.ContainsKey(Strings.Command_Compare))
{
this.RunCommandLine();
if (commands[Strings.Command_Compare].Count != 2)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Compare));
return(CommandLineResult.Invalid);
}
string fileInfo = string.Empty;
string file1 = commands[Strings.Command_Compare][0];
string file2 = commands[Strings.Command_Compare][1];
this.CheckFile(file1);
this.CheckFile(file2);
Console.WriteLine(Strings.WaitForCompareFiles);
using (KStudioClient client = KStudio.CreateClient())
{
if (file1.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant()) || file2.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant()))
{
client.ConnectToService();
}
using (KStudioEventFile eventFile1 = client.OpenEventFile(file1))
using (KStudioEventFile eventFile2 = client.OpenEventFile(file2))
{
FileData fileData1 = new FileData(eventFile1);
FileData fileData2 = new FileData(eventFile2);
CompareFileData compareData = new CompareFileData(fileData1, fileData2);
fileInfo = compareData.GetCompareFileDataAsText();
Console.WriteLine(fileInfo);
}
}
if (!string.IsNullOrEmpty(logFile))
{
Logger.Start(logFile, true);
Logger.Log(fileInfo);
Logger.Stop();
}
Console.WriteLine(Strings.Done);
return(CommandLineResult.SucceededExit);
}
// -update <filename> <metadata key> <metadata value>
if (commands.ContainsKey(Strings.Command_Update))
{
this.RunCommandLine();
if (commands[Strings.Command_Update].Count != 3)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Update));
return(CommandLineResult.Invalid);
}
string filePath = commands[Strings.Command_Update][0];
string key = commands[Strings.Command_Update][1];
object value = commands[Strings.Command_Update][2];
this.CheckFile(filePath);
string metadataText = string.Empty;
if (streamList.Count > 0)
{
// update stream metadata
foreach (string streamName in streamList)
{
Console.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.UpdatingStreamMetadata, streamName));
metadataText = this.EditMetadata(filePath, key, value, streamName, updatePersonalMetadata, true);
Console.WriteLine(metadataText);
}
}
else
{
// update file metadata
Console.WriteLine(Strings.UpdatingFileMetadata);
metadataText = this.EditMetadata(filePath, key, value, string.Empty, updatePersonalMetadata, false);
Console.WriteLine(metadataText);
}
Console.WriteLine(Strings.Done);
return(CommandLineResult.SucceededExit);
}
// -remove <filename> <metadata key>
if (commands.ContainsKey(Strings.Command_Remove))
{
this.RunCommandLine();
if (commands[Strings.Command_Remove].Count != 2)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Remove));
return(CommandLineResult.Invalid);
}
string filePath = commands[Strings.Command_Remove][0];
string key = commands[Strings.Command_Remove][1];
this.CheckFile(filePath);
string metadataText = string.Empty;
if (streamList.Count > 0)
{
// update stream metadata
foreach (string streamName in streamList)
{
Console.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.UpdatingStreamMetadata, streamName));
metadataText = this.EditMetadata(filePath, key, null, streamName, updatePersonalMetadata, true);
Console.WriteLine(metadataText);
}
}
else
{
// update file metadata
Console.WriteLine(Strings.UpdatingFileMetadata);
metadataText = this.EditMetadata(filePath, key, null, string.Empty, updatePersonalMetadata, false);
Console.WriteLine(metadataText);
}
Console.WriteLine(Strings.Done);
return(CommandLineResult.SucceededExit);
}
// -play <filename>
if (commands.ContainsKey(Strings.Command_Play))
{
this.RunCommandLine();
if (commands[Strings.Command_Play].Count != 1)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Play));
return(CommandLineResult.Invalid);
}
string filePath = commands[Strings.Command_Play][0];
this.CheckFile(filePath);
using (KStudioClient client = KStudio.CreateClient())
{
Console.WriteLine(Strings.WaitToConnect);
client.ConnectToService();
Console.WriteLine(Strings.StartPlayback);
Playback.PlaybackClip(client, filePath, streamList, loopCount);
Console.WriteLine(Strings.StopPlayback);
client.DisconnectFromService();
}
Console.WriteLine(Strings.Done);
return(CommandLineResult.SucceededExit);
}
// -record <filename> <duration>
if (commands.ContainsKey(Strings.Command_Record))
{
this.RunCommandLine();
if (commands[Strings.Command_Record].Count != 2)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Record));
return(CommandLineResult.Invalid);
}
string filePath = commands[Strings.Command_Record][0];
this.CheckDirectory(filePath);
double time = 0;
if (!double.TryParse(commands[Strings.Command_Record][1], out time))
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Record));
return(CommandLineResult.Invalid);
}
TimeSpan duration = TimeSpan.FromSeconds(time);
string errorMsg = string.Empty;
string fileInfo = string.Empty;
using (KStudioClient client = KStudio.CreateClient())
{
Console.WriteLine(Strings.WaitToConnect);
client.ConnectToService();
Console.WriteLine(Strings.StartRecording);
Recording.RecordClip(client, filePath, duration, streamList);
Console.WriteLine(Strings.StopRecording);
using (KStudioEventFile eventFile = client.OpenEventFile(filePath))
{
FileData fileData = new FileData(eventFile);
fileInfo = fileData.GetFileDataAsText();
Console.WriteLine(fileInfo);
}
client.DisconnectFromService();
}
if (!string.IsNullOrEmpty(logFile))
{
Logger.Start(logFile, true);
Logger.Log(fileInfo);
Logger.Stop();
}
Console.WriteLine(Strings.Done);
return(CommandLineResult.SucceededExit);
}
}
catch (Exception ex)
{
string errorMsg = string.Format(Strings.ErrorPrepend, ex.Message);
Console.Error.WriteLine(errorMsg);
return(CommandLineResult.Failed);
}
return(CommandLineResult.Invalid);
}
/// <summary>
/// Handles all command-line arguments
/// </summary>
/// <param name="args">Arguments array</param>
/// <returns>CommandLineResult to indicate if the operation was successful or not</returns>
private CommandLineResult ProcessCommandLine(string[] args)
{
string logFile = string.Empty;
List<string> streamList = new List<string>();
bool updatePersonalMetadata = false;
uint loopCount = 0;
Dictionary<string, List<string>> commands = new Dictionary<string, List<string>>();
try
{
if (args == null)
{
return CommandLineResult.Succeeded;
}
if (args.Length == 0)
{
return CommandLineResult.Succeeded;
}
// gather commands and support parameters
for (int i = 0; i < args.Length; i++)
{
string arg = args[i];
if (this.IsArgument(arg))
{
string key = arg.Substring(1).ToUpperInvariant();
if (!commands.ContainsKey(key))
{
commands.Add(key, new List<string>());
for (int j = i + 1; j < args.Length; j++)
{
string param = args[j];
if (!this.IsArgument(param))
{
commands[key].Add(param);
}
else
{
break;
}
}
}
}
}
// process all command args
if (commands.ContainsKey("?") || commands.ContainsKey(Strings.Command_Help))
{
this.RunCommandLine();
this.ShowCommandLineHelp();
return CommandLineResult.SucceededExit;
}
// -log <filename>
if (commands.ContainsKey(Strings.Command_Log))
{
if (commands[Strings.Command_Log].Count != 1)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Log));
return CommandLineResult.Invalid;
}
logFile = commands[Strings.Command_Log][0];
}
// -loop <count>
if (commands.ContainsKey(Strings.Command_Loop))
{
if (commands[Strings.Command_Loop].Count != 1)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Loop));
return CommandLineResult.Invalid;
}
if (!uint.TryParse(commands[Strings.Command_Loop][0], out loopCount))
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Loop));
return CommandLineResult.Invalid;
}
}
// -pii
if (commands.ContainsKey(Strings.Command_PII))
{
updatePersonalMetadata = true;
}
// -stream <stream1> <stream2> <stream3> ...
if (commands.ContainsKey(Strings.Command_Stream))
{
if (commands[Strings.Command_Stream].Count == 0)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Stream));
return CommandLineResult.Invalid;
}
streamList = commands[Strings.Command_Stream];
}
// -view <filename>
if (commands.ContainsKey(Strings.Command_View))
{
this.RunCommandLine();
if (commands[Strings.Command_View].Count != 1)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_View));
return CommandLineResult.Invalid;
}
string fileInfo = string.Empty;
string filePath = commands[Strings.Command_View][0];
this.CheckFile(filePath);
Console.WriteLine(Strings.WaitForViewFile);
using (KStudioClient client = KStudio.CreateClient())
{
if (filePath.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant()))
{
client.ConnectToService();
}
using (KStudioEventFile eventFile = client.OpenEventFile(filePath))
{
FileData data = new FileData(eventFile);
fileInfo = data.GetFileDataAsText();
Console.WriteLine(fileInfo);
}
}
if (!string.IsNullOrEmpty(logFile))
{
Logger.Start(logFile, true);
Logger.Log(fileInfo);
Logger.Stop();
}
Console.WriteLine(Strings.Done);
return CommandLineResult.SucceededExit;
}
// -compare <filename1> <filename2>
if (commands.ContainsKey(Strings.Command_Compare))
{
this.RunCommandLine();
if (commands[Strings.Command_Compare].Count != 2)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Compare));
return CommandLineResult.Invalid;
}
string fileInfo = string.Empty;
string file1 = commands[Strings.Command_Compare][0];
string file2 = commands[Strings.Command_Compare][1];
this.CheckFile(file1);
this.CheckFile(file2);
Console.WriteLine(Strings.WaitForCompareFiles);
using (KStudioClient client = KStudio.CreateClient())
{
if (file1.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant()) || file2.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant()))
{
client.ConnectToService();
}
using (KStudioEventFile eventFile1 = client.OpenEventFile(file1))
using (KStudioEventFile eventFile2 = client.OpenEventFile(file2))
{
FileData fileData1 = new FileData(eventFile1);
FileData fileData2 = new FileData(eventFile2);
CompareFileData compareData = new CompareFileData(fileData1, fileData2);
fileInfo = compareData.GetCompareFileDataAsText();
Console.WriteLine(fileInfo);
}
}
if (!string.IsNullOrEmpty(logFile))
{
Logger.Start(logFile, true);
Logger.Log(fileInfo);
Logger.Stop();
}
Console.WriteLine(Strings.Done);
return CommandLineResult.SucceededExit;
}
// -update <filename> <metadata key> <metadata value>
if (commands.ContainsKey(Strings.Command_Update))
{
this.RunCommandLine();
if (commands[Strings.Command_Update].Count != 3)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Update));
return CommandLineResult.Invalid;
}
string filePath = commands[Strings.Command_Update][0];
string key = commands[Strings.Command_Update][1];
object value = commands[Strings.Command_Update][2];
this.CheckFile(filePath);
string metadataText = string.Empty;
if (streamList.Count > 0)
{
// update stream metadata
foreach (string streamName in streamList)
{
Console.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.UpdatingStreamMetadata, streamName));
metadataText = this.EditMetadata(filePath, key, value, streamName, updatePersonalMetadata, true);
Console.WriteLine(metadataText);
}
}
else
{
// update file metadata
Console.WriteLine(Strings.UpdatingFileMetadata);
metadataText = this.EditMetadata(filePath, key, value, string.Empty, updatePersonalMetadata, false);
Console.WriteLine(metadataText);
}
Console.WriteLine(Strings.Done);
return CommandLineResult.SucceededExit;
}
// -remove <filename> <metadata key>
if (commands.ContainsKey(Strings.Command_Remove))
{
this.RunCommandLine();
if (commands[Strings.Command_Remove].Count != 2)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Remove));
return CommandLineResult.Invalid;
}
string filePath = commands[Strings.Command_Remove][0];
string key = commands[Strings.Command_Remove][1];
this.CheckFile(filePath);
string metadataText = string.Empty;
if (streamList.Count > 0)
{
// update stream metadata
foreach (string streamName in streamList)
{
Console.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.UpdatingStreamMetadata, streamName));
metadataText = this.EditMetadata(filePath, key, null, streamName, updatePersonalMetadata, true);
Console.WriteLine(metadataText);
}
}
else
{
// update file metadata
Console.WriteLine(Strings.UpdatingFileMetadata);
metadataText = this.EditMetadata(filePath, key, null, string.Empty, updatePersonalMetadata, false);
Console.WriteLine(metadataText);
}
Console.WriteLine(Strings.Done);
return CommandLineResult.SucceededExit;
}
// -play <filename>
if (commands.ContainsKey(Strings.Command_Play))
{
this.RunCommandLine();
if (commands[Strings.Command_Play].Count != 1)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Play));
return CommandLineResult.Invalid;
}
string filePath = commands[Strings.Command_Play][0];
this.CheckFile(filePath);
using (KStudioClient client = KStudio.CreateClient())
{
Console.WriteLine(Strings.WaitToConnect);
client.ConnectToService();
Console.WriteLine(Strings.StartPlayback);
Playback.PlaybackClip(client, filePath, streamList, loopCount);
Console.WriteLine(Strings.StopPlayback);
client.DisconnectFromService();
}
Console.WriteLine(Strings.Done);
return CommandLineResult.SucceededExit;
}
// -record <filename> <duration>
if (commands.ContainsKey(Strings.Command_Record))
{
this.RunCommandLine();
if (commands[Strings.Command_Record].Count != 2)
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Record));
return CommandLineResult.Invalid;
}
string filePath = commands[Strings.Command_Record][0];
this.CheckDirectory(filePath);
double time = 0;
if (!double.TryParse(commands[Strings.Command_Record][1], out time))
{
Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Record));
return CommandLineResult.Invalid;
}
TimeSpan duration = TimeSpan.FromSeconds(time);
string errorMsg = string.Empty;
string fileInfo = string.Empty;
using (KStudioClient client = KStudio.CreateClient())
{
Console.WriteLine(Strings.WaitToConnect);
client.ConnectToService();
Console.WriteLine(Strings.StartRecording);
Recording.RecordClip(client, filePath, duration, streamList);
Console.WriteLine(Strings.StopRecording);
using (KStudioEventFile eventFile = client.OpenEventFile(filePath))
{
FileData fileData = new FileData(eventFile);
fileInfo = fileData.GetFileDataAsText();
Console.WriteLine(fileInfo);
}
client.DisconnectFromService();
}
if (!string.IsNullOrEmpty(logFile))
{
Logger.Start(logFile, true);
Logger.Log(fileInfo);
Logger.Stop();
}
Console.WriteLine(Strings.Done);
return CommandLineResult.SucceededExit;
}
}
catch (Exception ex)
{
string errorMsg = string.Format(Strings.ErrorPrepend, ex.Message);
Console.Error.WriteLine(errorMsg);
return CommandLineResult.Failed;
}
return CommandLineResult.Invalid;
}
