public void OpenStorageUI(StorageObject storageObj)
{
storageCache = storageObj;
storageCache.clientUpdatedDelegate += StorageUpdatedEvent;
PopulateInventorySlots();
SoundManager.PlayAtPosition("Rustle#", PlayerManager.LocalPlayer.transform.position);
}
public void AddEqualObjects()
{
StorageObject obj1 = new StorageObject(1);
StorageObject obj2 = new StorageObject(1);
Assert.False(obj1 == obj2);
Assert.True(_comparer.Equals(obj1, obj2));
long id1 = _store.AddObject(obj1);
long id2 = _store.AddObject(obj2);
Assert.That(id1, Is.EqualTo(id2));
Assert.That(_store.Count, Is.EqualTo(1));
Assert.That(_store.GetObject(id1), Is.EqualTo(obj1));
Assert.That(_comparer.Equals(_store.GetObject(id1), obj2));
_store.RemoveObject(id1);
Assert.That(_store.GetObject(id2), Is.EqualTo(obj1));
Assert.That(_store.Count, Is.EqualTo(1));
_store.RemoveObject(id2);
Assert.Throws <RpcException>(() => _store.GetObject(id2));
Assert.That(_store.Count, Is.EqualTo(0));
}
// void OnEnable()
// {
// StorageObject.OnChestOpen += CheckChest;
// }
// void OnDisable()
// {
// StorageObject.OnChestOpen -= CheckChest;
// }
void CheckChest(StorageObject pChest)
{
if (pChest.UniqueID == ChestID)
{
Event.Invoke();
}
}
public void CanConvertMultipleStorageObjectToJson()
{
var obj = new StorageObject("a/b/c", "TestContainer", DateTime.UtcNow, "12345", 54321, string.Empty,
new Dictionary <string, string>());
var obj2 = new StorageObject("a/b/d", "TestContainer", DateTime.UtcNow, "00000", 11111, string.Empty,
new Dictionary <string, string>());
var converter = new StorageObjectPayloadConverter();
var payload = converter.Convert(new List <StorageObject>()
{
obj, obj2
});
var result = JArray.Parse(payload);
Assert.AreEqual(2, result.Count);
var item = result[0];
Assert.AreEqual("TestContainer/a/b/c", item["path"]);
Assert.AreEqual(54321, item["size_bytes"]);
Assert.AreEqual("12345", item["etag"]);
var item2 = result[1];
Assert.AreEqual("TestContainer/a/b/d", item2["path"]);
Assert.AreEqual(11111, item2["size_bytes"]);
Assert.AreEqual("00000", item2["etag"]);
}
public virtual StorageObjectID Create()
{
Guid internalID;
do
{
internalID = Guid.NewGuid();
}while (usedIDs.Contains(internalID));
usedIDs.Add(internalID);
var id = new StorageObjectID(internalID);
var obj = new StorageObject(this, id);
storage.Add(id, obj);
node_refcount.Add(id, 0);
archivalstates.Add(id, ArchivalState.Unarchived);
arrows_to_sink.Add(id, new Dictionary <string, List <StorageObjectID> >());
arrows_to_source.Add(id, new Dictionary <string, List <StorageObjectID> >());
arrows_to_sink_inverse.Add(id, new Dictionary <StorageObjectID, List <string> >());
arrows_to_source_inverse.Add(id, new Dictionary <StorageObjectID, List <string> >());
Messages.Add(new IOMessage(id, IOEvent.ObjectCreated));
return(id);
}
public void OpenStorageUI(StorageObject storageObj)
{
storageCache = storageObj;
storageCache.clientUpdatedDelegate += StorageUpdatedEvent;
PopulateInventorySlots();
SoundManager.PlayAtPosition("Rustle0" + UnityEngine.Random.Range(1, 6).ToString(), PlayerManager.LocalPlayer.transform.position);
}
public async Task <bool> SetData([FromBody] StorageObject dataObject)
{
bool ok = false;
try
{
if (dataObject == null ||
dataObject.Key == null ||
dataObject.Key.Length == 0 ||
dataObject.Data == null ||
dataObject.Data.Length == 0)
{
return(ok);
}
var task = new Task(() =>
{
ok = DataCache.SetDataObject(dataObject);
});
task.Start();
await task;
}
catch (Exception) {
return(false);
}
return(ok);
}
private void SaveAndLoadObject()
{
var testObject = new StorageObject
{
Number = 26,
String = "Hello World"
};
UnnyNet.Storage.Save(TEST_COLLECTION, TEST_KEY_OBJECT, testObject, saveResponse =>
{
Debug.Log("Save object " + saveResponse.Success);
UnnyNet.Storage.Load <StorageObject>(TEST_COLLECTION, TEST_KEY_OBJECT, loadResponse =>
{
Debug.Log("Load object " + loadResponse.Success);
if (loadResponse.Success)
{
if (loadResponse.Data != null)
{
var loadedObject = loadResponse.Data.Value;
Debug.LogWarning("Loaded Value: number = " + loadedObject.Number + " ; string = " + loadedObject.String);
}
else
{
Debug.LogError("Data is null");
}
}
});
});
}
public void Apply()
{
TargetStorage = GetComponent <StorageObject>();
if (TargetStorage.GetType() == typeof(PlayerInventory))
{
VariableName = "PlayerInventory";
}
else
{
VariableName = "Chest " + TargetStorage.Level + " " + transform.position.x.ToString() + "," + transform.position.y.ToString();
}
// print(VariableName);
int slotAmount = DialogueLua.GetVariable(VariableName + "SlotAmount").asInt;
TargetStorage.Init = DialogueLua.GetVariable(VariableName + "Init").asBool;
for (int i = 0; i < slotAmount; i++)
{
int itemAmount = DialogueLua.GetVariable(VariableName + "StackAmount" + i).asInt;
string itemName = DialogueLua.GetVariable(VariableName + "StackItem" + i).asString;
string itemType = DialogueLua.GetVariable(VariableName + "StackItemType" + i).asString;
ItemSystem.ItemTypes type = (ItemSystem.ItemTypes)System.Enum.Parse(typeof(ItemSystem.ItemTypes), itemType);
ItemBase item = ItemSystem.Instance.GetItemClone(itemName);
int amountAdded = TargetStorage.Add(item, (uint)itemAmount);
int amountLeft = itemAmount - amountAdded;
if (amountLeft > 0)
{
Debug.LogWarning("Saver could not add all items to storage: " + TargetStorage.Name);
}
}
}
/// <summary>
/// Given a path, will create all folders in that path, even if some already exist.
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
/// <exception cref="ApiException"></exception>
public StorageObject CreateAllFoldersInPath(string path)
{
if (string.IsNullOrEmpty(path) | path == "/")
{
throw new ApiException(157, "Invalid path provided, please supply one or more folders to be created");
}
path = path.Trim('/');
if (path.Length > 1024)
{
throw new ApiException(157, "Path length must be less than 1024 characters");
}
var folderPaths = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
StorageObject folderThusFar = null;
var pathThusFar = "/";
foreach (var folderPath in folderPaths)
{
// Try to create the folder
try
{
var createFolder = new CreateFolder(pathThusFar, folderPath);
folderThusFar = _foldersApi.CreateFolder(createFolder);
}
// catch any exceptions
// in the case the folder already exists, we do not want to throw as this is expected
catch (ApiException e)
{
var errorResponse = e.ProblemDetails();
if (!(errorResponse is { Code: 664 }))
private void ShowUI(StorageObject pObj)
{
StorageUI = GameObject.FindObjectOfType <StorageTransferUI>();
StorageUI.Open(pObj);
PixelCrushers.MessageSystem.SendMessage(gameObject, "OpenStorage", UniqueID);
}
private void OnUndo(SampleState state, StorageObject storage)
{
var lastValue = state.HelloString;
state.HelloString = (string)storage.Get("hello");
storage.Set("hello", lastValue);
}
public override async Task <object> Get <T>(T controller, string key)
{
var e = new StorageObject(controller.Alias, key);
var so = await e.GetEntity();
return(so.Deserialize());
}
public static bool GetStorageObject(QueryObject QueryObject, ref StorageObject storageResult)
{
bool ok;
QueueMainObject itemResultMain = null;
ok = DataCache.UserDataCache.TryGetValue(QueryObject.Key, out itemResultMain);
if (ok)
{
bool ok2 = itemResultMain.Queue.TryDequeue(out storageResult);
if (ok2)
{
QueryObject.Status = QueueStatus.Ongoing;
QueryObject.DataObject = storageResult;
}
else
{
QueryObject.Status = QueueStatus.CompleteMayBeDisposed;
}
}
else
{
QueryObject.Status = QueueStatus.CompleteMayBeDisposed;
}
return(ok);
}
private async Task <bool> WriteStorageObject(StorageObject storageObject)
{
var storageObjectJson = Newtonsoft.Json.JsonConvert.SerializeObject(storageObject);
System.IO.File.WriteAllText(_storageOptions.Value.IdentifyFileName, storageObjectJson);
return(true);
}
public void Open(StorageObject pCurrentStorage)
{
StorageUI.CurrentStorage = pCurrentStorage;
StorageUI.Title.text = pCurrentStorage.Name;
PlayerInventoryUI.CurrentStorage = GameManager.Instance.Player.GetComponent <PlayerInventory>();
PlayerInventoryUI.Title.text = PlayerInventoryUI.CurrentStorage.Name;
IsOpen = true;
GetComponent <WindowToggle>().Open();
}
public void Open(StorageObject pStoreInventory, Store pCurrentStore)
{
PlayerInventory = GameManager.Instance.Player.GetComponent <PlayerInventory>();
BasketInventory = GetComponent <StorageObject>();
StoreInventory = pStoreInventory;
CurrentStore = pCurrentStore;
TitleText.text = CurrentStore.Name;
DrawStore();
DrawBasket();
GetComponent <WindowToggle>().Open();
}
public void StorageObject()
{
if (objectToGrab != null)
{
truck.DepositABox(objectToGrab.gameObject);
objectToGrab = null;
truck = null;
isHoldingSomething = false;
isGoingToTruck = false;
}
}
public void CloseStorageUI()
{
storageCache.clientUpdatedDelegate -= StorageUpdatedEvent;
storageCache = null;
for (int i = localSlotCache.Count - 1; i >= 0; i--)
{
InventorySlotCache.Remove(localSlotCache[i]);
Destroy(localSlotCache[i].transform.parent.gameObject);
}
localSlotCache.Clear();
}
public static MediaItem UriToMediaItem(this string uri, StorageObject item)
{
return(new MediaItem
{
Id = uri,
Title = item.Name,
Icon = UmbracoIcons.MediaFile,
HasChildren = false,
PreviewImageUrl = uri,
Selectable = true,
MetaData = item.Metadata
});
}
public Stream GetObjectContent(string bucketName, string objectName)
{
Bucket bucket = getBucket(bucketName, true);
StorageObject obj = _dataContext.FindObject(bucket, objectName);
if (obj == null)
{
throw new ArgumentException($"Object with name {objectName} does not exist");
}
string path = Path.Combine(_fsRoot, bucket.Name, obj.Id);
return(new FileStream(path, FileMode.Open, FileAccess.Read));
}
public override void Start()
{
base.Start();
TargetStorage = GetComponent <StorageObject>();
if (TargetStorage.GetType() == typeof(PlayerInventory))
{
VariableName = "PlayerInventory";
}
else
{
VariableName = "Chest " + TargetStorage.Level + " " + transform.position.x.ToString() + "," + transform.position.y.ToString();
}
}
public void CloseStorageUI()
{
SoundManager.PlayAtPosition("Rustle0" + UnityEngine.Random.Range(1, 6).ToString(), PlayerManager.LocalPlayer.transform.position);
storageCache.clientUpdatedDelegate -= StorageUpdatedEvent;
storageCache = null;
for (int i = localSlotCache.Count - 1; i >= 0; i--)
{
InventorySlotCache.Remove(localSlotCache[i]);
Destroy(localSlotCache[i].transform.parent.gameObject);
}
localSlotCache.Clear();
}
StorageObject GetInventory(string pObjName)
{
GameObject obj = GameObject.Find(pObjName);
if (obj != null)
{
StorageObject storage = obj.GetComponent <StorageObject>();
if (storage != null)
{
return(storage);
}
}
return(null);
}
public static bool SetDataObject(StorageObject dataObject)
{
bool ok;
QueueMainObject ItemResultMain;
ok = DataCache.UserDataCache.TryGetValue(dataObject.Key, out ItemResultMain);
if (!ok)
{
ItemResultMain = CreateKey(dataObject.Key);
ok = DataCache.UserDataCache.TryAdd(dataObject.Key, ItemResultMain);
}
ItemResultMain.Queue.Enqueue(dataObject);
return(ok);
}
public async Task <IHttpActionResult> Create(StorageObject cloudObject)
{
cloudObject.ModifiedOn = cloudObject.CreatedOn = DateTime.UtcNow;
var entity = await AppDatabase.Storage.FindAsync(cloudObject.ObjectId);
if (entity != null)
{
return(BadRequest("ObjectId is in use"));
}
AppDatabase.Storage.Add(cloudObject);
await AppDatabase.SaveChangesAsync();
return(Ok(cloudObject.GetData()));
}
/// <summary>
/// UpdateStorage method updates Storage table and a note value in Notes table if Note hasn't been changed
/// </summary>
/// <param name="storageObject"></param>
/// <param name="userId"></param>
/// <returns>bool</returns>
public bool UpdateStorage(int userId, StorageObject storageObject)
{
//define method execution return value to be false by default
var retMthdExecResult = false;
int distillerId = _dl.GetDistillerId(userId);
if (storageObject != null)
{
try
{
var storRes =
from storRecord in _db.Storage
where storRecord.StorageID == storageObject.StorageId &&
storRecord.DistillerID == distillerId
select storRecord;
var storItem = storRes.FirstOrDefault();
if (storItem.Name != storageObject.StorageName || storageObject.Note != null)
{
storItem.Name = storageObject.StorageName;
}
if (storItem.SerialNumber != storageObject.SerialNumber || storageObject.Note != null)
{
storItem.SerialNumber = storageObject.SerialNumber;
}
if (storItem.Note != storageObject.Note || storageObject.Note != null)
{
storItem.Note = storageObject.Note;
}
_db.SaveChanges();
retMthdExecResult = true;
}
catch (Exception e)
{
Debug.WriteLine("Failed to update Storage Record : " + e);
retMthdExecResult = false;
}
}
return(retMthdExecResult);
}
public void FreeThePlayer()
{
if (objectToInteract != null && isWorking)
{
objectToInteract = null;
EndWork();
influenceArea.transform.localScale *= 0.5f;
GetComponent <CapsuleCollider>().radius = influenceArea.transform.localScale.x / 2;
}
if (objectToGrab != null && !isGoingToBox && !isHoldingSomething)
{
objectToGrab = null;
}
if (objectToGrab != null && isHoldingSomething && !isGoingToTruck)
{
truck = null;
}
}
public async Task <IHttpActionResult> Sync(StorageObject cloudObject)
{
var entity = await AppDatabase.Storage.FindAsync(cloudObject.ObjectId);
// create ?
if (entity == null)
{
return(await Create(cloudObject));
}
// Update if newer
if (entity.ModifiedOn < cloudObject.ModifiedOn)
{
return(await Update(cloudObject));
}
// return old
return(Ok(entity.GetData()));
}
public async Task <IHttpActionResult> Update(StorageObject cloudObject)
{
var entity = await AppDatabase.Storage.FindAsync(cloudObject.ObjectId);
if (entity == null)
{
return(await Create(cloudObject));
}
// ACL
switch (entity.AclType)
{
case StorageACLType.Admin:
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
break;
case StorageACLType.User:
if (UserId != entity.AclParam)
{
return(Unauthorized());
}
break;
}
if (entity.ObjectType != cloudObject.ObjectType)
{
//would cause caching errors
return(BadRequest("Can not change object type"));
}
entity.ModifiedOn = DateTime.UtcNow;
entity.ObjectData = cloudObject.ObjectData;
entity.ObjectScore = cloudObject.ObjectScore;
// Context.Update(entity);
await AppDatabase.SaveChangesAsync();
return(Ok(entity.GetData()));
}
/// <summary>
/// ストレージ オブジェクトをデータ ソース内のデータで更新します。
/// </summary>
/// <param name="refreshMode">更新モードを表す値。</param>
/// <param name="obj">更新するストレージ オブジェクト。</param>
public override void RefreshObject(RefreshMode refreshMode, StorageObject obj)
{
this.Target.RefreshObject(refreshMode, obj);
}
/// <summary>
/// ストレージ オブジェクトをストレージからデタッチします。
/// </summary>
/// <param name="obj">デタッチするストレージ オブジェクト。</param>
public override void DetachObject(StorageObject obj)
{
this.Target.DetachObject(obj);
}
