vdr-plugin-restfulapi/recordingmoveexecution.cpp at master · yavdr/vdr-plugin-restfulapi · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include "recordingmoveexecution.h"

namespace {

bool sameRevision(
  const RecordingMutationRevision& left,
  const RecordingMutationRevision& right)
{
  return left.recordingFile == right.recordingFile
    && left.targetFile == right.targetFile
    && left.recordingsState == right.recordingsState
    && left.timersState == right.timersState;
}

}

RecordingMoveExecutionGate::RecordingMoveExecutionGate(
  const RecordingMoveAnalyzer& analyzer,
  const RecordingMutationPlanner& planner)
  : analyzer(analyzer),
    planner(planner)
{
}

RecordingMoveExecutionGateResult RecordingMoveExecutionGate::validate(
  const std::string& recordingFile,
  const std::string& targetFile,
  const RecordingMutationRevision& expectedRevision,
  const RecordingMutationPolicy& policy) const
{
  RecordingMoveExecutionGateResult result;
  result.recordingFile = recordingFile;
  result.targetFile = targetFile;
  result.expectedRevision = expectedRevision;

  const RecordingMutationAnalysis analysis = analyzer.analyze(recordingFile, targetFile);
  const RecordingMutationPlan plan = planner.buildMovePlan(analysis, policy);

  result.currentRevision = analysis.revision;
  result.blockers = plan.blockers;
  result.warnings = plan.warnings;

  if (!sameRevision(expectedRevision, analysis.revision)) {
    result.status = RecordingMoveExecutionGateStatus::Conflict;
    return result;
  }

  if (!plan.executable) {
    result.status = RecordingMoveExecutionGateStatus::Blocked;
    return result;
  }

  result.status = RecordingMoveExecutionGateStatus::Ready;
  return result;
}

const char* RecordingMoveExecutionGateStatusName(
  RecordingMoveExecutionGateStatus status)
{
  switch (status) {
    case RecordingMoveExecutionGateStatus::Ready:
      return "ready";
    case RecordingMoveExecutionGateStatus::Conflict:
      return "conflict";
    case RecordingMoveExecutionGateStatus::Blocked:
      return "blocked";
  }

  return "blocked";
}