internal override bool SaveChildren(AbstractXServer _server, SessionId _sessionId, IStorage _storage, DateTime _now)
{
var toSave = new List<Guid>();
foreach (var pair in XValues)
{
var list = pair.Value as ServerXList;
if (list != null)
{
toSave.AddRange(list.GetGuids());
}
}
var saved = false;
foreach (var uid in toSave.Distinct())
{
saved |= _server.SaveInternal(uid, _storage, _now, _sessionId);
}
return saved;
}
public ServerXReport GetReport(int _kind, Guid _uid, SessionId _sessionId)
{
return ServiceContract.GetReport(_kind, _uid, _sessionId);
}
public void ClientObjectChanged(XReport _report, SessionId _sessionId)
{
ServiceContract.ClientObjectChanged(_report, _sessionId);
}
public void ObjectSaved(Int32 _kind, Guid _uid, SessionId _sessionId)
{
if (OnServerObjectSaved != null)
{
OnServerObjectSaved(_kind, _uid, _sessionId);
}
}
public IEnumerable<UndoXReport> Undo(Guid _uid, SessionId _sessionId)
{
return ServiceContract.Undo(_uid, _sessionId);
}
public IEnumerable<ServerXReport> Redo(Guid _uid, SessionId _sessionId)
{
return ServiceContract.Redo(_uid, _sessionId);
}
public uint GetCurrentGeneration(SessionId _sessionId)
{
int current;
if(m_currentVersion.TryGetValue(_sessionId, out current) && current>=0)
{
return m_changes[_sessionId][current].ActualFrom;
}
return Stored;
}
internal virtual bool SaveChildren(AbstractXServer _server, SessionId _sessionId, IStorage _storage, DateTime _now)
{
var saved = false;
foreach (var pair in m_xValues)
{
var list = pair.Value as ServerXList;
if (list != null)
{
foreach (var childUid in list.GetGuids())
{
saved = _server.SaveChild(childUid, Uid, _sessionId, _storage, pair.Key, _now) | saved;
}
}
}
return saved;
}
public bool Equals(SessionId _other)
{
return _other.m_value == m_value;
}
private void OnServerObjectSaved(Guid _uid, SessionId _sessionId)
{
//Console.WriteLine("SAVED:" + _uid);
if (m_serverObjectSaved != null)
{
if (IsAsync)
{
foreach (ServerObjectSaved d in m_serverObjectSaved.GetInvocationList())
{
d.BeginInvoke(m_objects[_uid].Kind, _uid, _sessionId, null, null);
}
}
else
{
m_serverObjectSaved(m_objects[_uid].Kind, _uid, _sessionId);
}
}
}
internal IEnumerable<UndoXReport> Undo(Guid _uid, SessionId _sessionId)
{
var dateTime = uint.MinValue;
var candidates = new List<Guid>();
GetAvailableUndoDate(_uid, _sessionId, this, ref dateTime, ref candidates);
var reports = new List<UndoXReport>();
foreach (var candidateUid in candidates.Distinct())
{
var serverXObjectContainer = m_objects[candidateUid];
reports.Add(serverXObjectContainer.Undo(_sessionId));
}
return reports;
}
internal bool SaveInternal(Guid _uid, IStorage _st, DateTime _now, SessionId _sessionId)
{
ServerXObjectContainer obj;
if (!m_objects.TryGetValue(_uid, out obj))
{
return false;
}
if (obj.Stored == 0 && _uid != GetRootUid())
{
obj.Stored = obj.GetCurrentGeneration(_sessionId);
obj.StoredId = _st.InsertMain(obj.Uid, obj.Kind, _now);
}
var saved = obj.Save(_sessionId, _st, _now, this);
saved = obj.SaveChildren(this, _sessionId, _st, _now) | saved;
OnServerObjectSaved(_uid, _sessionId);
return saved;
}
internal bool SaveChild(Guid _childUid, Guid _ownerUid, SessionId _sessionId, IStorage _storage, int _field,
DateTime _now)
{
if (_ownerUid == GetRootUid())
{
return SaveInternal(_childUid, _storage, _now, _sessionId);
}
ServerXObjectContainer child;
if (!m_objects.TryGetValue(_childUid, out child))
{
//not loaded yet
return false;
}
var saved = false;
if (child.Stored == 0)
{
saved = true;
child.ValidFrom = _now;
child.Stored = 1;
child.StoredId = _storage.InsertMain(child.Uid, child.Kind, _now, _ownerUid, _field);
}
saved = child.Save(_sessionId, _storage, _now, this) | saved;
saved = child.SaveChildren(this, _sessionId, _storage, _now) | saved;
if (saved)
{
OnServerObjectSaved(_childUid, _sessionId);
}
return saved;
}
internal bool Save(Guid _uid, SessionId _sessionId)
{
using (var st = CreateStorage())
{
using (st.CreateTransaction())
{
return SaveInternal(_uid, st, DateTime.Now, _sessionId);
}
}
}
internal IEnumerable<ServerXReport> Redo(Guid _uid, SessionId _sessionId)
{
var dateTime = uint.MaxValue;
var candidates = new List<Guid>();
GetAvailableRedoDate(_uid, _sessionId, this, ref dateTime, ref candidates);
var reports = new List<ServerXReport>();
foreach (var candidateUid in candidates.Distinct())
{
reports.Add(m_objects[candidateUid].Redo(_sessionId));
}
return reports;
}
internal void ClientObjectReverted(Guid _uid, SessionId _sessionId)
{
m_objects[_uid].Revert(_sessionId);
}
internal bool Save(SessionId _sessionId, IStorage _storage, DateTime _now, AbstractXServer _abstractXServer)
{
List<XReport> reports;
if (m_changes.TryGetValue(_sessionId, out reports) && m_currentVersion[_sessionId] >= 0)
{
var reverseItems = new List<AbstractXReportItem>();
var changes = reports[m_currentVersion[_sessionId]];
foreach (var item in changes.Items)
{
IServerXValue xValue;
if (!m_xValues.TryGetValue(item.FieldId, out xValue))
{
xValue = item.CreateXValue();
m_xValues.Add(item.FieldId, xValue);
reverseItems.Add(item.CreateDefaultReportItem());
}
else
{
reverseItems.Add(xValue.CreateReverseReportItem(item));
}
int oldId;
if (m_xValueOldIds.TryGetValue(item.FieldId, out oldId))
{
m_xValueOldIds[item.FieldId] = xValue.SaveOriginalValue(Uid, item, _storage, oldId, _now, _abstractXServer);
}
else
{
m_xValueOldIds[item.FieldId] = xValue.SaveOriginalValue(Uid, item, _storage, null, _now, _abstractXServer);
}
}
reports.Clear();
m_currentVersion[_sessionId] = -1;
ValidFrom = _now;
foreach (var pair in m_changes)
{
if (pair.Key == _sessionId)
{
continue;
}
var reverseReport = new XReport(changes.Uid, reverseItems, changes.Kind, EState.UNDO_ABLE | EState.REVERT_ABLE | (pair.Value.Any()?EState.REDO_ABLE : EState.SINGLE)) { ActualFrom = changes.ActualFrom };
foreach (var xReport in pair.Value)
{
xReport.UpdateAccordingNewValues(m_xValues, reverseReport);
}
pair.Value.Insert(0, reverseReport);
m_currentVersion[pair.Key]++;
}
return true;
}
return false;
}
internal void FillFromClient(XReport _xReport, SessionId _sessionId)
{
Uid = _xReport.Uid;
AddChanges(_sessionId, _xReport);
}
internal UndoXReport Undo(SessionId _sessionId)
{
if (m_currentVersion.ContainsKey(_sessionId))
{
var version = --m_currentVersion[_sessionId];
if (version > -1)
{
var reports = m_changes[_sessionId];
var actual = reports[version];
var last = reports[reports.Count - 1];
return new UndoXReport(Uid, actual.Items, actual.ActualFrom, Kind, EState.UNDO_ABLE|EState.REVERT_ABLE|(last!=actual?EState.REDO_ABLE : EState.SINGLE));
}
}
return new UndoXReport(Uid, Stored, Kind);
}
internal void GetAvailableRedoDate(SessionId _sessionId, AbstractXServer _server,
ref uint _generation, ref List<Guid> _candidates)
{
XReport changes = null;
int version;
if (m_currentVersion.TryGetValue(_sessionId, out version))
{
if (version < m_changes[_sessionId].Count)
{
if (version < m_changes[_sessionId].Count - 1)
{
changes = m_changes[_sessionId][version + 1];
var result = changes.ActualFrom;
if (result < _generation)
{
_candidates.Clear();
_generation = result;
}
if (result == _generation)
{
_candidates.Add(Uid);
}
}
else if (version >= 0)
{
changes = m_changes[_sessionId][version];
}
}
}
var uids = new List<Guid>();
if (changes != null)
{
uids.AddRange(
changes.Items.OfType<XReportList>().SelectMany(_list => _list.Items).Where(
_item => _item.State == EReportListItemState.ADDED).Select(_item => _item.Uid));
}
foreach (var pair in m_xValues)
{
var list = pair.Value as ServerXList;
if (list == null) continue;
uids.AddRange(list.GetGuids());
}
foreach (var uid in uids)
{
_server.GetAvailableRedoDate(uid, _sessionId, _server, ref _generation, ref _candidates);
}
}
internal void AddChanges(SessionId _sessionId, XReport _report)
{
List<XReport> list;
if (!m_changes.TryGetValue(_sessionId, out list))
{
list = new List<XReport>();
m_changes.Add(_sessionId, list);
m_currentVersion.Add(_sessionId, 0);
}
else
{
var version = ++m_currentVersion[_sessionId];
if (version < list.Count)
{
list.RemoveRange(version, list.Count - version);
}
}
list.Add(_report);
}
internal void GetAvailableUndoDate(SessionId _sessionId, AbstractXServer _server,
ref uint _dateTime, ref List<Guid> _candidates)
{
XReport changes = null;
var result = Stored;
int version;
if (m_currentVersion.TryGetValue(_sessionId, out version))
{
if (version >= 0)
{
changes = m_changes[_sessionId][version];
result = changes.ActualFrom;
}
if (result > _dateTime)
{
_candidates.Clear();
_dateTime = result;
}
if (result == _dateTime)
{
_candidates.Add(Uid);
}
}
var uids = new List<Guid>();
if (changes != null)
{
uids.AddRange(
changes.Items.OfType<XReportList>().SelectMany(_list => _list.Items).Where(
_item => _item.State == EReportListItemState.ADDED).Select(_item => _item.Uid));
}
foreach (var pair in m_xValues)
{
var list = pair.Value as ServerXList;
if (list == null) continue;
uids.AddRange(list.GetGuids());
if (changes != null)
{
var pairCopy = pair;
var update = (XReportList) changes.Items.FirstOrDefault(_item => _item.FieldId == pairCopy.Key);
if (update != null)
{
foreach (var item in update.Items)
{
switch (item.State)
{
case EReportListItemState.REMOVED:
uids.Remove(item.Uid);
break;
}
}
}
}
}
foreach (var uid in uids)
{
_server.GetAvailableUndoDate(uid, _sessionId, _server, ref _dateTime, ref _candidates);
}
}
public void Save(Guid _uid, SessionId _sessionId)
{
ServiceContract.Save(_uid, _sessionId);
}
internal ServerXReport GetReport(SessionId _sessionId)
{
var actualFrom = Stored;
List<XReport> reports;
var state = EState.SINGLE;
var items = new List<AbstractXReportItem>();
foreach (var pair in m_xValues)
{
items.Add(pair.Value.GetOriginalValueReportItem(pair.Key, _sessionId));
}
if (m_changes.TryGetValue(_sessionId, out reports))
{
if (m_currentVersion[_sessionId] >= 0)
{
var last = reports[reports.Count - 1];
var actual = reports[m_currentVersion[_sessionId]];
state |= EState.UNDO_ABLE|EState.REVERT_ABLE;
if (last != actual) state |= EState.REDO_ABLE;
var changes = actual;
items.AddRange(changes.Items);
actualFrom = changes.ActualFrom;
}
}
else
{
m_changes.Add(_sessionId, new List<XReport>());
m_currentVersion.Add(_sessionId, -1);
}
var result = new ServerXReport(Uid, items, actualFrom, Kind, state);
return result;
}
private void OnServerObjectSaved(int _kind, Guid _uid, SessionId _sessionId)
{
if (ServerObjectSaved != null)
{
ServerObjectSaved(_kind, _uid, _sessionId);
}
}
internal ServerXReport GetReport(SessionId _sessionId, uint _actualFor)
{
var actualFrom = Stored;
var lastModification = Stored;
var items = new List<AbstractXReportItem>();
List<XReport> reports;
XReport last = null;
if (m_changes.TryGetValue(_sessionId, out reports))
{
last = reports.LastOrDefault(_report => _report.ActualFrom <= _actualFor);
if (last != null)
{
actualFrom = last.ActualFrom;
}
}
else
{
m_changes.Add(_sessionId, new List<XReport>());
m_currentVersion.Add(_sessionId, -1);
}
foreach (var pair in m_xValues)
{
var xName = pair.Key;
items.Add(pair.Value.GetOriginalValueReportItem(xName, _sessionId));
if (last != null)
{
items.AddRange(last.Items.Where(_item => _item.FieldId == xName));
}
}
var result = new ServerXReport(Uid, items, actualFrom, Kind, EState.SINGLE);
return result;
}
public uint AddNew(XReport _xReport, SessionId _sessionId, Guid _parentUid)
{
return ServiceContract.AddNew(_xReport, _sessionId, _parentUid);
}
internal void PrepareToShrink(SessionId _sessionId)
{
if (!ValidTill.HasValue)
{
var report = GetReport(_sessionId);
//m_changes.Clear();
m_currentVersion.Clear();
m_currentVersion[_sessionId] = 0;
m_changes[_sessionId].Add(report);
m_xValueOldIds.Clear();
Stored = 0;
StoredId = 0;
}
}
public void ClientObjectReverted(Guid _uid, SessionId _sessionId)
{
ServiceContract.ClientObjectReverted(_uid, _sessionId);
}
internal ServerXReport Redo(SessionId _sessionId)
{
List<XReport> reports;
if (!m_changes.TryGetValue(_sessionId, out reports)) return null;
var version = ++m_currentVersion[_sessionId];
var actual = reports[version];
var last = reports[reports.Count - 1];
return new ServerXReport(Uid, actual.Items, actual.ActualFrom, Kind, EState.UNDO_ABLE | EState.REVERT_ABLE | (last!=actual ? EState.REDO_ABLE : EState.SINGLE));
}
internal void Revert(SessionId _sessionId)
{
List<XReport> reports;
if (!m_changes.TryGetValue(_sessionId, out reports) || !reports.Any()) return;
reports.Clear();
m_currentVersion[_sessionId] = -1;
}
internal void ClientObjectChanged(XReport _report, SessionId _sessionId)
{
_report.ActualFrom = NextGeneration();
m_objects[_report.Uid].AddChanges(_sessionId, _report);
}
