public async Task <Item> ModifyItem(Guid playerid, Guid itemid, ModifiedItem modifiedItem)
{
Item item = await _repository.GetItem(playerid, itemid);
item._Name = modifiedItem._Name;
return(await _repository.ModifyItem(playerid, itemid, item));
}
public async Task <Item> Modify(Guid playerId, Guid itemid, ModifiedItem item)
{
Player player = await this.GetPlayer(playerId);
Item newItem = new Item();
newItem.Level = item.Level;
newItem.ItemType = item.ItemType;
Item[] itemList = player.Items.ToArray();
for (int i = 0; i < itemList.Count(); i++)
{
if (itemList[i].ItemID == itemid)
{
newItem.ItemID = itemList[i].ItemID;
newItem.CreationDate = itemList[i].CreationDate;
itemList[i] = newItem;
}
}
player.Items = itemList.ToList();
await _collection.ReplaceOneAsync(Builders <Player>
.Filter.Eq("_id", playerId), player);
return(newItem);
}
private static void AddADObject(ModifiedItem item)
{
var oguObject = item.OguObjectData;
string[] rdns = SynchronizeHelper.GetOguObjectRdns(oguObject);
string parentDN = string.Join(",", rdns, 1, rdns.Length - 1);
ADHelper adHelper = SynchronizeContext.Current.ADHelper;
using (DirectoryEntry parentEntry = parentDN.IsNullOrEmpty() ? adHelper.GetRootEntry() : adHelper.NewEntry(parentDN))
{
parentEntry.ForceBound();
using (DirectoryEntry newEntry = WhatEverNewEntry(oguObject, parentEntry))
{
ObjectSetterHelper.Convert(ObjectModifyType.Add, oguObject, newEntry);
//item.ADObjectData = SynchronizeHelper.GetSearchResultByID(newEntry.NativeGuid, newEntry.ToADSchemaType()).ToADOjectWrapper();
if (SynchronizeContext.Current.IDMapper.NewIDMappingDictionary.ContainsKey(oguObject.ID) &&
SynchronizeContext.Current.IDMapper.NewIDMappingDictionary[oguObject.ID] == null)
{
SynchronizeContext.Current.IDMapper.NewIDMappingDictionary[oguObject.ID] = new IDMapping()
{
SCObjectID = oguObject.ID,
ADObjectGuid = newEntry.NativeGuid,
LastSynchronizedVersionTime = (DateTime)oguObject.Properties["VERSION_START_TIME"]
};
}
}
}
}
public async Task <Item> UpdateItem(Guid playerId, Guid itemId, [FromBody] ModifiedItem item)
{
Item i = new Item();
i.Level = item.Level;
return(await _repository.UpdateItem(playerId, itemId, i));
}
public async Task <Item> Update(Guid playerId, Guid id, ModifiedItem modifiedItem)
{
Item item = await _repository.GetItem(playerId, id);
item.Price = modifiedItem.Price;
await _repository.UpdateItem(playerId, item);
return(item);
}
public async Task <Item> ModifyItem(Guid playerId, Guid itemId, ModifiedItem item)
{
Item i = new Item
{
Value = item.Value
};
return(await _mongoDBRepository.UpdateItem(playerId, itemId, i));
}
public async Task <Item> ModifyItem(Guid id, ModifiedItem modifiedItem)
{
FilterDefinition <Item> filter = Builders <Item> .Filter.Eq("Id", id);
var i = await _items.Find(filter).FirstAsync();
await _items.ReplaceOneAsync(filter, i);
return(i);
}
private static void ModifyADObjectProperties(ObjectModifyType modifyType, ModifiedItem item)
{
IOguObject oguObject = item.OguObjectData;
ADObjectWrapper adObject = item.ADObjectData;
using (DirectoryEntry entry = SynchronizeHelper.GetSearchResultByID(SynchronizeContext.Current.ADHelper, adObject.NativeGuid, (ADSchemaType)oguObject.ObjectType).GetDirectoryEntry())
{
entry.ForceBound();
ObjectSetterHelper.Convert(modifyType, oguObject, entry);
}
}
public async Task <Item> Modify(Guid id, ModifiedItem item)
{
Item i;
if (_items.TryGetValue(id, out i))
{
i.Name = item.Name;
i.Lvl = item.Lvl;
}
return(null);
}
public Task <Item> UpdateItem(Guid playerId, Guid itemId, ModifiedItem modifiedItem)
{
Item newItem = new Item()
{
Id = itemId,
Level = modifiedItem.Level,
Type = modifiedItem.Type,
CreationDate = DateTime.Today
};
return(_repo.UpdateItem(playerId, newItem));
}
public async Task <Item> ModifyItem(Guid id, ModifiedItem item)
{
for (int i = 0; i < itemList.Count; i++)
{
if (itemList[i].Id == id)
{
itemList[i].Level = item.Level;
return(itemList[i]);
}
}
return(null);
}
public async Task <Item> Update(Guid playerId, [FromBody] ModifiedItem modifiedItem)
{
Item item = new Item();
item.Price = modifiedItem.Price;
try{
await repository.UpdateItem(playerId, item);
}
catch {
throw new NotFoundException();
}
return(item);
}
public async Task <Item> ModifyItem(Guid playerId, Guid id, ModifiedItem item)
{
var filter = Builders <Player> .Filter.Where(x => x.Id == playerId && x.Items.Any(it => it.Id == id));
var update = Builders <Player> .Update.Set(x => x.Items[-1].Level, item.Level);
var player = await PlayerCollection.FindOneAndUpdateAsync(filter, update);
var i = player.Items.Single(x => x.Id == id);
i.Level = item.Level;
return(i);
}
public async Task <Item> UpdateItem(Guid id, Guid itemId, ModifiedItem item)
{
FilterDefinition <Player> filter = Builders <Player> .Filter.Eq("_id", id);
Player p1 = await _collection.Find(filter).FirstAsync();
Item i1 = p1.Items.Find(Item => Item.Id == itemId);
i1.Level = item.Level;
await _collection.ReplaceOneAsync(filter, p1);
return(i1);
}
public ActionResult <Task <Item> > ModifyItem(Guid id, Guid itemId, int level)
{
ModifiedItem modIt = new ModifiedItem();
modIt._level = level;
modIt._itemId = itemId;
TryValidateModel(modIt);
if (ModelState.IsValid)
{
return(itProcessor.ModifyItem(id, modIt, itemId));
}
else
{
return(null);
}
}
private static void ApplyModify(ModifiedItem item)
{
try
{
if ((item.ModifyType & ObjectModifyType.Delete) == ObjectModifyType.Delete)
{
// 只要有删除动作，则不做其它动作
SynchronizeContext.Current.IncreaseDeleteItemCount(() => DeleteADObject(ObjectModifyType.Delete, item.OguObjectData, item.ADObjectData));
}
else if ((item.ModifyType & ObjectModifyType.Add) == ObjectModifyType.Add)
{
SynchronizeContext.Current.IncreaseAddItemCount(() => AddADObject(item));
if ((item.ModifyType & ObjectModifyType.PropertyModified) == ObjectModifyType.PropertyModified)
{
SynchronizeContext.Current.IncreaseModifyItemCount(() => ModifyADObjectProperties(ObjectModifyType.PropertyModified, item));
}
}
else
{
if ((item.ModifyType & ObjectModifyType.PropertyModified) == ObjectModifyType.PropertyModified)
{
SynchronizeContext.Current.IncreaseModifyItemCount(() => ModifyADObjectProperties(ObjectModifyType.PropertyModified, item));
}
if ((item.ModifyType & ObjectModifyType.MissingMarker) == ObjectModifyType.MissingMarker)
{
ModifyADObjectProperties(ObjectModifyType.MissingMarker, item);
}
// if ((item.ModifyType & ObjectModifyType.ChildrenModified) == ObjectModifyType.ChildrenModified)
// SynchronizeContext.Current.IncreaseModifyItemCount(() => ModifyADGroupChildren(ObjectModifyType.ChildrenModified, item));
}
}
catch (Exception ex)
{
SynchronizeContext.Current.ExceptionCount++;
LogHelper.WriteSynchronizeDBLogDetail(SynchronizeContext.Current.SynchronizeID, "应用变更:" + item.ModifyType,
item.OguObjectData == null ? string.Empty : item.OguObjectData.ID,
item.OguObjectData == null ? string.Empty : item.OguObjectData.Name,
item.ADObjectData == null ? string.Empty : item.ADObjectData.NativeGuid.ToString(),
item.ADObjectData == null ? string.Empty : item.ADObjectData.DN, ex.GetRealException().ToString());
}
}
public async Task <Item> UpdateItem(Guid playerId, Guid itemId, ModifiedItem item)
{
var filter = Builders <Player> .Filter.Eq(p => p.Id, playerId);
Player player = await _playerCollection.Find(filter).FirstAsync();
for (int i = 0; i < player.itemList.Count; i++)
{
if (player.itemList[i].itemId == itemId)
{
player.itemList[i].level = item.level;
await _playerCollection.ReplaceOneAsync(filter, player);
return(player.itemList[i]);
}
}
return(null);
}
public async Task <Item> ModifyItem(ObjectId id, ModifiedItem item, ObjectId playerId)
{
var db = dbClient.GetDatabase("game");
var players = db.GetCollection <Player>("players");
var filter = Builders <Player> .Filter.Eq("id", playerId);
var result = players.Find(filter).SingleOrDefault();
for (int i = 0; i < result.ItemList.Count; i++)
{
if (result.ItemList[i].id == id)
{
result.ItemList[i].Level = item.Level;
return(result.ItemList[i]);
}
}
return(null);
}
public static ModifiedItem GetPKValues(ModifiedItem modifiedItem, List <Header_Datatype> Headers_Datatypes, string[] ItemValues)
{
if (Headers_Datatypes.Count != ItemValues.Length)
{
throw new System.ArgumentException("Headers count and values count are not equal", "Headers_Datatypes");
}
modifiedItem.PrimaryKeysValues = new List <string>(new string[modifiedItem.PrimaryKeysHeaders.Count]);
for (int i = 0; i < Headers_Datatypes.Count; i++)
{
for (int j = 0; j < modifiedItem.PrimaryKeysHeaders.Count; j++)
{
if (modifiedItem.PrimaryKeysHeaders[j].Equals(Headers_Datatypes[i].Header))
{
modifiedItem.PrimaryKeysValues[j] = ItemValues[i];
}
}
}
return(modifiedItem);
}
public async Task <Item> UpdateItem(Guid playerId, Guid itemId, ModifiedItem item)
{
Ratkaisija players = await ReadFile();
for (int i = 0; i < players.playerLista.Count; i++)
{
if (players.playerLista[i].Id == playerId)
{
for (int j = 0; j < players.playerLista[i].itemList.Count; j++)
{
if (players.playerLista[i].itemList[j].itemId == itemId)
{
players.playerLista[i].itemList[j].level = item.level; // tässä nyt on päätetty että updateitemilla muutetaan itemin leveliä
File.WriteAllText("game-dev.txt", JsonConvert.SerializeObject(players));
return(players.playerLista[i].itemList[j]);
}
}
}
}
return(null);
}
public async Task <Item> ModifyItem(Guid id, ModifiedItem modifiedItem)
{
int index = -1;
for (int i = 0; i < items.Count; ++i)
{
if (items[i].Id == id)
{
index = i;
}
}
if (index >= 0)
{
items[index].OwnerId = modifiedItem.OwnerId;
return(items[index]);
}
else
{
return(null);
}
}
public async Task <Item> ModifyItem(Guid playerid, Guid id, ModifiedItem item)
{
var filter = Builders <Player> .Filter.Eq("Id", playerid);
var cursor = await coll.FindAsync(filter);
Player player = cursor.First();
foreach (Item item2 in player.items)
{
if (item2.Id == id)
{
if (item2 != null)
{
item2.Level = item.Level;
await coll.FindOneAndReplaceAsync(filter, player);
}
return(item2);
}
}
return(null);
}
public async Task <Item> UpdateItem(Guid playerId, Guid itemId, ModifiedItem item)
{
PlayerListHolder players = await ReadFile();
for (int i = 0; i < players.playerList.Count; i++)
{
if (players.playerList[i].Id == playerId)
{
for (int j = 0; j < players.playerList[i].itemList.Count; j++)
{
if (players.playerList[i].itemList[j].itemId == itemId)
{
players.playerList[i].itemList[j].level = item.Level;
File.WriteAllText("game-dev.txt", JsonConvert.SerializeObject(players));
return(players.playerList[i].itemList[j]);
}
}
}
}
return(null);
}
public async Task <Item> UpdateItem(Guid playerId, Guid itemId, [FromBody] ModifiedItem item)
{
return(await _repository.UpdateItem(playerId, itemId, item));
}
public async Task<Item> ModifyItem(Guid playerId, Guid id, ModifiedItem item) {
Item i = await GetItem(playerId, id);
i.Level = item.Level;
return i;
}
private static void ModifyADGroupChildren(ObjectModifyType modifyType, ModifiedItem item)
{
ADHelper adHelper = SynchronizeContext.Current.ADHelper;
IOguObject oguObject = item.OguObjectData;
ADObjectWrapper adObject = item.ADObjectData;
using (DirectoryEntry entry = SynchronizeHelper.GetSearchResultByID(adHelper, adObject.NativeGuid, ADSchemaType.Groups).GetDirectoryEntry())
{
entry.ForceBound();
ObjectSetterHelper.Convert(modifyType, oguObject, entry);
}
}
private static void AddADObject(ModifiedItem item)
{
var oguObject = item.OguObjectData;
string[] rdns = SynchronizeHelper.GetOguObjectRdns(oguObject);
string parentDN = string.Join(",", rdns, 1, rdns.Length - 1);
ADHelper adHelper = SynchronizeContext.Current.ADHelper;
using (DirectoryEntry parentEntry = parentDN.IsNullOrEmpty() ? adHelper.GetRootEntry() : adHelper.NewEntry(parentDN))
{
parentEntry.ForceBound();
using (DirectoryEntry newEntry = WhatEverNewEntry(oguObject, parentEntry))
{
ObjectSetterHelper.Convert(ObjectModifyType.Add, oguObject, newEntry);
//item.ADObjectData = SynchronizeHelper.GetSearchResultByID(newEntry.NativeGuid, newEntry.ToADSchemaType()).ToADOjectWrapper();
if (SynchronizeContext.Current.IDMapper.NewIDMappingDictionary.ContainsKey(oguObject.ID) &&
SynchronizeContext.Current.IDMapper.NewIDMappingDictionary[oguObject.ID] == null)
{
SynchronizeContext.Current.IDMapper.NewIDMappingDictionary[oguObject.ID] = new IDMapping()
{
SCObjectID = oguObject.ID,
ADObjectGuid = newEntry.NativeGuid,
LastSynchronizedVersionTime = (DateTime)oguObject.Properties["VERSION_START_TIME"]
};
}
}
}
}
private static void ApplyModify(ModifiedItem item)
{
try
{
if ((item.ModifyType & ObjectModifyType.Delete) == ObjectModifyType.Delete)
{
// 只要有删除动作，则不做其它动作
SynchronizeContext.Current.IncreaseDeleteItemCount(() => DeleteADObject(ObjectModifyType.Delete, item.OguObjectData, item.ADObjectData));
}
else if ((item.ModifyType & ObjectModifyType.Add) == ObjectModifyType.Add)
{
SynchronizeContext.Current.IncreaseAddItemCount(() => AddADObject(item));
if ((item.ModifyType & ObjectModifyType.PropertyModified) == ObjectModifyType.PropertyModified)
SynchronizeContext.Current.IncreaseModifyItemCount(() => ModifyADObjectProperties(ObjectModifyType.PropertyModified, item));
}
else
{
if ((item.ModifyType & ObjectModifyType.PropertyModified) == ObjectModifyType.PropertyModified)
SynchronizeContext.Current.IncreaseModifyItemCount(() => ModifyADObjectProperties(ObjectModifyType.PropertyModified, item));
if ((item.ModifyType & ObjectModifyType.MissingMarker) == ObjectModifyType.MissingMarker)
ModifyADObjectProperties(ObjectModifyType.MissingMarker, item);
// if ((item.ModifyType & ObjectModifyType.ChildrenModified) == ObjectModifyType.ChildrenModified)
// SynchronizeContext.Current.IncreaseModifyItemCount(() => ModifyADGroupChildren(ObjectModifyType.ChildrenModified, item));
}
}
catch (Exception ex)
{
SynchronizeContext.Current.ExceptionCount++;
LogHelper.WriteSynchronizeDBLogDetail(SynchronizeContext.Current.SynchronizeID, "应用变更:" + item.ModifyType,
item.OguObjectData == null ? string.Empty : item.OguObjectData.ID,
item.OguObjectData == null ? string.Empty : item.OguObjectData.Name,
item.ADObjectData == null ? string.Empty : item.ADObjectData.NativeGuid.ToString(),
item.ADObjectData == null ? string.Empty : item.ADObjectData.DN, ex.GetRealException().ToString());
}
}
public async Task <Item> ModifyItem(Guid id, ModifiedItem item)
{
throw new NotImplementedException();
}
public Task <Item> Update(Guid playerId, Guid id, /*[FromBody]*/ ModifiedItem item)
{
return(_processor.Update(playerId, id, item));
}
public async Task <Item> Modify(string id, [FromBody] ModifiedItem item)
{
Guid _id = new Guid(id);
return(await _processor.Modify(_id, item));
}
private async void Modified(string Path)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async() =>
{
try
{
await Locker.WaitAsync();
try
{
if (CurrentLocation == System.IO.Path.GetDirectoryName(Path))
{
if (await FileSystemStorageItemBase.OpenAsync(Path) is FileSystemStorageItemBase ModifiedItem)
{
PathConfiguration Config = await SQLite.Current.GetPathConfigurationAsync(CurrentLocation);
if (CurrentCollection.FirstOrDefault((Item) => Item.Path.Equals(Path, StringComparison.OrdinalIgnoreCase)) is FileSystemStorageItemBase OldItem)
{
if (ModifiedItem.GetType() == OldItem.GetType())
{
await OldItem.RefreshAsync();
}
else
{
CurrentCollection.Remove(OldItem);
if (!SettingControl.IsDisplayProtectedSystemItems || !ModifiedItem.IsSystemItem)
{
if ((ModifiedItem is IHiddenStorageItem && SettingControl.IsDisplayHiddenItem) || ModifiedItem is not IHiddenStorageItem)
{
if (CurrentCollection.Any())
{
int Index = SortCollectionGenerator.SearchInsertLocation(CurrentCollection, ModifiedItem, Config.SortTarget.GetValueOrDefault(), Config.SortDirection.GetValueOrDefault());
if (Index >= 0)
{
CurrentCollection.Insert(Index, ModifiedItem);
}
else
{
CurrentCollection.Add(ModifiedItem);
}
}
else
{
CurrentCollection.Add(ModifiedItem);
}
}
}
}
}
else if (ModifiedItem is not IHiddenStorageItem)
{
if (CurrentCollection.Any())
{
int Index = SortCollectionGenerator.SearchInsertLocation(CurrentCollection, ModifiedItem, Config.SortTarget.GetValueOrDefault(), Config.SortDirection.GetValueOrDefault());
if (Index >= 0)
{
CurrentCollection.Insert(Index, ModifiedItem);
}
else
{
CurrentCollection.Add(ModifiedItem);
}
}
else
{
CurrentCollection.Add(ModifiedItem);
}
}
}
}
}
finally
{
Locker.Release();
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"{ nameof(StorageAreaWatcher)}: Modify item in collection failed");
}
});
public Task <Item> Modify(Guid playerId, Guid itemId, ModifiedItem item)
{
return(_processor.Modify(playerId, itemId, item));
}
public void PrepareAndAddModifiedItem(IOguObject oguObject, ADObjectWrapper adObject, ObjectModifyType objectModifyType)
{
ModifiedItem item = new ModifiedItem() { OguObjectData = oguObject, ADObjectData = adObject, ModifyType = objectModifyType };
if (oguObject.ObjectType == SchemaType.Groups)
{
this.ModifiedGroupItems.Add(item);
}
else
{
this.ModifiedOuAndUserItems.Add(item);
}
}
