public override void Deserialize(JObject json, int vercode)
{
if (json == null)
{
return;
}
syncVersion = new SyncVersion(JsonHelper.Get <JObject>(json, "syncVersion"), vercode);
head = JsonHelper.GetFloat(json, "head");
neck = JsonHelper.GetFloat(json, "neck");
shoulderWidth = JsonHelper.GetFloat(json, "shoulderWidth");
body = JsonHelper.GetFloat(json, "body");
hipWidth = JsonHelper.GetFloat(json, "hipWidth");
foreArm = JsonHelper.GetFloat(json, "foreArm");
upperArm = JsonHelper.GetFloat(json, "upperArm");
palm = JsonHelper.GetFloat(json, "palm");
upperLeg = JsonHelper.GetFloat(json, "upperLeg");
lowerLeg = JsonHelper.GetFloat(json, "lowerLeg");
heelHeight = JsonHelper.GetFloat(json, "heelHeight");
footLength = JsonHelper.GetFloat(json, "footLength");
boydHeight = JsonHelper.GetFloat(json, "boydHeight");
bodyHeightSkeleton = JsonHelper.GetFloat(json, "bodyHeightSkeleton");
bodySwingspanSkeleton = JsonHelper.GetFloat(json, "bodySwingspanSkeleton");
}
public ItemChangeMetadata(SyncId itemId, ChangeKind changeKind, SyncVersion creationVersion, SyncVersion changeVersion)
{
ItemId = itemId;
ChangeKind = changeKind;
CreationVersion = creationVersion;
ChangeVersion = changeVersion;
}
private static SyncItem LoadItem(XmlDocument document)
{
SyncItem loadedItem = new SyncItem();
XmlNode itemNode = document.DocumentElement;
loadedItem.ID = XmlUtil.GetAttribute("id", itemNode);
loadedItem.Name = XmlUtil.GetAttribute("name", itemNode);
loadedItem.ParentID = XmlUtil.GetAttribute("parentid", itemNode);
loadedItem.TemplateID = XmlUtil.GetAttribute("tid", itemNode);
loadedItem.MasterID = XmlUtil.GetAttribute("mid", itemNode);
loadedItem.BranchId = XmlUtil.GetAttribute("bid", itemNode);
loadedItem.TemplateName = XmlUtil.GetAttribute("template", itemNode);
SyncVersion loadedVersion = loadedItem.AddVersion(
XmlUtil.GetAttribute("language", itemNode),
XmlUtil.GetAttribute("version", itemNode),
string.Empty);
foreach (XmlNode node in itemNode.SelectNodes("fields/field"))
{
XmlNode content = node.SelectSingleNode("content");
loadedVersion.AddField(
XmlUtil.GetAttribute("tfid", node),
XmlUtil.GetAttribute("key", node),
XmlUtil.GetAttribute("key", node),
content != null ? XmlUtil.GetValue(content) : null,
content != null);
}
return(loadedItem);
}
private static SyncVersion ReadVersion(Tokenizer reader)
{
SyncVersion syncVersion = new SyncVersion();
SyncVersion result;
try
{
Dictionary <string, string> dictionary = ReadHeaders(reader);
syncVersion.Language = dictionary["language"];
syncVersion.Version = dictionary["version"];
syncVersion.Revision = dictionary["revision"];
reader.NextLine();
while (reader.Line == "----field----")
{
SyncField syncField = SyncField.ReadField(reader);
if (syncField != null)
{
syncVersion.Fields.Add(syncField);
}
}
result = syncVersion;
}
catch (Exception innerException)
{
throw new Exception(string.Format("Failed to load version {0} for language {1}", syncVersion.Version, syncVersion.Language), innerException);
}
return(result);
}
private static void GetPendingChanges()
{
if (!PendingChanges.Any())
{
return;
}
var changeSet = PendingChanges.Peek();
if (changeSet != null)
{
var doc = SyncVersion.GetDocumentTypeByCod(changeSet);
// show Progress
var percent = Convert.ToInt32(((double)index++ / (double)changesetsCount) * 100);
ShowProgress(string.Format("{0}% {1}", percent, doc.DocumentName));
if (doc != null)
{
DoSync(doc, changeSet);
PendingChanges.Pop();
}
else
{
//TODO handle null Documents locally.
PendingChanges.Pop();
}
}
if (PendingChanges.Any())
{
GetPendingChanges();
}
}
public static SyncVersion SetFieldValue(this SyncVersion syncVersion, IFieldInfo fieldInfo, string value)
{
SyncField field = syncVersion.Fields.FirstOrDefault(f => f.FieldID == fieldInfo.FieldId);
var fieldIndex = syncVersion.Fields.IndexOf(field);
syncVersion.Fields[fieldIndex].FieldValue = value;
return(syncVersion);
}
public SyncItem UpdateStatistics(SyncItem syncItem)
{
SyncVersion versionToUpdate = GetVersionToUpdate(syncItem);
int index = syncItem.Versions.IndexOf(versionToUpdate);
SyncVersion syncVersion = syncItem.Versions[index];
syncVersion.SetFieldValue(StatisticsTemplateFields.Updated, DateUtil.IsoNowWithTicks);
syncVersion.SetFieldValue(StatisticsTemplateFields.UpdatedBy, _config.CurrentUser);
return(syncItem);
}
/// <summary>
/// SyncVersion to string.
/// </summary>
/// <param name="version">The version.</param>
/// <returns></returns>
private static string SyncVersion2String(SyncVersion version)
{
string retVal = null;
if (version != null)
{
retVal = version.ReplicaKey.ToString() + "." + version.TickCount;
}
return(retVal);
}
public override void Deserialize(JObject json, int vercode)
{
if (json == null)
{
return;
}
syncVersion = new SyncVersion(JsonHelper.Get <JObject>(json, "syncVersion"), vercode);
userBaseInfo = new UserBaseInfo(JsonHelper.Get <JObject>(json, "userBaseInfo"), vercode);
bodyInfo = new BodyInfo(JsonHelper.Get <JObject>(json, "bodyInfo"), vercode);
}
public static void SerializeVersion(TextWriter writer, SyncVersion syncVersion)
{
WriteSplitter("version", writer);
WriteHeader("language", syncVersion.Language, writer);
WriteHeader("version", syncVersion.Version, writer);
WriteHeader("revision", syncVersion.Revision, writer);
writer.WriteLine();
foreach (SyncField current in syncVersion.Fields)
{
SerializeField(writer, current);
}
}
/// <summary>
/// Creates a new version for a content item in a particular language.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="baseVersion">The version to copy off of</param>
/// <param name="context"></param>
/// <returns></returns>
public override int AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
if (!ItemsById.ContainsKey(itemDefinition.ID))
{
return(-1);
}
SyncItem current = ItemsById[itemDefinition.ID];
int num = -1;
Language baseVersionLanguage = baseVersion.Language;
if (Language.Invariant.Equals(baseVersionLanguage))
{
baseVersionLanguage = LanguageManager.DefaultLanguage;
}
if (baseVersion.Version != null && baseVersion.Version.Number > 0)
{
// copy version
SyncVersion matchingVersion = (current.Versions ?? new List <SyncVersion>())
.OrderByDescending(vr => int.Parse(vr.Version))
.FirstOrDefault(vr => vr.Language.Equals(baseVersionLanguage.Name));
int?maxVersionNumber = matchingVersion != null?int.Parse(matchingVersion.Version) : null as int?;
num = maxVersionNumber.HasValue && maxVersionNumber > 0 ? maxVersionNumber.Value + 1 : -1;
if (num > 0)
{
SyncVersion newVersion = current.AddVersion(matchingVersion.Language, num.ToString(),
matchingVersion.Revision);
IList <SyncField> currentFieldValues = matchingVersion.Fields;
foreach (SyncField fieldValue in currentFieldValues)
{
newVersion.AddField(fieldValue.FieldID, fieldValue.FieldName, fieldValue.FieldKey,
fieldValue.FieldValue, true);
}
}
}
if (num == -1)
{
num = 1;
// add blank version
current.AddVersion(baseVersionLanguage.Name, num.ToString(), Guid.NewGuid().ToString());
}
return(num);
}
protected override void UpdateMetadataStoreWithLocalChanges()
{
SyncVersion newVersion = new SyncVersion(0, _metaData.GetNextTickCount());
_metaData.DeleteDetector.MarkAllItemsUnreported();
foreach (SyncTransferData data in _localItems)
{
//Look up an item's metadata by its ID...
ItemMetadata item = _metaData.FindItemMetadataByUniqueIndexedField(URI_COLUMNNAME, data.Uri);
if (item == null)
{
//New item, must have been created since that last time the metadata was updated.
//Create the item metadata required for sync (giving it a SyncID and a version, defined to be a DWORD and a ULONGLONG
//For creates, simply provide the relative replica ID (0) and the tick count for the provider (ever increasing)
SyncGlobalId globalId = new SyncGlobalId(0, Guid.NewGuid());
item = _metaData.CreateItemMetadata(new SyncId(globalId), newVersion);
item.ChangeVersion = newVersion;
item.SetCustomField(URI_COLUMNNAME, data.Uri);
SaveItemMetadata(item);
//Increment sync item counter need for reporting progress info
base.RemainingSessionWorkEstimate++;
}
else
{
if (data.LastModified > item.GetUInt64Field(TIMESTAMP_COLUMNNAME)) // the item has changed since the last sync operation.
{
//Changed Item, this item has changed since the last time the metadata was updated.
//Assign a new version by simply stating "who" modified this item (0 = local/me) and "when" (tick count for the store)
item.ChangeVersion = newVersion;
SaveItemMetadata(item);
//Increment sync item counter need for reporting progress info
base.RemainingSessionWorkEstimate++;
}
else
{
//Unchanged item, nothing has changes so just mark it as live so that the metadata knows it has not been deleted.
_metaData.DeleteDetector.ReportLiveItemById(item.GlobalId);
}
}
}
//Now go back through the items that are no longer in the store and mark them as deleted in the metadata.
//This sets the item as a tombstone.
foreach (ItemMetadata item in _metaData.DeleteDetector.FindUnreportedItems())
{
item.MarkAsDeleted(newVersion);
SaveItemMetadata(item);
}
}
private SyncVersion GetVersionToUpdate(SyncItem syncItem)
{
SyncVersion versionToUpdate = syncItem.Versions.FirstOrDefault(v => _config.DefaultVersion.Equals(v));
if (versionToUpdate != null)
{
versionToUpdate = syncItem.Versions.FirstOrDefault(v => v.Language == _config.DefaultVersion.Language);
if (versionToUpdate != null)
{
versionToUpdate = syncItem.Versions.FirstOrDefault();
}
}
return(versionToUpdate);
}
void UpdateMetadataStoreWithLocalChanges(IEnumerable<MegaNodeHelper> nodes)
{
SyncVersion newVersion = new SyncVersion(0, _metadata.GetNextTickCount());
_metadata.DeleteDetector.MarkAllItemsUnreported();
foreach (var node in nodes)
{
var item = FindItemMetadataByNodeId(node.Node.Id);
if (item == null)
{
item = CreateItemMetadata(new SyncId(new SyncGlobalId(0, Guid.NewGuid())), newVersion);
item.ChangeVersion = newVersion;
SaveItemMetadata(item, node.Node.Id, node.Path);
}
else
{
if (node.Path != item.GetStringField(PATH_COLUMNNAME))
{
if (node.Node.Type == MegaNodeType.Folder)
{
item.MarkAsDeleted(newVersion);
item.ChangeVersion = newVersion;
SaveItemMetadata(item);
var newItem = CreateItemMetadata(new SyncId(new SyncGlobalId(0, Guid.NewGuid())), newVersion);
newItem.ChangeVersion = newVersion;
SaveItemMetadata(newItem, node.Node.Id, node.Path);
}
else
{
//Changed Item, this item has changed since the last time the metadata was updated.
item.ChangeVersion = newVersion;
SaveItemMetadata(item, node.Node.Id, node.Path);
}
}
else
{
//Unchanged item, nothing has changes so just mark it as live so that the metadata knows it has not been deleted.
_metadata.DeleteDetector.ReportLiveItemById(item.GlobalId);
}
}
}
foreach (ItemMetadata item in _metadata.DeleteDetector.FindUnreportedItems())
{
item.MarkAsDeleted(newVersion);
SaveItemMetadata(item);
}
}
//Update the metadata store with changes that have occured on the data store since the last time it was updated.
public void UpdateMetadataStoreWithLocalChanges()
{
SyncVersion newVersion = new SyncVersion(0, _metadata.GetNextTickCount());
_metadata.DeleteDetector.MarkAllItemsUnreported();
foreach (Guid id in _store.Ids)
{
ItemData data = _store.Get(id);
ItemMetadata item = null;
//Look up an item's metadata by its ID...
item = _metadata.FindItemMetadataById(new SyncId(id));
if (null == item)
{
//New item, must have been created since that last time the metadata was updated.
//Create the item metadata required for sync (giving it a SyncID and a version, defined to be a DWORD and a ULONGLONG
//For creates, simply provide the relative replica ID (0) and the tick count for the provider (ever increasing)
item = _metadata.CreateItemMetadata(new SyncId(id), newVersion);
item.ChangeVersion = newVersion;
SaveItemMetadata(item, data.TimeStamp);
_syncItemCount++;
}
else
{
if (data.TimeStamp > item.GetUInt64Field(TIMESTAMP_COLUMNNAME)) // the item has changed since the last sync operation.
{
//Changed Item, this item has changed since the last time the metadata was updated.
//Assign a new version by simply stating "who" modified this item (0 = local/me) and "when" (tick count for the store)
item.ChangeVersion = newVersion;
SaveItemMetadata(item, data.TimeStamp);
_syncItemCount++;
}
else
{
//Unchanged item, nothing has changes so just mark it as live so that the metadata knows it has not been deleted.
_metadata.DeleteDetector.ReportLiveItemById(new SyncId(id));
}
}
}
//Now go back through the items that are no longer in the store and mark them as deleted in the metadata.
//This sets the item as a tombstone.
foreach (ItemMetadata item in _metadata.DeleteDetector.FindUnreportedItems())
{
item.MarkAsDeleted(newVersion);
SaveItemMetadata(item, 0); // set timestamp to 0 for tombstones
}
}
void UpdateMetadataStoreWithLocalChanges(IEnumerable <MegaNodeHelper> nodes)
{
SyncVersion newVersion = new SyncVersion(0, _metadata.GetNextTickCount());
_metadata.DeleteDetector.MarkAllItemsUnreported();
foreach (var node in nodes)
{
var item = FindItemMetadataByNodeId(node.Node.Id);
if (item == null)
{
item = CreateItemMetadata(new SyncId(new SyncGlobalId(0, Guid.NewGuid())), newVersion);
item.ChangeVersion = newVersion;
SaveItemMetadata(item, node.Node.Id, node.Path);
}
else
{
if (node.Path != item.GetStringField(PATH_COLUMNNAME))
{
if (node.Node.Type == MegaNodeType.Folder)
{
item.MarkAsDeleted(newVersion);
item.ChangeVersion = newVersion;
SaveItemMetadata(item);
var newItem = CreateItemMetadata(new SyncId(new SyncGlobalId(0, Guid.NewGuid())), newVersion);
newItem.ChangeVersion = newVersion;
SaveItemMetadata(newItem, node.Node.Id, node.Path);
}
else
{
//Changed Item, this item has changed since the last time the metadata was updated.
item.ChangeVersion = newVersion;
SaveItemMetadata(item, node.Node.Id, node.Path);
}
}
else
{
//Unchanged item, nothing has changes so just mark it as live so that the metadata knows it has not been deleted.
_metadata.DeleteDetector.ReportLiveItemById(item.GlobalId);
}
}
}
foreach (ItemMetadata item in _metadata.DeleteDetector.FindUnreportedItems())
{
item.MarkAsDeleted(newVersion);
SaveItemMetadata(item);
}
}
public SyncVersion BuildSyncVersion()
{
SyncVersion version = new SyncVersion
{
Language = DefaultVersion.Language,
Version = DefaultVersion.Version,
Revision = Guid.NewGuid().ToString()
};
string date = DateUtil.IsoNowWithTicks;
version.AddField(StatisticsTemplateFields.Created, date);
version.AddField(StatisticsTemplateFields.CreatedBy, CurrentUser);
version.AddField(StatisticsTemplateFields.Revision, Guid.NewGuid().ToString());
version.AddField(StatisticsTemplateFields.Updated, date);
version.AddField(StatisticsTemplateFields.UpdatedBy, CurrentUser);
return version;
}
private void MarkAsTombstoneMetadataItem(PrimaryKeyId?eventPk)
{
if (eventPk == null)
{
throw new ArgumentNullException("eventPk");
}
SyncVersion newVersion = GetNewSyncVersion();
ItemMetadata item = Provider.ReplicaMetadata.FindItemMetadataByUniqueIndexedField(SyncReplicaMetadata.URI_COLUMNNAME,
eventPk);
//Если метаданные для данного элемента отсутсвуют то нет необходимости создавать их и помечать как удаленные
if (item != null)
{
item.MarkAsDeleted(newVersion);
Provider.ReplicaMetadata.SaveItemMetadata(item);
}
}
public SyncVersion BuildSyncVersion()
{
SyncVersion version = new SyncVersion
{
Language = DefaultVersion.Language,
Version = DefaultVersion.Version,
Revision = Guid.NewGuid().ToString()
};
string date = DateUtil.IsoNowWithTicks;
version.AddField(StatisticsTemplateFields.Created, date);
version.AddField(StatisticsTemplateFields.CreatedBy, CurrentUser);
version.AddField(StatisticsTemplateFields.Revision, Guid.NewGuid().ToString());
version.AddField(StatisticsTemplateFields.Updated, date);
version.AddField(StatisticsTemplateFields.UpdatedBy, CurrentUser);
return(version);
}
public async Task <IActionResult> Post([FromBody] SyncTodoModel syncData)
{
if (syncData?.SyncTodoItems == null || syncData.SyncTodoItems.Length == 0)
{
return(BadRequest());
}
var userId = User.GetUserId();
var latestVersionId = (await _versionRepository.SelectAsync(1, _ => _.UserId == userId, _ => _.VersionId)).FirstOrDefault()?.VersionId ?? -1;
if (latestVersionId > 0 && latestVersionId > syncData.Version)
{
return(BadRequest(new { Error = "请先同步数据" }));
}
// TODO: 使用 redis 分布式锁，锁当前用户的操作，顺序同步
// 处理 todoItem
var toAddTodoItems = syncData.SyncTodoItems.Where(_ => _.Type == OperationType.Add).Select(_ => _.TodoItem).ToArray();
var todoRepository = HttpContext.RequestServices.GetRequiredService <ITodoItemRepository>();
await todoRepository.InsertAsync(toAddTodoItems);
var toDeleteTodoItemIds = syncData.SyncTodoItems.Where(_ => _.Type == OperationType.Delete).Select(_ => _.TodoItem.TodoId).Distinct().ToList();
await todoRepository.UpdateAsync(todo => toDeleteTodoItemIds.Contains(todo.TodoId), t => t.IsDeleted, true);
var toUpdateItems = syncData.SyncTodoItems.Where(_ => _.Type == OperationType.Update).Select(_ => _.TodoItem).ToArray();
foreach (var item in toUpdateItems)
{
await todoRepository.UpdateAsync(item);
}
var version = new SyncVersion()
{
SyncData = syncData.ToJson(),
UserId = userId,
SyncTime = DateTime.UtcNow
};
await _versionRepository.InsertAsync(version);
return(Ok(new
{
VersionId = version.VersionId
}));
}
public static SyncVersion Clone(this SyncVersion version)
{
Assert.ArgumentNotNull(version, "version");
var newSyncVersion = new SyncVersion
{
Language = version.Language,
Revision = version.Revision,
Version = version.Version
};
foreach (var field in version.Fields)
{
newSyncVersion.AddField(field.FieldID, field.FieldName, field.FieldKey, field.FieldValue, true);
}
return(newSyncVersion);
}
public static SyncVersion Clone(this SyncVersion version)
{
Assert.ArgumentNotNull(version, "version");
var newSyncVersion = new SyncVersion
{
Language = version.Language,
Revision = version.Revision,
Version = version.Version
};
foreach (var field in version.Fields)
{
newSyncVersion.AddField(field.FieldID, field.FieldName, field.FieldKey, field.FieldValue, true);
}
return newSyncVersion;
}
/// <summary>
/// Создает новый объект метаданных элемента, который может быть использован для добавления записи метаданных нового элемента в хранилище метаданных.
/// </summary>
/// <param name="globalId">The global id.</param>
/// <param name="creationVersion">The creation version.</param>
/// <returns></returns>
public override ItemMetadata CreateItemMetadata(SyncId globalId, SyncVersion creationVersion)
{
if (globalId == null || creationVersion == null)
{
throw new ArgumentNullException();
}
if (globalId.IsVariableLength != IdFormats.ItemIdFormat.IsVariableLength ||
globalId.RawId.Length != IdFormats.ItemIdFormat.Length)
{
throw new SyncIdFormatMismatchException("globalId");
}
ItemMetadataAdaptor retVal = ItemMetadataAdaptor.CreateInstance(globalId, ReplicaId);
retVal.CreationVersion = creationVersion;
retVal.ChangeVersion = creationVersion;
return(retVal);
}
/// <summary>
/// Parses the sync version to SyncVersion object example "1.2" "1212.321".
/// </summary>
/// <param name="version">The version.</param>
/// <returns></returns>
private static SyncVersion String2SyncVersion(string version)
{
SyncVersion retVal = SyncVersion.UnknownVersion;
if (!string.IsNullOrEmpty(version))
{
string [] parts = version.Split('.');
try
{
retVal = new SyncVersion(Convert.ToUInt32(parts[0]), Convert.ToUInt64(parts[1]));
}
catch
{
throw new ArgumentException("invalid version");
}
}
return(retVal);
}
internal ItemMetadata CreateItemMetadata(SyncId syncId = null, SyncVersion newVersion = null)
{
var setChangeVersion = false;
if (newVersion == null || syncId == null)
{
newVersion = new SyncVersion(0, _metadata.GetNextTickCount());
syncId = new SyncId(new SyncGlobalId(0, Guid.NewGuid()));
setChangeVersion = true;
}
var result = _metadata.CreateItemMetadata(syncId, newVersion);
if (setChangeVersion)
{
result.ChangeVersion = newVersion;
}
return(result);
}
private ItemMetadata CreateMetadataItem(PrimaryKeyId?eventPk)
{
if (eventPk == null)
{
throw new ArgumentNullException("eventPk");
}
SyncVersion newVersion = GetNewSyncVersion();
//New item, must have been created since that last time the metadata was updated.
//Create the item metadata required for sync (giving it a SyncID and a version, defined to be a DWORD and a ULONGLONG
//For creates, simply provide the relative replica ID (0) and the tick count for the provider (ever increasing)
SyncGlobalId globalId = new SyncGlobalId(0, Guid.NewGuid());
ItemMetadata retVal = Provider.ReplicaMetadata.CreateItemMetadata(new SyncId(globalId), newVersion);
retVal.ChangeVersion = newVersion;
//Set Uri as pk event
retVal.SetCustomField(SyncReplicaMetadata.URI_COLUMNNAME, (Guid)eventPk.Value);
Provider.ReplicaMetadata.SaveItemMetadata(retVal);
return(retVal);
}
private void ChangeVersionMetadataItem(PrimaryKeyId?eventPk)
{
if (eventPk == null)
{
throw new ArgumentNullException("eventPk");
}
ItemMetadata item = Provider.ReplicaMetadata.FindItemMetadataByUniqueIndexedField(SyncReplicaMetadata.URI_COLUMNNAME,
eventPk);
//Если метаданные для данного элемента отсутсвуют то создаем их
//Это может произойти когда реплика была создана при уже существующих calendar events.
if (item == null)
{
CreateMetadataItem(eventPk);
}
else
{
SyncVersion newVersion = GetNewSyncVersion();
item.ChangeVersion = newVersion;
Provider.ReplicaMetadata.SaveItemMetadata(item);
}
}
/// <summary>
/// Builds the version.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="version">The version.</param>
private static void BuildVersion(SyncItem item, Item version)
{
SyncVersion syncVersion = item.AddVersion(version.Language.ToString(), version.Version.ToString(), version.Statistics.Revision);
if (syncVersion == null)
{
return;
}
version.Fields.ReadAll();
version.Fields.Sort();
foreach (Field field in version.Fields)
{
if (TemplateManager.GetTemplate(version).GetField(field.ID) != null && !field.Shared)
{
string fieldValue = GetFieldValue(field);
if (fieldValue != null)
{
syncVersion.AddField(field.ID.ToString(), field.Name, field.Key, fieldValue, true);
}
}
}
}
private static SyncVersion ReadVersion(Tokenizer reader)
{
var version = new SyncVersion();
try
{
var dictionary = SerializationUtils.ReadHeaders(reader);
version.Language = dictionary["language"];
version.Version = dictionary["version"];
version.Revision = dictionary["revision"];
reader.NextLine();
while (reader.Line == FieldLine)
{
SyncField item = ReadField(reader);
if (item != null)
{
version.Fields.Add(item);
}
}
return version;
}
catch (Exception exception)
{
throw new Exception(string.Format("Failed to load version {0} for language {1}", version.Version, version.Language), exception);
}
}
//Update the metadata store with changes that have occured on the data store since the last time it was updated.
public void UpdateMetadataStoreWithLocalChanges()
{
SyncVersion newVersion = new SyncVersion(0, _metadata.GetNextTickCount());
_metadata.DeleteDetector.MarkAllItemsUnreported();
foreach (Guid id in _store.Ids)
{
ItemData data = _store.Get(id);
ItemMetadata item = null;
//Look up an item's metadata by its ID...
item = _metadata.FindItemMetadataById(new SyncId(id));
if (null == item)
{
//New item, must have been created since that last time the metadata was updated.
//Create the item metadata required for sync (giving it a SyncID and a version, defined to be a DWORD and a ULONGLONG
//For creates, simply provide the relative replica ID (0) and the tick count for the provider (ever increasing)
item = _metadata.CreateItemMetadata(new SyncId(id), newVersion);
item.ChangeVersion = newVersion;
SaveItemMetadata(item, data.TimeStamp);
_syncItemCount++;
}
else
{
if (data.TimeStamp > item.GetUInt64Field(TIMESTAMP_COLUMNNAME)) // the item has changed since the last sync operation.
{
//Changed Item, this item has changed since the last time the metadata was updated.
//Assign a new version by simply stating "who" modified this item (0 = local/me) and "when" (tick count for the store)
item.ChangeVersion = newVersion;
SaveItemMetadata(item, data.TimeStamp);
_syncItemCount++;
}
else
{
//Unchanged item, nothing has changes so just mark it as live so that the metadata knows it has not been deleted.
_metadata.DeleteDetector.ReportLiveItemById(new SyncId(id));
}
}
}
//Now go back through the items that are no longer in the store and mark them as deleted in the metadata.
//This sets the item as a tombstone.
foreach (ItemMetadata item in _metadata.DeleteDetector.FindUnreportedItems())
{
item.MarkAsDeleted(newVersion);
SaveItemMetadata(item, 0); // set timestamp to 0 for tombstones
}
}
public BodyInfo()
{
syncVersion = new SyncVersion();
boydHeight = BodyInfoHeight;
}
public override void Deserialize(JObject json, int vercode)
{
if (json == null)
{
return;
}
syncVersion = new SyncVersion(JsonHelper.Get <JObject>(json, "syncVersion"), vercode);
// id = JsonHelper.GetString(json,"id");
email = JsonHelper.GetString(json, "email");
firstName = JsonHelper.GetString(json, "firstName");
lastName = JsonHelper.GetString(json, "lastName");
gender = (GenderEnum)JsonHelper.GetInteger(json, "gender");
firstCode = JsonHelper.GetInteger(json, "firstCode");
country = JsonHelper.GetString(json, "country");
secondCode = JsonHelper.GetInteger(json, "secondCode");
province = JsonHelper.GetString(json, "province");
thirdCode = JsonHelper.GetInteger(json, "thirdCode");
city = JsonHelper.GetString(json, "city");
detailAddress = JsonHelper.GetString(json, "detailAddress");
postCode = JsonHelper.GetString(json, "postCode");
phone = JsonHelper.GetString(json, "phone");
facebook = JsonHelper.GetString(json, "facebook");
twitter = JsonHelper.GetString(json, "twitter");
clubType = JsonHelper.GetString(json, "clubType");
graspClubStyle = JsonHelper.GetBoolean(json, "graspHandStyle");
unitForm = JsonHelper.GetBoolean(json, "unitForm");
userType = (UserType)JsonHelper.GetInteger(json, "userType");
coachID = JsonHelper.GetString(json, "coachID");
//userAgeGroup=(UserAgeGroup)JsonHelper.GetInteger(json,"userAgeGroup");
//userHeightGroup = (UserHeightGroup)JsonHelper.GetInteger(json, "userHeightGroup");
//userWeightGroup = (UserWeightGroup)JsonHelper.GetInteger(json, "userWeightGroup");
//userHDCPGroup = (UserHDCPGroup)JsonHelper.GetInteger(json, "userHDCPGroup");
userAge = JsonHelper.GetString(json, "userAge");
userHeight = JsonHelper.GetString(json, "userHeight");
userWeight = JsonHelper.GetString(json, "userWeight");
userHDCP = JsonHelper.GetString(json, "userHDCP");
//201505280903 ADD
// userInfoState=(UserInfoState)JsonHelper.GetInteger(json,"userInfoState");
userName = JsonHelper.GetString(json, "userName");
passWord = JsonHelper.GetString(json, "passWord");
userAgeEnum = JsonHelper.GetInteger(json, "userAgeEnum");
userHeightEnum = JsonHelper.GetInteger(json, "userHeightEnum");
userWeightEnum = JsonHelper.GetInteger(json, "userWeightEnum");
userHDCPEnum = JsonHelper.GetInteger(json, "userHDCPEnum");
//20160912
isUseBioswing = JsonHelper.GetBoolean(json, "isUseBioswing");
PelvicPivotAxisEnum = JsonHelper.GetInteger(json, "PelvicPivotAxisEnum");
TrailArmActionEnum = JsonHelper.GetInteger(json, "TrailArmActionEnum");
PosturalReleaseEnum = JsonHelper.GetInteger(json, "PosturalReleaseEnum");
LeverDeliveryActionEnum = JsonHelper.GetInteger(json, "LeverDeliveryActionEnum");
DownswingPlaneEnum = JsonHelper.GetInteger(json, "DownswingPlaneEnum");
HipDifferentialEnum = JsonHelper.GetInteger(json, "HipDifferentialEnum");
}
/// <summary>
/// Pastes single version from ItemDom into the item
///
/// </summary>
/// <param name="item">The item.</param>
/// <param name="syncVersion">The sync version.</param>
/// <param name="ignoreMissingTemplateFields">Whether to ignore fields in the serialized item that do not exist on the Sitecore template</param>
/// <param name="creatingNewItem">Whether the item under update is new or not (controls logging verbosity)</param>
/// <returns>The version that was pasted</returns>
protected virtual Item PasteSyncVersion(Item item, SyncVersion syncVersion, bool ignoreMissingTemplateFields, bool creatingNewItem)
{
Language language = Language.Parse(syncVersion.Language);
var targetVersion = global::Sitecore.Data.Version.Parse(syncVersion.Version);
Item languageItem = item.Database.GetItem(item.ID, language);
Item languageVersionItem = languageItem.Versions[targetVersion];
if (languageVersionItem == null)
{
languageVersionItem = languageItem.Versions.AddVersion();
if (!creatingNewItem)
_logger.AddedNewVersion(languageVersionItem);
}
// ReSharper disable once SimplifyLinqExpression
if (!languageVersionItem.Versions.GetVersionNumbers().Any(x => x.Number == languageVersionItem.Version.Number))
{
if (!creatingNewItem)
_logger.AddedNewVersion(languageVersionItem);
}
using (new EditContext(languageVersionItem))
{
languageVersionItem.RuntimeSettings.ReadOnlyStatistics = true;
if (languageVersionItem.Versions.Count == 0)
languageVersionItem.Fields.ReadAll();
foreach (Field field in languageVersionItem.Fields)
{
if (!field.Shared && syncVersion.Fields.All(x => x.FieldID != field.ID.ToString()))
{
_logger.ResetFieldThatDidNotExistInSerialized(field);
field.Reset();
}
}
bool wasOwnerFieldParsed = false;
foreach (SyncField field in syncVersion.Fields)
{
ID result;
if (ID.TryParse(field.FieldID, out result) && result == FieldIDs.Owner)
wasOwnerFieldParsed = true;
PasteSyncField(languageVersionItem, field, ignoreMissingTemplateFields, creatingNewItem);
}
if (!wasOwnerFieldParsed)
languageVersionItem.Fields[FieldIDs.Owner].Reset();
}
ClearCaches(languageVersionItem.Database, languageVersionItem.ID);
ResetTemplateEngineIfItemIsTemplate(languageVersionItem);
return languageVersionItem;
}
public bool Equals(SyncVersion obj)
{
return Language == obj.Language && Version == obj.Version;
}
public static SyncItem AddVersion(this SyncItem syncItem, SyncVersion syncVersion)
{
syncItem.Versions.Add(syncVersion);
return syncItem;
}
/// <summary>
/// Создает новый объект метаданных элемента, который может быть использован для добавления записи метаданных нового элемента в хранилище метаданных.
/// </summary>
/// <param name="globalId">The global id.</param>
/// <param name="creationVersion">The creation version.</param>
/// <returns></returns>
public override ItemMetadata CreateItemMetadata(SyncId globalId, SyncVersion creationVersion)
{
if (globalId == null || creationVersion == null)
{
throw new ArgumentNullException();
}
if (globalId.IsVariableLength != IdFormats.ItemIdFormat.IsVariableLength
|| globalId.RawId.Length != IdFormats.ItemIdFormat.Length)
{
throw new SyncIdFormatMismatchException("globalId");
}
ItemMetadataAdaptor retVal = ItemMetadataAdaptor.CreateInstance(globalId, ReplicaId);
retVal.CreationVersion = creationVersion;
retVal.ChangeVersion = creationVersion;
return retVal;
}
public UserBaseInfo()
{
//id = Utils.GenerateId();
syncVersion = new SyncVersion();
}
internal ItemMetadata CreateItemMetadata(SyncId syncId = null, SyncVersion newVersion = null)
{
var setChangeVersion = false;
if (newVersion == null || syncId == null)
{
newVersion = new SyncVersion(0, _metadata.GetNextTickCount());
syncId = new SyncId(new SyncGlobalId(0, Guid.NewGuid()));
setChangeVersion = true;
}
var result = _metadata.CreateItemMetadata(syncId, newVersion);
if (setChangeVersion) { result.ChangeVersion = newVersion; }
return result;
}
public static SyncVersion AddField(this SyncVersion syncItem, IFieldInfo field, string value)
{
syncItem.AddField(field.FieldId, field.Name, field.Key, value, true);
return(syncItem);
}
private static SyncItem ReadItem(Tokenizer reader, bool assertVersion)
{
SyncItem syncItem = null;
while (reader.Line != null && reader.Line.Length == 0)
{
reader.NextLine();
}
if (reader.Line == null || reader.Line != "----item----")
{
throw new Exception("Format error: serialized stream does not start with ----item----");
}
syncItem = new SyncItem();
Dictionary <string, string> dictionary = ReadHeaders(reader);
syncItem.ID = dictionary["id"];
int num;
if (assertVersion && !string.IsNullOrEmpty(dictionary["version"]) && int.TryParse(dictionary["version"], out num) && SyncItem.FormatVersion < num)
{
throw new Exception(string.Concat(new object[]
{
"The file was generated using a newer version of Serialization. (",
SyncItem.FormatVersion,
" < ",
num,
")"
}));
}
syncItem.ItemPath = dictionary["path"];
SyncItem result;
try
{
syncItem.DatabaseName = dictionary["database"];
syncItem.ParentID = dictionary["parent"];
syncItem.Name = dictionary["name"];
syncItem.BranchId = dictionary["master"];
syncItem.TemplateID = dictionary["template"];
syncItem.TemplateName = dictionary["templatekey"];
reader.NextLine();
while (reader.Line == "----field----")
{
SyncField syncField = SyncField.ReadField(reader);
if (syncField != null)
{
syncItem.SharedFields.Add(syncField);
}
}
while (reader.Line == "----version----")
{
SyncVersion syncVersion = ReadVersion(reader);
if (syncVersion != null)
{
syncItem.Versions.Add(syncVersion);
}
}
result = syncItem;
}
catch (Exception innerException)
{
throw new Exception("Error reading item: " + syncItem.ItemPath, innerException);
}
return(result);
}
