/// <summary>
/// UPDATE
/// </summary>
///
private void UpdateItem(ItemMetadata item, ItemChange change, SaveChangeContext context)
{
var data = (IFileDataRetriever)context.ChangeData;
var attr = _metadataStore.GetItemInfo(item);
var stream = data.FileData.IsDirectory ? null : data.FileStream;
try
{
SyncedNodeAttributes updatedNode = null;
//if pathes are different then consider renaming with unchanged content
if (attr.Path != data.FileData.RelativePath)
{
updatedNode = _nodeStore.MoveFile(attr.Path, data.FileData.RelativePath, attr.Id);
OnAppliedChange(ChangeType.Rename, data.FileData.RelativePath, attr.Path);
}
else
{
updatedNode = _nodeStore.UpdateFile(attr.Path, data.FileData, stream, attr.Id);
OnAppliedChange(ChangeType.Update, data.FileData.RelativePath);
}
item.ChangeVersion = change.ChangeVersion;
_metadataStore.SaveItemMetadata(item, updatedNode.Id, updatedNode.Path);
}
catch (MegaStoreConstraintException e)
{
ProcessConstraint(change, context, e, item, e.Node);
}
catch (MegaStoreException e)
{
ForgetItem(context, item, e);
}
catch (MegaApiException e)
{
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
OnDemandedResync();
}
catch (DirectoryNotFoundException e)
{
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
OnDemandedResync();
}
catch (COMException e)
{
OnDemandedResync();
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
}
finally
{
CloseStream(stream);
}
}
private void SaveItemMetadata(ItemMetadata item)
{
_metadata.SaveItemMetadata(item);
}
/// <summary>
/// CREATE
/// </summary>
private void CreateItem(ItemChange change, SaveChangeContext context, ItemMetadata itemToSaveChanges = null)
{
var data = (IFileDataRetriever)context.ChangeData;
Stream stream = null;
try
{
stream = data.FileData.IsDirectory ? null : data.FileStream;
var createdNode = _nodeStore.InsertNode(data.FileData, data.FileData.RelativePath, stream);
if (itemToSaveChanges == null)
{
itemToSaveChanges = _metadataStore.CreateItemMetadata(change.ItemId, change.CreationVersion);
}
itemToSaveChanges.ChangeVersion = change.ChangeVersion;
_metadataStore.SaveItemMetadata(itemToSaveChanges, createdNode.Id, createdNode.Path);
OnAppliedChange(ChangeType.Create, data.FileData.RelativePath);
}
catch (MegaStoreConstraintException e)
{
ProcessConstraint(change, context, e, null, e.Node);
}
catch (MegaApiException e)
{
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
}
catch (DirectoryNotFoundException e)
{
OnDemandedResync();
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
}
catch (COMException e)
{
OnDemandedResync();
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
}
finally
{
CloseStream(stream);
}
}
private void ProcessConstraint(
ItemChange change,
SaveChangeContext context,
MegaStoreConstraintException e,
ItemMetadata item,
MegaNodeHelper conflictingNode)
{
switch (e.ConstraintType)
{
case MegaStoreConstraintType.TargetExists:
ResolveConflict(item, change, context, conflictingNode);
break;
case MegaStoreConstraintType.NoParent:
OnDemandedResync();
context.RecordConstraintConflictForItem(ConstraintConflictReason.NoParent);
break;
// todo add no-free-space handling
case MegaStoreConstraintType.ZeroSize:
context.RecordConstraintConflictForItem(ConstraintConflictReason.Other);
break;
case MegaStoreConstraintType.NotEmpty:
OnDemandedResync();
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
break;
}
}
private void SaveItemMetadata(ItemMetadata item, UInt64 timeStamp)
{
item.SetCustomField(TIMESTAMP_COLUMNNAME, timeStamp);
// item.SetCustomField(ENTITY_COLUMNNAME, entityType);
SaveItemMetadata(item);
}
private void BackupFile(ItemMetadata item, string path, ItemChange change, SaveChangeContext context)
{
var t = _nodeStore.BackupFile(path);
var newItem = _metadataStore.CreateItemMetadata();
_metadataStore.SaveItemMetadata(newItem, t.Node.Id, t.Path);
if (item == null)
{
CreateItem(change, context);
}
else
{
UpdateItem(item, change, context);
}
}
private void UploadBack(ItemMetadata item, ItemChange change, SaveChangeContext context)
{
//TODO this still re-downloads the file just uploaded
item.ResurrectDeletedItem();
CreateItem(change, context, item);
}
internal SyncedNodeAttributes GetItemInfo(ItemMetadata item)
{
if (item == null) { return null; }
return new SyncedNodeAttributes
{
Path = item.GetStringField(PATH_COLUMNNAME),
Id = item.GetStringField(ID_COLUMNNAME)
};
}
private static void HandleRandomHair(GameSession session, PacketReader packet)
{
int shopId = packet.ReadInt();
bool useVoucher = packet.ReadBool();
BeautyMetadata beautyShop = BeautyMetadataStorage.GetShopById(shopId);
List <BeautyItem> beautyItems = BeautyMetadataStorage.GetGenderItems(beautyShop.ShopId, session.Player.Gender);
if (!HandleShopPay(session, beautyShop, useVoucher))
{
return;
}
// Grab random hair
Random random = RandomProvider.Get();
int indexHair = random.Next(beautyItems.Count);
BeautyItem chosenHair = beautyItems[indexHair];
//Grab a preset hair and length of hair
ItemMetadata beautyItemData = ItemMetadataStorage.GetMetadata(chosenHair.ItemId);
int indexPreset = random.Next(beautyItemData.HairPresets.Count);
HairPresets chosenPreset = beautyItemData.HairPresets[indexPreset];
//Grab random front hair length
double chosenFrontLength = random.NextDouble() *
(beautyItemData.HairPresets[indexPreset].MaxScale - beautyItemData.HairPresets[indexPreset].MinScale) + beautyItemData.HairPresets[indexPreset].MinScale;
//Grab random back hair length
double chosenBackLength = random.NextDouble() *
(beautyItemData.HairPresets[indexPreset].MaxScale - beautyItemData.HairPresets[indexPreset].MinScale) + beautyItemData.HairPresets[indexPreset].MinScale;
// Grab random preset color
ColorPaletteMetadata palette = ColorPaletteMetadataStorage.GetMetadata(2); // pick from palette 2. Seems like it's the correct palette for basic hair colors
int indexColor = random.Next(palette.DefaultColors.Count);
MixedColor color = palette.DefaultColors[indexColor];
Item newHair = new(chosenHair.ItemId)
{
Color = EquipColor.Argb(color, indexColor, palette.PaletteId),
HairData = new((float)chosenBackLength, (float)chosenFrontLength, chosenPreset.BackPositionCoord, chosenPreset.BackPositionRotation, chosenPreset.FrontPositionCoord, chosenPreset.FrontPositionRotation),
IsTemplate = false,
IsEquipped = true,
OwnerCharacterId = session.Player.CharacterId,
OwnerCharacterName = session.Player.Name
};
Dictionary <ItemSlot, Item> cosmetics = session.Player.Inventory.Cosmetics;
//Remove old hair
if (cosmetics.Remove(ItemSlot.HR, out Item previousHair))
{
previousHair.Slot = -1;
session.Player.HairInventory.RandomHair = previousHair; // store the previous hair
DatabaseManager.Items.Delete(previousHair.Uid);
session.FieldManager.BroadcastPacket(EquipmentPacket.UnequipItem(session.Player.FieldPlayer, previousHair));
}
cosmetics[ItemSlot.HR] = newHair;
session.FieldManager.BroadcastPacket(EquipmentPacket.EquipItem(session.Player.FieldPlayer, newHair, ItemSlot.HR));
session.Send(BeautyPacket.RandomHairOption(previousHair, newHair));
}
public void SaveItemMetadata(ItemMetadata item, string id, string path)
{
item.SetCustomField(ID_COLUMNNAME, id);
item.SetCustomField(PATH_COLUMNNAME, path);
SaveItemMetadata(item);
}
public void SaveItemMetadata(ItemMetadata item)
{
_metadata.SaveItemMetadata(item);
}
protected ProviderItem(ItemMetadata createdFolder)
{
this.Identifier = createdFolder.Identifier;
this.ParentIdentifier = createdFolder.ParentIdentifier;
this.Filename = createdFolder.Name;
}
public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context)
{
try
{
UInt64 timeStamp = 0;
ItemMetadata item = null;
ISyncDataObject data = null;
switch (saveChangeAction)
{
case SaveChangeAction.Create:
//Do duplicate detection here
item = _metadata.FindItemMetadataById(change.ItemId);
if (null != item)
{
throw new SyncException("SaveItemChange must not have Create action for existing items.");
}
item = _metadata.CreateItemMetadata(change.ItemId, change.CreationVersion);
item.ChangeVersion = change.ChangeVersion;
data = (ISyncDataObject)context.ChangeData;
//We are using the same id for both the local and global item id.
var version = _syncContext.CreateItem(data, change.ItemId.GetGuidId(), CompanyId, StoreId);
if (version != null)
{
timeStamp = BitConverter.ToUInt64(version, 0);
SaveItemMetadata(item, timeStamp);
}
break;
case SaveChangeAction.UpdateVersionAndData:
case SaveChangeAction.UpdateVersionOnly:
item = _metadata.FindItemMetadataById(change.ItemId);
if (null == item)
{
throw new SyncException("Item Not Found in Store!?");
}
item.ChangeVersion = change.ChangeVersion;
if (saveChangeAction == SaveChangeAction.UpdateVersionOnly)
{
SaveItemMetadata(item);
}
else //Also update the data and the timestamp.
{
data = (ISyncDataObject)context.ChangeData;
timeStamp = BitConverter.ToUInt64(_syncContext.UpdateItem(item.GlobalId.GetGuidId(), data, CompanyId, StoreId), 0);
SaveItemMetadata(item, timeStamp);
}
break;
case SaveChangeAction.DeleteAndStoreTombstone:
item = _metadata.FindItemMetadataById(change.ItemId);
if (null == item)
{
// item = _metadata.CreateItemMetadata(change.ItemId, change.CreationVersion);
return;
}
if (change.ChangeKind == ChangeKind.Deleted)
{
item.MarkAsDeleted(change.ChangeVersion);
}
else
{
// This should never happen in Sync Framework V1.0
throw new SyncException("Invalid ChangeType");
}
item.ChangeVersion = change.ChangeVersion;
SaveItemMetadata(item, timeStamp); // set timestamp to 0 for tombstones
_syncContext.DeleteItem(item.GlobalId.GetGuidId(), CompanyId, StoreId);
break;
//Merge the changes! (Take the data from the local item + the remote item),noting to update the tick count to propagate the resolution!
case SaveChangeAction.UpdateVersionAndMergeData:
item = _metadata.FindItemMetadataById(change.ItemId);
if (null == item)
{
throw new SyncException("Item Not Found in Store!?");
}
if (item.IsDeleted != true)
{
//Note - you must update the change version to propagate the resolution!
item.ChangeVersion = new SyncVersion(0, _metadata.GetNextTickCount());
//Combine the conflicting data...
ISyncDataObject mergedData = _syncContext.Merge(_syncContext.GetItem(item.GlobalId.GetGuidId(), CompanyId, StoreId), (ISyncDataObject)context.ChangeData, CompanyId, StoreId);
timeStamp = BitConverter.ToUInt64(_syncContext.UpdateItem(item.GlobalId.GetGuidId(), mergedData, CompanyId, StoreId), 0);
SaveItemMetadata(item, timeStamp);
}
break;
case SaveChangeAction.DeleteAndRemoveTombstone:
item = _metadata.FindItemMetadataById(change.ItemId);
if (item != null)
{
List <SyncId> ids = new List <SyncId>();
ids.Add(item.GlobalId);
_metadata.RemoveItemMetadata(ids);
}
_syncContext.DeleteItem(change.ItemId.GetGuidId(), CompanyId, StoreId);
break;
}
}
catch (SyncException ex)
{
ILog logger = LogManager.GetLogger(Assembly.GetExecutingAssembly().GetName().Name);
logger.Error(ex.Message, ex);
//do Log
}
catch (DbEntityValidationException ex)
{
ILog logger = LogManager.GetLogger(Assembly.GetExecutingAssembly().GetName().Name);
logger.Error(ex.Message, ex);
//do Log
}
catch (Exception ex)
{
ILog logger = LogManager.GetLogger(Assembly.GetExecutingAssembly().GetName().Name);
logger.Error(ex.Message, ex);
//do Log
}
}
private void SaveItemMetadata(ItemMetadata item)
{
_metadata.SaveItemMetadata(item);
}
/// <summary>
/// DELETE
/// </summary>
private void DeleteItem(ItemMetadata item, ItemChange change, SaveChangeContext context, bool removeTombstone = false)
{
try
{
var attr = _metadataStore.GetItemInfo(item);
_nodeStore.DeleteFile(attr.Path, attr.Id);
OnAppliedChange(ChangeType.Delete, null, attr.Path);
if (removeTombstone)
{
_metadataStore.Metadata.RemoveItemMetadata(new List<SyncId> { item.GlobalId });
}
else
{
item.MarkAsDeleted(change.ChangeVersion);
_metadataStore.SaveItemMetadata(item);
}
}
catch (MegaStoreConstraintException e)
{
ProcessConstraint(change, context, e, item, null);
}
// never mind, the item isn't found anyway
catch (MegaStoreException)
{
if (removeTombstone)
{
_metadataStore.Metadata.RemoveItemMetadata(new List<SyncId> { item.GlobalId });
}
else
{
item.MarkAsDeleted(change.ChangeVersion);
_metadataStore.SaveItemMetadata(item);
}
}
catch (MegaApiException e)
{
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
OnDemandedResync();
}
}
public ItemMetadataWrapper(ItemMetadata meta)
{
_meta = meta;
}
/// <summary>
/// CONFLICT
/// </summary>
private void ResolveConflict(ItemMetadata item, ItemChange change, SaveChangeContext context, MegaNodeHelper conflictingNode)
{
var data = (IFileDataRetriever)context.ChangeData;
// item does not exist in metadata (can happen when create+create)
if (item == null)
{
if (conflictingNode == null)
{
context.RecordRecoverableErrorForItem(new RecoverableErrorData(new Exception()));
}
if (FilesAreEqual(data, conflictingNode))
{
DoNothing(item, change, context, false, conflictingNode);
}
else
{
BackupFile(item, conflictingNode.Path, change, context);
}
return;
}
var attr = _metadataStore.GetItemInfo(item);
try
{
if (change.ChangeKind == ChangeKind.Deleted)
{
// local delete + remote delete
if (item.IsDeleted)
{
DoNothing(item, change, context, true);
}
// local delete + remote update
else
{
DownloadBack(item, change);
}
}
else
{
// local update + remote delete
if (item.IsDeleted)
{
UploadBack(item, change, context);
}
// update + update
else
{
if (FilesAreEqual(data, _nodeStore.FindNodeById(attr.Id)))
{
DoNothing(item, change, context);
}
else
{
BackupFile(item, attr.Path, change, context);
}
}
}
}
catch (MegaApiException e)
{
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
}
}
public override void SaveItemMetadata(ItemMetadata item)
{
ItemMetadataAdaptor entityItemMetaData = ItemMetadataAdaptor.CreateInstance(item);
entityItemMetaData.Save();
}
private void DownloadBack(ItemMetadata item, ItemChange change)
{
item.ChangeVersion = new SyncVersion(change.ChangeVersion.ReplicaKey, GetNextTickCount());
_metadataStore.SaveItemMetadata(item);
}
private void SaveItemMetadata(ItemMetadata item, ulong timeStamp)
{
item.SetCustomField(TIMESTAMP_COLUMNNAME, timeStamp);
SaveItemMetadata(item);
}
private void DoNothing(
ItemMetadata item,
ItemChange change,
SaveChangeContext context,
bool deleted = false,
MegaNodeHelper existingNode = null)
{
// creating
if (item == null)
{
if (existingNode == null)
{
context.RecordRecoverableErrorForItem(new RecoverableErrorData(new Exception()));
}
item = _metadataStore.Metadata.CreateItemMetadata(change.ItemId, change.CreationVersion);
item.ChangeVersion = change.ChangeVersion;
_metadataStore.SaveItemMetadata(item, existingNode.Node.Id, existingNode.Path);
return;
}
if (deleted)
{
item.MarkAsDeleted(change.ChangeVersion);
}
item.ChangeVersion = change.ChangeVersion;
_metadataStore.SaveItemMetadata(item);
}
private void SaveItemMetadata(ItemMetadata item, ulong timeStamp)
{
item.SetCustomField(TIMESTAMP_COLUMNNAME, timeStamp);
SaveItemMetadata(item);
}
// the node is suddenly out, remove it from database
// (it was a concurrency delete attempt - we should restore the existing version)
private void ForgetItem(SaveChangeContext context, ItemMetadata item, Exception e)
{
_metadataStore.Metadata.RemoveItemMetadata(new List<SyncId> { item.GlobalId });
OnDemandedResync();
context.RecordRecoverableErrorForItem(new RecoverableErrorData(e));
}
//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();
var entities = _syncContext.GetSyncObjects(CompanyId, StoreId);
foreach (ISyncDataObject entity in entities)
{
try
{
ISyncDataObject data = entity;
ItemMetadata item = null;
//Look up an item's metadata by its ID...
item = _metadata.FindItemMetadataById(new SyncId(entity.SyncItemId));
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(entity.SyncItemId), newVersion);
item.ChangeVersion = newVersion;
SaveItemMetadata(item, BitConverter.ToUInt64(data.SyncItemVersion, 0));
//var package = data as SyncDataPackage;
//if (package != null)
//{
// item.SetCustomField(PACKAGECOUNT, (UInt32)package.Items.Count);
//}
}
else
{
//var package = data as SyncDataPackage;
//var packageCount = item.GetUInt32Field(PACKAGECOUNT);
if (BitConverter.ToUInt64(data.SyncItemVersion, 0) != 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, BitConverter.ToUInt64(data.SyncItemVersion, 0));
}
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(entity.SyncItemId));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
//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 null for tombstones
}
}