public MalListEntry(int malAnimeId, byte? rating, CompletionStatus status, short numEpisodesWatched)
{
MalAnimeId = malAnimeId;
Rating = rating;
Status = status;
NumEpisodesWatched = numEpisodesWatched;
}
private void OnAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
OperationType operationType;
switch (e.LastOperation)
{
case SocketAsyncOperation.Accept:
operationType = OperationType.Accept;
break;
case SocketAsyncOperation.Connect:
operationType = OperationType.Connect;
break;
case SocketAsyncOperation.Receive:
operationType = OperationType.Receive;
break;
case SocketAsyncOperation.Send:
operationType = OperationType.Send;
break;
case SocketAsyncOperation.Disconnect:
operationType = OperationType.Disconnect;
break;
default:
throw new ArgumentOutOfRangeException();
}
CompletionStatus completionStatus = new CompletionStatus(this, m_state, operationType, e.SocketError,
e.BytesTransferred);
m_completionPort.Queue(ref completionStatus);
}
public MalListEntry(byte? rating, CompletionStatus status, short numEpisodesWatched)
: this()
{
Rating = rating;
Status = status;
NumEpisodesWatched = numEpisodesWatched;
}
public void RunAsCommand_Valid_ProcessCompletedCalledWithValidArgs()
{
var Manager = SetupManager();
int CompletedCalled = 0;
Manager.ProcessCompleted += (s, e) => {
CompletedCalled++;
Assert.Equal(CompletionStatus.Success, e.Status);
};
CompletionStatus Result = Manager.RunAsCommand(TestFileName);
Assert.Equal(1, CompletedCalled);
}
public AttemptResult(long attemptId, User user, Theme theme,
CompletionStatus completionStatus, AttemptStatus attemptStatus,
SuccessStatus successStatus, DateTime?startTime, float?scaledScore)
{
this.AttemptId = attemptId;
this.User = user;
this.Theme = theme;
this.CompletionStatus = completionStatus;
this.AttemptStatus = attemptStatus;
this.SuccessStatus = successStatus;
this.StartTime = startTime;
this.Score = new Score(scaledScore);
}
public AttemptResult(long attemptId, User user, Theme theme,
CompletionStatus completionStatus, AttemptStatus attemptStatus,
SuccessStatus successStatus, DateTime? startTime, float? scaledScore)
{
this.AttemptId = attemptId;
this.User = user;
this.Theme = theme;
this.CompletionStatus = completionStatus;
this.AttemptStatus = attemptStatus;
this.SuccessStatus = successStatus;
this.StartTime = startTime;
this.Score = new Score(scaledScore);
}
/// <summary>
/// Gets the RTE string that represents the completion status.
/// </summary>
public static string GetRteCompletionStatus(CompletionStatus status)
{
switch (status)
{
case CompletionStatus.Completed:
return "completed";
case CompletionStatus.Incomplete:
return "incomplete";
case CompletionStatus.NotAttempted:
return "not attempted";
default:
return "unknown";
}
}
public object Convert(object value, Type targetType, object parameter, string language)
{
CompletionStatus inStatus = (CompletionStatus)value;
double opac = 1.0;
if (inStatus != CompletionStatus.inProgress)
{
opac = 0.3;
}
return(opac);
}
void DataComplete(RacingEvent data, CompletionStatus status)
{
if (status == CompletionStatus.Completed || status == CompletionStatus.NoChange)
{
foreach (ShellTile tile in ShellTile.ActiveTiles)
{
StandardTileData tileData = RacingEventDataConverter.Convert(data);
tile.Update(tileData);
}
}
OnUpdateCompleted.Invoke();
}
/// <summary>
/// Encodes specified audio file according to settings. The script file must already be written.
/// </summary>
/// <param name="settings">An object containing the encoding settings.</param>
/// <returns>The endoding completion status..</returns>
public static CompletionStatus EncodeAudio(MediaEncoderSettings settings)
{
CompletionStatus Result = CompletionStatus.Success;
string WavFile = PathManager.GetAudioFile(settings.JobIndex, AudioActions.Wav);
ProcessStartOptions Options = new ProcessStartOptions(settings.JobIndex, "Exporting Audio", false).TrackProcess(settings);
if (!File.Exists(WavFile))
{
EncoderBusiness.SaveAudioToWav(settings, WavFile, Options);
if (settings.CompletionStatus == CompletionStatus.Cancelled)
{
File.Delete(WavFile);
return(CompletionStatus.Cancelled);
}
if (!File.Exists(WavFile))
{
settings.Cancel();
return(CompletionStatus.Error);
}
}
string DestFile = PathManager.GetAudioFile(settings.JobIndex, settings.AudioAction);
if (!File.Exists(DestFile))
{
Options.Title = "Encoding Audio";
if (settings.AudioAction == AudioActions.Opus)
{
string Args = string.Format(@"--bitrate {0} ""{1}"" ""{2}""", settings.AudioQuality, WavFile, DestFile);
FFmpegProcess Worker = new FFmpegProcess(Options);
Result = Worker.Run("Encoder\\opusenc.exe", Args);
}
else if (settings.AudioAction == AudioActions.Aac || settings.AudioAction == AudioActions.Flac)
{
Result = MediaEncoder.Encode(WavFile, null,
settings.AudioAction == AudioActions.Flac ? "flac" : "aac",
string.Format("-b:a {0}k", settings.AudioQuality),
DestFile,
Options);
}
}
if (Result != CompletionStatus.Success || !File.Exists(DestFile))
{
File.Delete(DestFile);
settings.Cancel();
}
return(Result);
}
public AttemptResult(long attemptId, User user, CurriculumChapterTopic curriculumChapterTopic, TopicTypeEnum topicType, CompletionStatus completionStatus, AttemptStatus attemptStatus, SuccessStatus successStatus, DateTime? startTime, DateTime? finishTime, int iudicoCourseRef, float? minScore, float? maxScore, float? rawScore, float? scaledScore)
{
this.AttemptId = attemptId;
this.User = user;
this.CurriculumChapterTopic = curriculumChapterTopic;
this.TopicType = topicType;
this.CompletionStatus = completionStatus;
this.AttemptStatus = attemptStatus;
this.SuccessStatus = successStatus;
this.StartTime = startTime;
this.FinishTime = finishTime;
this.IudicoCourseRef = iudicoCourseRef;
this.Score = new Score(minScore, maxScore, rawScore, scaledScore);
}
public AnswerResult(long activityAttempId, long activityPackageId, string activityTitle, long? interactionId, CompletionStatus completionStatus, SuccessStatus? successStatus,
AttemptResult attempResult, object learnerResponse, string correctResponse, InteractionType? learnerResponseType, float? scaledScore)
{
this.ActivityAttemptId = activityAttempId;
this.ActivityPackageId = activityPackageId;
this.ActivityTitle = activityTitle;
this.InteractionId = interactionId;
this.CompletionStatus = completionStatus;
this.SuccessStatus = successStatus;
this.AttemptResult = attempResult;
this.LearnerResponse = learnerResponse;
this.CorrectResponse = correctResponse;
this.LearnerResponseType = learnerResponseType;
this.ScaledScore = scaledScore;
}
private CompletionStatus ExecuteComplex(string src, string dst)
{
string DstEncode = GetPathWithoutExtension(dst) + "_.mp4";
string DstExtract = GetPathWithoutExtension(dst) + "_.mkv";
string DstAac = GetPathWithoutExtension(dst) + "_.aac";
jobId++;
CompletionStatus Result;
FFmpegConfig.UserInterfaceManager.Start(jobId, "Encoding to H264/AAC (Complex)");
ProcessStartOptions OptionsMain = new ProcessStartOptions(jobId, "", true);
FFmpegProcess ProcessMain = null;
OptionsMain.Started += (sender, e) => {
ProcessMain = e.Process;
};
Task <CompletionStatus> TaskMain = Task.Run(() => MediaEncoder.Encode(src, "h264", null, "", DstEncode, OptionsMain));
ProcessStartOptions Options = new ProcessStartOptions(jobId, "Extracting Audio", false);
Result = MediaMuxer.ExtractAudio(src, DstExtract, Options);
if (Result == CompletionStatus.Success)
{
Options.Title = "Encoding Audio";
Result = MediaEncoder.Encode(DstExtract, null, "aac", null, DstAac, Options);
}
if (Result != CompletionStatus.Success)
{
ProcessMain?.Cancel();
}
TaskMain.Wait();
CompletionStatus Result2 = TaskMain.Result;
if (Result == CompletionStatus.Success && Result2 == CompletionStatus.Success)
{
Options.Title = "Muxing Audio and Video";
Result = MediaMuxer.Muxe(DstEncode, DstAac, dst, Options);
}
File.Delete(DstEncode);
File.Delete(DstExtract);
File.Delete(DstAac);
FFmpegConfig.UserInterfaceManager.Stop(jobId);
return(Result);
}
public void CreateAnswerResultWithParameters()
{
const long ActivityAttemptId = 2349;
const long ActivityPackageId = 83294;
const string ActivityTitle = "Some Activity";
long? interactionId = 12382;
const CompletionStatus CompletionStatus = CompletionStatus.NotAttempted;
const SuccessStatus SuccessStatus = SuccessStatus.Failed;
var attemptResult = new AttemptResult();
const string LearnerResponse = "C";
const string CorrectResponse = "-328";
InteractionType?learnerResponseType = Common.Models.Shared.Statistics.InteractionType.Numeric;
float? scaledScore = 0.58f;
float? minScore = 0;
float? maxScore = 50;
float? rawScore = 29;
string primaryResourceFromManifest = "0.html";
var answerResult = new AnswerResult(
ActivityAttemptId,
ActivityPackageId,
ActivityTitle,
interactionId,
CompletionStatus,
SuccessStatus,
attemptResult,
LearnerResponse,
CorrectResponse,
learnerResponseType,
minScore,
maxScore,
rawScore,
scaledScore,
primaryResourceFromManifest);
Assert.AreEqual(ActivityAttemptId, answerResult.ActivityAttemptId);
Assert.AreEqual(ActivityPackageId, answerResult.ActivityPackageId);
Assert.AreEqual(ActivityTitle, answerResult.ActivityTitle);
Assert.AreEqual(interactionId, answerResult.InteractionId);
Assert.AreEqual(CompletionStatus, answerResult.CompletionStatus);
Assert.AreEqual(SuccessStatus, answerResult.SuccessStatus);
Assert.AreSame(attemptResult, answerResult.AttemptResult);
Assert.AreEqual(LearnerResponse, answerResult.LearnerResponse);
Assert.AreEqual(CorrectResponse, answerResult.CorrectResponse);
Assert.AreEqual(learnerResponseType, answerResult.LearnerResponseType);
Assert.AreEqual(scaledScore, answerResult.ScaledScore);
}
public override void Accept()
{
m_inSocketAsyncEventArgs.AcceptSocket = null;
if (!m_socket.AcceptAsync(m_inSocketAsyncEventArgs))
{
if (m_inSocketAsyncEventArgs.SocketError == SocketError.Success)
{
m_acceptedSocket = new NativeSocket(m_inSocketAsyncEventArgs.AcceptSocket);
}
CompletionStatus completionStatus = new CompletionStatus(this, m_state, OperationType.Accept, SocketError.Success, 0);
m_completionPort.Queue(ref completionStatus);
}
}
/// <summary>
/// Runs vspipe with specified source file. The output will be discarded.
/// </summary>
/// <param name="path">The path to the script to run.</param>
/// <param name="options">The options for starting the process.</param>
/// <param name="callback">A method that will be called after the process has been started.</param>
/// <returns>The process completion status.</returns>
public CompletionStatus RunVapourSynth(string path, ProcessOptionsEncoder options = null, ProcessStartedEventHandler callback = null)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentException("Path cannot be null or empty.", nameof(path));
}
if (!fileSystem.Exists(factory.Config.VsPipePath))
{
throw new System.IO.FileNotFoundException($@"File ""{factory.Config.VsPipePath}"" specified by Config.VsPipePath is not found.");
}
string Args = $@"""{path}"" .";
IProcessWorker Manager = factory.Create(options, callback);
CompletionStatus Result = Manager.Run(factory.Config.VsPipePath, Args);
return(Result);
}
/// <summary>
/// Encodes an Avisynth script through X264 10bit.
/// </summary>
/// <param name="source">The script to encode.</param>
/// <param name="encodeArgs">Options for x264.</param>
/// <param name="destination">The destination file.</param>
/// <param name="options">The options for starting the process.</param>
/// <returns></returns>
public static CompletionStatus EncodeX264_10bit(string source, string encodeArgs, string destination, ProcessStartOptions options)
{
File.Delete(destination);
StringBuilder Query = new StringBuilder("--demuxer y4m ");
Query.Append(encodeArgs);
Query.Append(" -o \"");
Query.Append(destination);
Query.Append("\" -");
// Run x264 with query.
FFmpegProcess Worker = new FFmpegProcess(options);
CompletionStatus Result = Worker.RunAvisynthToEncoder(source, Query.ToString(), EncoderApp.x264, AppPaths.X264Path);
return(Result);
}
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
StringReader reader = new StringReader(worker_process.Output);
StringBuilder errors = new StringBuilder();
bool error_found = false;
string line = "";
string last_line = "";
while ((line = reader.ReadLine()) != null)
{
Console.WriteLine(line);
if (line.IndexOf("Error") >= 0)
{
errors.AppendLine(line);
error_found = true;
}
last_line = line;
}
errors.AppendLine(last_line);
UpdateStatus(WorkingState.Finished);
CompletionStatus result = (CompletionStatus)e.Result;
switch (result)
{
case CompletionStatus.Success:
UpdateStatus(WorkingState.Success);
break;
case CompletionStatus.Error:
Console.WriteLine("Parameters: " + worker_process.CommandWithArgs);
UpdateStatus(WorkingState.Error, errors.ToString());
break;
case CompletionStatus.Cancelled:
UpdateStatus(WorkingState.Cancelled);
break;
case CompletionStatus.Timeout:
UpdateStatus(WorkingState.Timeout);
break;
default:
break;
}
}
public static void AddToModelState(this CompletionStatus completionStatus, ModelStateDictionary modelState)
{
foreach (var validationError in completionStatus.MessageList)
{
if (validationError.FieldNames.Count == 0)
{
modelState.AddModelError("Validation Errors", validationError.Message);
}
else
{
foreach (var fieldName in validationError.FieldNames)
{
modelState.AddModelError(fieldName, validationError.Message);
}
}
}
}
public void RunAsCommand_Valid_ProcessStartedCalledWithValidArgs()
{
var Manager = SetupManager();
int ProcessStartedCalled = 0;
Manager.ProcessStarted += (s, e) => {
ProcessStartedCalled++;
Assert.NotNull(s);
Assert.NotNull(e.ProcessWorker);
Assert.Equal(Manager, e.ProcessWorker);
Assert.NotNull(Manager.WorkProcess);
};
CompletionStatus Result = Manager.RunAsCommand(TestFileName);
Assert.Equal(1, ProcessStartedCalled);
}
public OwnedArtifactGroup FindOneRecordBy(int id, int groupID, CompletionStatus completiotStatus)
{
using NpgsqlConnection connection = OpenConnectionToDB();
var query = $"SELECT * FROM \"NATQuest\".\"{DBTableName}\" WHERE \"ArtifactID\" = '{id}' AND \"GroupID\" = '{groupID}' AND \"ArtifactStatusID\" = {(int)completiotStatus} LIMIT 1;";
using var command = new NpgsqlCommand(query, connection);
var reader = command.ExecuteReader();
var oneRecord = default(OwnedArtifactGroup);
while (reader.Read())
{
oneRecord = ProvideOneRecord(reader);
}
;
return(oneRecord);
}
/// <summary>
/// Runs avs2yuv with specified source file. The output will be discarded.
/// </summary>
/// <param name="path">The path to the script to run.</param>
public CompletionStatus RunAvisynth(string path)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentException("Path cannot be null or empty.", nameof(path));
}
if (!fileSystem.Exists(Config.Avs2yuvPath))
{
throw new System.IO.FileNotFoundException(string.Format(@"File ""{0}"" specified by Config.Avs2yuvPath is not found.", Config.Avs2yuvPath));
}
string TempFile = path + ".out";
string Args = string.Format(@"""{0}"" -o ""{1}""", path, TempFile);
CompletionStatus Result = Run(Config.Avs2yuvPath, Args);
fileSystem.Delete(TempFile);
return(Result);
}
private CompletionStatus GenerateDeshakerLogSegment(MediaEncoderSettings settings, string inputFile, int segment, long jobStart, long frameStart, long frameEnd, ProcessStartOptions jobOptions)
{
// Write Deshaker Pass 1 script to file.
string Script = MediaEncoderScript.GenerateDeshakerScript(settings, inputFile, segment, frameStart, frameEnd);
File.WriteAllText(settings.DeshakerScript, Script);
// Run pass.
jobOptions.IsMainTask = true;
jobOptions.Title = "Running Deshaker Prescan";
jobOptions.ResumePos = frameStart - jobStart;
CompletionStatus Result = FFmpeg.MediaEncoder.ConvertToAvi(settings.DeshakerScript, settings.DeshakerTempOut, false, jobOptions);
File.Delete(settings.DeshakerScript);
File.Delete(settings.DeshakerTempOut);
return(Result);
}
private CompletionStatus ExecuteComplex(string src, string dst)
{
string DstEncode = GetPathWithoutExtension(dst) + "_.mp4";
string DstExtract = GetPathWithoutExtension(dst) + "_.mkv";
string DstAac = GetPathWithoutExtension(dst) + "_.aac";
jobId++;
CompletionStatus Result;
ffmpegManagerUI.Start(jobId, "Encoding to H264/AAC (Complex)");
ProcessOptionsFFmpeg OptionsMain = new ProcessOptionsFFmpeg(jobId, "", true);
IProcessManager ProcessMain = null;
Task <CompletionStatus> TaskMain = Task.Run(() => encoder.Encode(src, "h264", null, "", DstEncode, OptionsMain));
ProcessOptionsFFmpeg Options = new ProcessOptionsFFmpeg(jobId, "Extracting Audio", false);
Result = muxer.ExtractAudio(src, DstExtract, Options);
if (Result == CompletionStatus.Success)
{
Options.Title = "Encoding Audio";
Result = encoder.Encode(DstExtract, null, "aac", null, DstAac, Options,
(s, p) => ProcessMain = p.ProcessManager);
}
if (Result != CompletionStatus.Success)
{
ProcessMain?.Cancel();
}
TaskMain.Wait();
CompletionStatus Result2 = TaskMain.Result;
if (Result == CompletionStatus.Success && Result2 == CompletionStatus.Success)
{
Options.Title = "Muxing Audio and Video";
Result = muxer.Muxe(DstEncode, DstAac, dst, Options);
}
File.Delete(DstEncode);
File.Delete(DstExtract);
File.Delete(DstAac);
ffmpegManagerUI.Stop(jobId);
return(Result);
}
/// <summary>
/// Merges specified audio and video files.
/// </summary>
/// <param name="videoFile">The file containing the video.</param>
/// <param name="audioFile">The file containing the audio.</param>
/// <param name="destination">The destination file.</param>
/// <param name="options">The options for starting the process.</param>
/// <returns>The process completion status.</returns>
public static CompletionStatus Muxe(string videoFile, string audioFile, string destination, ProcessStartOptions options)
{
CompletionStatus Result = CompletionStatus.Success;
File.Delete(destination);
// FFMPEG fails to muxe H264 into MKV container. Converting to MP4 and then muxing with the audio, however, works.
string OriginalVideoFile = videoFile;
if ((videoFile.EndsWith(".264") || videoFile.EndsWith(".265")) && destination.ToLower().EndsWith(".mkv"))
{
videoFile = videoFile.Substring(0, videoFile.Length - 4) + ".mp4";
Result = Muxe(OriginalVideoFile, null, videoFile, options);
}
if (Result == CompletionStatus.Success)
{
// Join audio and video files.
FFmpegProcess Worker = new FFmpegProcess(options);
// FFMPEG-encoded AAC streams are invalid and require an extra flag to join.
bool FixAac = audioFile != null?audioFile.ToLower().EndsWith(".aac") : false;
string Query;
if (string.IsNullOrEmpty(audioFile))
{
Query = string.Format(@"-y -i ""{0}"" -vcodec copy -an ""{1}""", videoFile, destination);
}
else if (string.IsNullOrEmpty(videoFile))
{
Query = string.Format(@"-y -i ""{0}"" -acodec copy -vn ""{1}""", videoFile, destination);
}
else
{
Query = string.Format(@"-y -i ""{0}"" -i ""{1}"" -acodec copy -vcodec copy -map 0:v -map 1:a{2} ""{3}""", videoFile, audioFile, FixAac ? " -bsf:a aac_adtstoasc" : "", destination);
}
Result = Worker.RunFFmpeg(Query);
}
// Delete temp file.
if (OriginalVideoFile != videoFile)
{
File.Delete(videoFile);
}
return(Result);
}
public void DeleteUsedArtifactFromView(Student student, int artifactID)
{
var artifactToDelete = _artifact.FindOneRecordBy(artifactID);
CompletionStatus completionStatus = CompletionStatus.Finished;
switch (artifactToDelete.Type)
{
case TypeClassification.Individual:
var model = _ownedArtifactStudent.FindOneRecordBy(artifactID, student.Id, completionStatus);
_ownedArtifactStudent.DeleteRecord(model.Id);
break;
case TypeClassification.Group:
var modelGroup = _ownedArtifactGroup.FindOneRecordBy(artifactID, student.GroupID, completionStatus);
_ownedArtifactGroup.DeleteRecord(modelGroup.Id);
break;
}
}
public void CreateAttemptResultWithParameters()
{
const long AttemptId = 12312;
const int IudicoCourseRef = 23;
var user = new User();
var curriculumChapterTopic = new CurriculumChapterTopic();
const TopicTypeEnum TopicTypeEnum = TopicTypeEnum.TestWithoutCourse;
const CompletionStatus CompletionStatus = CompletionStatus.Incomplete;
const AttemptStatus AttemptStatus = AttemptStatus.Completed;
const SuccessStatus SuccessStatus = SuccessStatus.Passed;
DateTime? startTime = new DateTime(32478932);
DateTime? finishTime = new DateTime(189041324);
float? score = 0.22f;
float? minScore = 0;
float? maxScore = 50;
float? rawScore = 11;
var attemptResult = new AttemptResult(
AttemptId,
user,
curriculumChapterTopic,
TopicTypeEnum,
CompletionStatus,
AttemptStatus,
SuccessStatus,
startTime,
finishTime,
IudicoCourseRef,
minScore,
maxScore,
rawScore,
score);
Assert.AreEqual(AttemptId, attemptResult.AttemptId);
Assert.AreEqual(user, attemptResult.User);
Assert.AreEqual(curriculumChapterTopic, attemptResult.CurriculumChapterTopic);
Assert.AreEqual(TopicTypeEnum, attemptResult.TopicType);
Assert.AreEqual(CompletionStatus, attemptResult.CompletionStatus);
Assert.AreEqual(AttemptStatus, attemptResult.AttemptStatus);
Assert.AreEqual(SuccessStatus, attemptResult.SuccessStatus);
Assert.AreEqual(startTime, attemptResult.StartTime);
Assert.AreEqual(finishTime, attemptResult.FinishTime);
Assert.AreEqual(score, attemptResult.Score.ScaledScore);
}
public static bool MarkTaskStatus(this TaskContext context, CompletionStatus completionStatus, ResultStatus result, string reason, IStateManager steManager)
{
try
{
context.Logger.Info(reason);
//IStateManager steManager = Bus.StateManager;
//todo:
IReadWritableTaskState task = context.TaskStateWritable;
var isDone = completionStatus.IsDone();
if (isDone)
{
task.IsFinished = true;
task.CompletedOn = DateTime.UtcNow;
}
if (result.Id == ResultStatus.Error.Id)
{
task.FailedCount = task.FailedCount + 1;
}
task.UpdatedOn = DateTime.UtcNow;
task.Status = result;
steManager.UpdateTask(task, context.Transaction, isDone);
if (isDone)
{
context.Logger.Info("Done");
//context.Transaction.Commit();
}
return(true);
}
catch (FrameworkException e)
{
context.Logger.Error("FrameworkException while updating task status from node {node}, Complete: {complete}, Result: {result}, Reason: {reason} with error {error}", NodeSettings.Instance.Name, completionStatus.Name, result.Name, reason, e);
return(false);
}
catch (Exception e)
{
context.Logger.Error("Failed to update task status from node {node}, Complete: {complete}, Result: {result}, Reason: {reason} with error {error}", NodeSettings.Instance.Name, completionStatus.Name, result.Name, reason, e);
return(false);
}
}
/// <summary>
/// Runs avs2pipemod with specified source file. The output will be discarded.
/// </summary>
/// <param name="path">The path to the script to run.</param>
/// <param name="options">The options for starting the process.</param>
/// <param name="callback">A method that will be called after the process has been started.</param>
/// <returns>The process completion status.</returns>
public CompletionStatus RunAvisynth(string path, ProcessOptionsEncoder options = null, ProcessStartedEventHandler callback = null)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentException("Path cannot be null or empty.", nameof(path));
}
if (!fileSystem.Exists(factory.Config.Avs2PipeMod))
{
throw new System.IO.FileNotFoundException($@"File ""{factory.Config.Avs2PipeMod}"" specified by Config.Avs2PipeModPath is not found.");
}
string Args = $@"""{path}"" -rawvideo > NUL";
IProcessWorker Manager = factory.Create(options, callback);
Manager.OutputType = ProcessOutput.Error;
string Cmd = $@"""{factory.Config.Avs2PipeMod}"" {Args}";
CompletionStatus Result = Manager.RunAsCommand(Cmd);
return(Result);
}
private void PrintStateTransitionStatus(InstanceOperation instOp, CompletionStatus operationStatus)
{
string operationType = ConvertInstanceOperation(instOp);
switch (operationStatus)
{
case (CompletionStatus.Succeeded):
Console.WriteLine("The " + operationType + " operation succeeded.");
return;
case (CompletionStatus.Failed):
Console.WriteLine("The " + operationType + " operation failed.");
return;
case (CompletionStatus.Pending):
Console.WriteLine("The " + operationType + " operation is pending or was skipped.");
return;
}
}
public override void Send(byte[] buffer, int offset, int count, SocketFlags flags)
{
if (m_outSocketAsyncEventArgs.Buffer != buffer)
{
m_outSocketAsyncEventArgs.SetBuffer(buffer, offset, count);
}
else if (m_outSocketAsyncEventArgs.Offset != offset || m_inSocketAsyncEventArgs.Count != count)
{
m_outSocketAsyncEventArgs.SetBuffer(offset, count);
}
if (!m_socket.SendAsync(m_outSocketAsyncEventArgs))
{
CompletionStatus completionStatus = new CompletionStatus(this, m_state, OperationType.Send, m_outSocketAsyncEventArgs.SocketError,
m_outSocketAsyncEventArgs.BytesTransferred);
m_completionPort.Queue(ref completionStatus);
}
}
public static void MarkProcessStatus(this IReadWritableProcessState state, CompletionStatus completionStatus,
ResultStatus result, string reason, IStateManager stateManager, IProcessRepository registeredProcesses,
IProcessExecutionContext executionContext, IBatchEngineSubscribers batchEngineSubscribers,
IFrameworkLogger fLogger)
{
state.Status = completionStatus;
state.Result = result;
if (completionStatus.IsDone())
{
state.CompleteTime = DateTime.UtcNow;
}
state.IsFinished = completionStatus.Id == CompletionStatus.Finished.Id;
state.IsStopped = completionStatus.Id == CompletionStatus.Stopped.Id;
stateManager.SaveProcess(state);
state.TriggerProcessEvents(registeredProcesses, executionContext, result.Id == ResultStatus.Error.Id, state.IsStopped,
batchEngineSubscribers, fLogger, reason);
}
public void UseArtifact(Student student, int artifactID)
{
var artifactToUse = _artifact.FindOneRecordBy(artifactID);
CompletionStatus completionStatus = CompletionStatus.Unfinished;
switch (artifactToUse.Type)
{
case TypeClassification.Individual:
var model = _ownedArtifactStudent.FindOneRecordBy(artifactID, student.Id, completionStatus);
model.CompletionStatus = CompletionStatus.Finished;
_ownedArtifactStudent.UpdateRecord(model);
break;
case TypeClassification.Group:
var modelGroup = _ownedArtifactGroup.FindOneRecordBy(artifactID, student.GroupID, completionStatus);
modelGroup.CompletionStatus = CompletionStatus.Finished;
_ownedArtifactGroup.UpdateRecord(modelGroup);
break;
}
}
public void GetJobs_WithCompletionStatusFilter_ReturnsResultsMatchingFilter()
{
// Arrange
CompletionStatus completionStatus = CompletionStatus.Succeeded;
IJobRepository jobRepository = CreateJobRepository();
jobRepository
.GetJobs()
.Returns(testData.AsQueryable());
IJobService jobService = CreateJobService(jobRepository);
// Act
IActionResult results = jobService.GetJobs(null, null, null, null, completionStatus, false, 1);
// Assert
OkObjectResult objResult = results
.Should()
.BeOfType <OkObjectResult>()
.Subject;
JobQueryResponseModel response = objResult.Value
.Should()
.BeOfType <JobQueryResponseModel>()
.Subject;
response.TotalItems.Should().Be(3);
response.CurrentPage.Should().Be(1);
response.TotalPages.Should().Be(1);
IEnumerable <JobSummary> summaries = response.Results;
summaries
.Should()
.OnlyContain(s => s.CompletionStatus == completionStatus);
summaries
.Should()
.HaveCount(3);
}
public static string GetStatusClass(CompletionStatus status)
{
var statusClass = "fa ";
switch (status)
{
case CompletionStatus.NotStarted:
statusClass += "fa-circle";
break;
case CompletionStatus.InProgress:
statusClass += "fa-spinner fa-spin";
break;
case CompletionStatus.Completed:
statusClass += "fa-check-circle";
break;
}
return(statusClass);
}
/// <summary>
/// For files encoded in various segments (stop/resume), merge the various segments.
/// </summary>
private CompletionStatus MergeSegments(MediaEncoderSettings settings, string destination) {
MediaEncoderSegments segBusiness = new MediaEncoderSegments();
segBusiness.Analyze(settings);
if (segBusiness.SegLeft.Count() > 0)
return CompletionStatus.Error;
List<string> SegmentList = new List<string>();
foreach (SegmentInfo seg in segBusiness.SegDone) {
SegmentList.Add(PathManager.GetOutputFile(settings.JobIndex, seg.Start, settings.Container));
}
CompletionStatus Result = CompletionStatus.Success;
File.Delete(destination);
if (SegmentList.Count == 1)
File.Move(SegmentList[0], destination);
else if (SegmentList.Count > 1) {
Result = MediaMuxer.Concatenate(SegmentList, destination, new ProcessStartOptions(settings.JobIndex, "Merging Files", false));
}
settings.CompletionStatus = Result;
return Result;
}
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
StringReader reader = new StringReader(worker_process.Output);
string line = "";
while ((line = reader.ReadLine()) != null)
{
if (line.IndexOf("Error") >= 0)
{
break;
}
}
Console.WriteLine(line);
UpdateStatus(WorkingState.Finished);
CompletionStatus result = (CompletionStatus)e.Result;
switch (result)
{
case CompletionStatus.Success:
UpdateStatus(WorkingState.Success);
break;
case CompletionStatus.Error:
UpdateStatus(WorkingState.Error, line);
break;
case CompletionStatus.Cancelled:
UpdateStatus(WorkingState.Cancelled);
break;
case CompletionStatus.Timeout:
UpdateStatus(WorkingState.Timeout);
break;
default:
break;
}
}
private void OnAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
OperationType operationType;
switch (e.LastOperation)
{
case SocketAsyncOperation.Accept:
operationType = OperationType.Accept;
if (e.SocketError == SocketError.Success)
{
m_acceptedSocket = new NativeSocket(e.AcceptSocket);
}
break;
case SocketAsyncOperation.Connect:
operationType = OperationType.Connect;
break;
case SocketAsyncOperation.Receive:
operationType = OperationType.Receive;
break;
case SocketAsyncOperation.Send:
operationType = OperationType.Send;
break;
case SocketAsyncOperation.Disconnect:
operationType = OperationType.Disconnect;
break;
default:
throw new ArgumentOutOfRangeException();
}
CompletionStatus completionStatus = new CompletionStatus(this, m_state, operationType, e.SocketError,
e.BytesTransferred);
m_completionPort.Queue(ref completionStatus);
}
public override bool GetMultipleQueuedCompletionStatus(int timeout, CompletionStatus[] completionStatuses, out int removed)
{
if (m_overlappedEntries == null || m_overlappedEntries.Length < completionStatuses.Length)
{
if (m_overlappedEntries != null)
{
m_overlappedEntriesHandle.Free();
}
m_overlappedEntries = new OverlappedEntry[completionStatuses.Length];
m_overlappedEntriesHandle = GCHandle.Alloc(m_overlappedEntries, GCHandleType.Pinned);
m_overlappedEntriesAddress = Marshal.UnsafeAddrOfPinnedArrayElement(m_overlappedEntries, 0);
}
bool result = UnsafeMethods.GetQueuedCompletionStatusEx(m_completionPortHandle, m_overlappedEntriesAddress,
completionStatuses.Length, out removed, timeout, false);
if (!result)
{
int error = Marshal.GetLastWin32Error();
if (error == WaitTimeoutError)
{
removed = 0;
return false;
}
throw new Win32Exception(error);
}
for (int i = 0; i < removed; i++)
{
HandleCompletionStatus(out completionStatuses[i], m_overlappedEntries[i].Overlapped,
m_overlappedEntries[i].CompletionKey, m_overlappedEntries[i].BytesTransferred);
}
return true;
}
/// <summary>
/// All enum values are valid.
/// </summary>
/// <param name="value">The value to validate.</param>
public override void ValidateCompletionStatus(CompletionStatus value)
{
switch(value)
{
case CompletionStatus.Completed:
case CompletionStatus.Incomplete:
case CompletionStatus.NotAttempted:
case CompletionStatus.Unknown:
break;
default:
throw new ArgumentOutOfRangeException("value");
}
}
public abstract void ValidateCompletionStatus(CompletionStatus value);
public void SendReceive()
{
CompletionPort completionPort = CompletionPort.Create();
bool exception = false;
var task = Task.Factory.StartNew(() =>
{
bool cancel = false;
while (!cancel)
{
CompletionStatus [] completionStatuses = new CompletionStatus[10];
int removed;
completionPort.GetMultipleQueuedCompletionStatus(-1, completionStatuses, out removed);
for (int i = 0; i < removed; i++)
{
if (completionStatuses[i].OperationType == OperationType.Signal)
{
cancel = true;
}
else if (completionStatuses[i].SocketError == SocketError.Success)
{
EventWaitHandle manualResetEvent = (EventWaitHandle)completionStatuses[i].State;
manualResetEvent.Set();
}
else
{
exception = true;
}
}
}
});
AutoResetEvent clientEvent = new AutoResetEvent(false);
AutoResetEvent acceptedEvent = new AutoResetEvent(false);
AsyncSocket listener = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(listener, acceptedEvent);
listener.Bind(IPAddress.Any, 5553);
listener.Listen(1);
AsyncSocket serverSocket = AsyncSocket.CreateIPv4Tcp();
listener.Accept(serverSocket);
AsyncSocket clientSocket = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(clientSocket, clientEvent);
clientSocket.Bind(IPAddress.Any,0);
clientSocket.Connect("localhost", 5553);
clientEvent.WaitOne();
acceptedEvent.WaitOne();
AutoResetEvent serverEvent = new AutoResetEvent(false);
completionPort.AssociateSocket(serverSocket, serverEvent);
byte[] recv = new byte[1];
serverSocket.Receive(recv);
byte[] data = new[] {(byte)1};
clientSocket.Send(data);
clientEvent.WaitOne(); // wait for data to be send
serverEvent.WaitOne(); // wait for data to be received
Assert.AreEqual(1, recv[0]);
completionPort.Signal(null);
task.Wait();
Assert.IsFalse(exception);
completionPort.Dispose();
listener.Dispose();
serverSocket.Dispose();
clientSocket.Dispose();
}
//Seperate Connection is not used?
public long Save(CompletionStatus status, string CompletionMsg, bool SeperateConnection)
{
SqlUtil sql = new SqlUtil(mDatabase);
sql.BypassTransaction = true;
return Save(status, CompletionMsg, sql);
}
/// <summary>
/// you can supply your own SQL object and force the audit to go to that database. Used by GT
/// </summary>
/// <param name="status"></param>
/// <param name="CompletionMsg"></param>
/// <param name="SQL"></param>
/// <returns></returns>
public long Save(CompletionStatus status, string CompletionMsg, SqlUtil SQL)
{
//save it - just in case of recovery
mCompletionStatus = status;
mCompletionMsg = CompletionMsg;
string sql;
SqlParameterCollection oParameters = new SqlCommand().Parameters;
long ID = -1;
oParameters.AddWithValue("@iDataType", DataUtils.DBNullIfNull(mDataType));
oParameters.AddWithValue("@iDataID", DataUtils.DBNullIfNull(mDataID));
oParameters.AddWithValue("@iCorrespondenceID", DataUtils.DBNullIfNull(mCorrespondenceID));
oParameters.AddWithValue("@iEventID", DataUtils.DBNullIfNull(mEventID));
oParameters.AddWithValue("@iEventDescription", DataUtils.DBNullIfNull(mEventDescription));
oParameters.AddWithValue("@iCompletionMsg", DataUtils.DBNullIfNull(CompletionMsg));
oParameters.AddWithValue("@iCompletionStatus", DataUtils.DBNullIfNull(status));
if (mLogTime == DateTime.MinValue)
mLogTime = DateTimeUtility.ServerDateNoRefresh();
oParameters.AddWithValue("@iTime", mLogTime);
sql = "set ansi_warnings off;INSERT INTO AuditHeader (DataType,DataID,CorrespondenceID,EventID,EventDescription,CompletionMsg,CompletionStatus,LogTime)"
+ " VALUES (@iDataType,@iDataID,@iCorrespondenceID,@iEventID,@iEventDescription,@iCompletionMsg,@iCompletionStatus,@iTime)";
sql += "; select @@IDENTITY as ID";
DataTable oTable;
try {
oTable = SQL.ExecuteSingleResultSetSQLQuery(sql, oParameters);
} catch (Exception x) {
if (mRecover && SqlRecover.SaveForRecovery(x, true, this, "auditheader"))
return 0;
else
throw new Exception("sql error", x);
}
if (oTable.Rows.Count == 0)
return -1;
ID = DataUtils.LongZeroIfNull(oTable.Rows[0]["ID"]);
if (ID < 1)
return -1;
if (mFieldChanges != null) {
string o;
string n;
oParameters = new SqlCommand().Parameters;
foreach (string field in mFieldChanges.UpdateList.Keys) {
mFieldChanges.GetAuditValue(field, out o, out n);
oParameters.AddWithValue("@iAuditID", ID);
oParameters.AddWithValue("@iField", DataUtils.DBNullIfNull(field));
oParameters.AddWithValue("@iOldVal", DataUtils.DBNullIfNull(o));
oParameters.AddWithValue("@iNewVal", DataUtils.DBNullIfNull(n));
sql = "set ansi_warnings off;INSERT INTO AuditDetail(AuditID,Field, OldValue,NewValue) " +
" VALUES (@iAuditID,@iField, @iOldVal,@iNewVal);";
SQL.ExecuteNoResultSetSQLQuery(sql, oParameters);
oParameters.Clear();
}
}
return ID;
}
public override void Connect(System.Net.IPEndPoint endPoint)
{
m_outSocketAsyncEventArgs.RemoteEndPoint = endPoint;
if (!m_socket.ConnectAsync(m_outSocketAsyncEventArgs))
{
CompletionStatus completionStatus = new CompletionStatus(this, m_state, OperationType.Connect, SocketError.Success, 0);
m_completionPort.Queue(ref completionStatus);
}
}
private void HandleCompletionStatus(out CompletionStatus completionStatus, IntPtr overlappedAddress, IntPtr completionKey, int bytesTransferred)
{
if (completionKey.Equals(SignalPostCompletionKey))
{
object state;
m_signalQueue.TryDequeue(out state);
completionStatus = new CompletionStatus(null, state, OperationType.Signal, SocketError.Success, 0);
}
else
{
var overlapped = Overlapped.CompleteOperation(overlappedAddress);
if (completionKey.Equals(SocketCompletionKey))
{
// if the overlapped ntstatus is zero we assume success and don't call get overlapped result for optimization
if (overlapped.Success)
{
SocketError socketError = SocketError.Success;
try
{
if (overlapped.OperationType == OperationType.Accept)
{
overlapped.AsyncSocket.UpdateAccept();
}
else if (overlapped.OperationType == OperationType.Connect)
{
overlapped.AsyncSocket.UpdateConnect();
}
}
catch (SocketException)
{
socketError = (SocketError)Marshal.GetLastWin32Error();
}
completionStatus = new CompletionStatus(overlapped.AsyncSocket, overlapped.State,
overlapped.OperationType, socketError,
bytesTransferred);
}
else
{
SocketError socketError = SocketError.Success;
SocketFlags socketFlags;
bool operationSucceed = UnsafeMethods.WSAGetOverlappedResult(overlapped.AsyncSocket.Handle,
overlappedAddress,
out bytesTransferred, false, out socketFlags);
if (!operationSucceed)
{
socketError = (SocketError)Marshal.GetLastWin32Error();
}
completionStatus = new CompletionStatus(overlapped.AsyncSocket, overlapped.State,
overlapped.OperationType, socketError,
bytesTransferred);
}
}
else
{
completionStatus = new CompletionStatus(overlapped.AsyncSocket, overlapped.State,
overlapped.OperationType, SocketError.Success, 0);
}
}
}
public TRANSACTION_UNAVAILABLE(int minor, CompletionStatus status) :
base(System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.FullName, minor, status) { }
public CODESET_INCOMPATIBLE(int minor, CompletionStatus status) :
base(System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.FullName, minor, status) { }
public long Save(CompletionStatus status, string CompletionMsg)
{
return Save(status, CompletionMsg, SqlUtil.Get(mDatabase));
}
public NO_IMPLEMENT(int minor, CompletionStatus status, string missingtype) :
base(System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.FullName +
" ["+missingtype+"] ", minor, status) { }
public override void Receive(byte[] buffer, int offset, int count, SocketFlags flags)
{
m_inSocketAsyncEventArgs.AcceptSocket = null;
if (m_inSocketAsyncEventArgs.Buffer != buffer)
{
m_inSocketAsyncEventArgs.SetBuffer(buffer, offset, count);
}
else if (m_inSocketAsyncEventArgs.Offset != offset || m_inSocketAsyncEventArgs.Count != count)
{
m_inSocketAsyncEventArgs.SetBuffer(offset, count);
}
if (!m_socket.ReceiveAsync(m_inSocketAsyncEventArgs))
{
CompletionStatus completionStatus = new CompletionStatus(this, m_state, OperationType.Receive, m_inSocketAsyncEventArgs.SocketError,
m_inSocketAsyncEventArgs.BytesTransferred);
m_completionPort.Queue(ref completionStatus);
}
}
public override void Accept(AsyncSocket socket)
{
NativeSocket nativeSocket = (NativeSocket)socket;
m_inSocketAsyncEventArgs.AcceptSocket = nativeSocket.m_socket;
if (!m_socket.AcceptAsync(m_inSocketAsyncEventArgs))
{
CompletionStatus completionStatus = new CompletionStatus(this, m_state, OperationType.Accept, SocketError.Success, 0);
m_completionPort.Queue(ref completionStatus);
}
}
/// <summary>
/// This value is not valid for SCORM 1.2
/// </summary>
/// <param name="value">The value to validate.</param>
public override void ValidateCompletionStatus(CompletionStatus value)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.OnlyValidForSCORMV1p3, "CompletionStatus"));
}
public static string MalAnimeStatusAsString(CompletionStatus status)
{
// This could come from the DB...
switch (status)
{
case CompletionStatus.Completed:
return "Completed";
case CompletionStatus.Dropped:
return "Dropped";
case CompletionStatus.OnHold:
return "On Hold";
case CompletionStatus.PlanToWatch:
return "Plan to Watch";
case CompletionStatus.Watching:
return "Watching";
default:
return "???";
}
}
public override bool GetQueuedCompletionStatus(int timeout, out CompletionStatus completionStatus)
{
int bytesTransferred;
IntPtr completionKey;
IntPtr overlappedAddress;
bool result = UnsafeMethods.GetQueuedCompletionStatus(m_completionPortHandle, out bytesTransferred,
out completionKey, out overlappedAddress, timeout);
if (!result && overlappedAddress == IntPtr.Zero)
{
int error = Marshal.GetLastWin32Error();
if (error == WaitTimeoutError)
{
completionStatus = new CompletionStatus();
return false;
}
throw new Win32Exception(error);
}
HandleCompletionStatus(out completionStatus, overlappedAddress, completionKey, bytesTransferred);
return true;
}
public TRANSIENT(int minor, CompletionStatus status, string additionalDetail) :
base(System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.FullName +
" ["+additionalDetail+"] ", minor, status) { }
protected AbstractCORBASystemException(System.Runtime.Serialization.SerializationInfo info,
System.Runtime.Serialization.StreamingContext context) : base(info, context) {
m_minor = info.GetInt32("minor");
m_status = (CompletionStatus)
info.GetValue("status", typeof(CompletionStatus));
}
public AnswerResult(long activityAttempId, long activityPackageId, string activityTitle, long? interactionId, CompletionStatus completionStatus, SuccessStatus? successStatus, AttemptResult attempResult, object learnerResponse, string correctResponse, InteractionType? learnerResponseType, float? minScore, float? maxScore, float? rawScore, float? scaledScore, string primaryResourceFromManifest)
{
this.ActivityAttemptId = activityAttempId;
this.ActivityPackageId = activityPackageId;
this.ActivityTitle = activityTitle;
this.InteractionId = interactionId;
this.CompletionStatus = completionStatus;
this.SuccessStatus = successStatus;
this.AttemptResult = attempResult;
this.LearnerResponse = learnerResponse;
this.CorrectResponse = correctResponse;
this.LearnerResponseType = learnerResponseType;
this.MinScore = minScore;
this.MaxScore = maxScore;
this.RawScore = rawScore;
this.ScaledScore = scaledScore;
this.PrimaryResourceFromManifest = primaryResourceFromManifest;
}
protected AbstractCORBASystemException(string exceptionDesc, int minor, CompletionStatus status) :
base("CORBA system exception : " + exceptionDesc +
", completed: " + status + " minor: " + minor) {
m_minor = minor;
m_status = status;
}
public BAD_QOS(int minor, CompletionStatus status) :
base(System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.FullName, minor, status) { }
