/// <summary> /// Delete an item from the user's inventory /// /// If the inventory service has not yet delievered the inventory /// for this user then the request will be queued. /// </summary> /// <param name="item"></param> /// <returns> /// true on a successful delete or a if the request is queued. /// Returns false on an immediate failure /// </returns> public bool DeleteItem(InventoryItemBase item) { IInventoryProviderSelector selector = ProviderRegistry.Instance.Get <IInventoryProviderSelector>(); IInventoryStorage provider = selector.GetProvider(item.Owner); provider.PurgeItem(item); return(true); }
/// <summary> /// Find an appropriate folder for the given asset type /// </summary> /// <param name="type"></param> /// <returns>null if no appropriate folder exists</returns> public InventoryFolderBase FindFolderForType(int type) { InventoryFolderBase bestFolderForType; lock (_folderTypeCache) { _folderTypeCache.TryGetValue(type, out bestFolderForType); if (bestFolderForType != null) { return(bestFolderForType); } } IInventoryProviderSelector inventorySelect = ProviderRegistry.Instance.Get <IInventoryProviderSelector>(); IInventoryStorage provider = inventorySelect.GetProvider(m_userProfile.ID); try { bestFolderForType = provider.FindFolderForType(m_userProfile.ID, (AssetType)type); } catch { } if (bestFolderForType == null) { //next best folder will be the user root folder, it has to exist try { bestFolderForType = provider.FindFolderForType(m_userProfile.ID, (AssetType)FolderType.Root); } catch { } if (bestFolderForType == null) { throw new InventoryStorageException( String.Format("Can not retrieve a destination folder for types, user {0} has no root folder", m_userProfile.ID)); } } lock (_folderTypeCache) { if (_folderTypeCache.ContainsKey(type)) { _folderTypeCache[type] = bestFolderForType; } else { _folderTypeCache.Add(type, bestFolderForType); } } return(bestFolderForType); }
public InventoryActor(IInventoryStorage inventoryStorage, IPerformanceService performanceService, IBackUpService backUpService, bool withCache = true) { if (backUpService == null) { throw new ArgumentNullException(nameof(backUpService)); } BackUpService = backUpService; PerformanceService = performanceService; PerformanceService.Init(); Logger.Debug("Starting Inventory Actor ...."); InventoryStorage = inventoryStorage; _withCache = withCache; Become(Initializing); }
public GroupDisplayData GroupDisplayDataFromSOG(UUID userId, GroupLoader.LoaderParams parms, SceneObjectGroup sog, IInventoryStorage inv, string userName, InventoryItemBase item) { if (((parms.Checks & LoaderChecks.PrimLimit) != 0) && sog.GetParts().Count > parms.PrimLimit) { throw new Exceptions.PrimExporterPermissionException("Object contains too many prims"); } HashSet <UUID> fullPermTextures = CollectFullPermTexturesIfNecessary(ref userId, parms, inv); PrimDisplayData rootPrim = null; List <PrimDisplayData> groupData = new List <PrimDisplayData>(); foreach (SceneObjectPart part in sog.GetParts()) { if (((parms.Checks & LoaderChecks.UserMustBeCreator) != 0) && part.CreatorID != userId) { throw new Exceptions.PrimExporterPermissionException("You are not the creator of all parts"); } PrimDisplayData pdd = this.ExtractPrimMesh(part, parms, fullPermTextures); if (pdd == null) { throw new NullReferenceException("Prim mesh could not be loaded"); } groupData.Add(pdd); if (pdd.IsRootPrim) { rootPrim = pdd; } } //assign parent to all prims foreach (var part in groupData) { if (!part.IsRootPrim) { part.Parent = rootPrim; } } //sort prims by link number var sortedPrims = groupData.OrderBy(g => g.LinkNum); return(new GroupDisplayData { Prims = sortedPrims, RootPrim = rootPrim, CreatorName = userName, ObjectName = sog.Name }); }
private IActorRef GetActorRef(IInventoryStorage inventoryStorage, string productId, IPerformanceService performanceService) { if (_products.ContainsKey(productId)) { return(_products[productId]); } Logger.Debug("Creating inventory actor " + productId + " since it does not yet exist ..."); var productActorRef = Context.ActorOf( Props.Create(() => new ProductInventoryActor(inventoryStorage, NotificationActorRef, productId, _withCache, performanceService)) , productId); _products.Add(productId, productActorRef); return(_products[productId]); }
// Searches the parentage tree for an ancestor folder with a matching type (e.g. Trash) public InventoryFolderBase FindTopLevelFolderFor(UUID folderID) { IInventoryProviderSelector inventorySelect = ProviderRegistry.Instance.Get <IInventoryProviderSelector>(); IInventoryStorage provider = inventorySelect.GetProvider(m_userProfile.ID); InventoryFolderBase folder; try { folder = provider.FindTopLevelFolderFor(m_userProfile.ID, folderID); } catch { folder = null; } return(folder); }
private void CollectCreatedAssetIdsFromUserInventory(UUID creatorId, C5.HashSet <UUID> retAssets) { IInventoryProviderSelector selector = ProviderRegistry.Instance.Get <IInventoryProviderSelector>(); IInventoryStorage provider = selector.GetProvider(creatorId); List <InventoryFolderBase> skel = provider.GetInventorySkeleton(creatorId); foreach (InventoryFolderBase folder in skel) { InventoryFolderBase fullFolder = provider.GetFolder(folder.ID); foreach (InventoryItemBase item in fullFolder.Items) { if (m_allowedCreatorIds.Contains(item.CreatorIdAsUuid)) { retAssets.Add(item.AssetID); } } } }
public ProductInventoryActor(IInventoryStorage inventoryStorage, IActorRef InventoryQueryActorRef, string id, bool withCache, IPerformanceService performanceService) { PerformanceService = performanceService; _id = id; _withCache = withCache; InventoryStorage = inventoryStorage; RealTimeInventory = RealTimeInventory.InitializeFromStorage(InventoryStorage, id); NotificationActorRef = InventoryQueryActorRef; ReceiveAsync <GetInventoryMessage>(async message => { if (!CanProcessMessage(message.ProductId, message)) { return; } if (_withCache == false) { var result = await RealTimeInventory.ReadInventoryFromStorageAsync(InventoryStorage, message.ProductId); RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; } else { RealTimeInventory = RealTimeInventory.ToSuccessOperationResult().ProcessAndSendResult(message, (rti) => new GetInventoryCompletedMessage(rti, true), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; } }); ReceiveAsync <ReserveMessage>(async message => { if (!CanProcessMessage(message.ProductId, message)) { return; } var result = await RealTimeInventory.ReserveAsync(InventoryStorage, message.ProductId, message.Update); RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; }); ReceiveAsync <UpdateQuantityMessage>(async message => { if (!CanProcessMessage(message.ProductId, message)) { return; } var result = await RealTimeInventory.UpdateQuantityAsync(InventoryStorage, message.ProductId, message.Update); RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; }); ReceiveAsync <UpdateAndHoldQuantityMessage>(async message => { if (!CanProcessMessage(message.ProductId, message)) { return; } var updateandHoldResultesult = await RealTimeInventory.UpdateQuantityAndHoldAsync(InventoryStorage, message.ProductId, message.Update); RealTimeInventory = updateandHoldResultesult.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; }); ReceiveAsync <PlaceHoldMessage>(async message => { if (!CanProcessMessage(message.ProductId, message)) { return; } var result = await RealTimeInventory.PlaceHoldAsync(InventoryStorage, message.ProductId, message.Update); RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; }); ReceiveAsync <PurchaseMessage>(async message => { if (!CanProcessMessage(message.ProductId, message)) { return; } var result = await RealTimeInventory.PurchaseAsync(InventoryStorage, message.ProductId, message.Update); RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; }); ReceiveAsync <PurchaseFromHoldsMessage>(async message => { if (!CanProcessMessage(message.ProductId, message)) { return; } var result = await RealTimeInventory.PurchaseFromHoldsAsync(InventoryStorage, message.ProductId, message.Update).ConfigureAwait(false); RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; }); ReceiveAsync <FlushStreamsMessage>(async message => { var result = await RealTimeInventory.InventoryStorageFlushAsync(InventoryStorage, _id); Sender.Tell(result.Data); }); ReceiveAsync <ResetInventoryQuantityReserveAndHoldMessage>(async message => { if (!CanProcessMessage(message.ProductId, message)) { return; } var updateandHoldResultesult = await RealTimeInventory.ResetInventoryQuantityReserveAndHoldAsync(InventoryStorage, message.ProductId, message.Update, message.Reservations, message.Holds); RealTimeInventory = updateandHoldResultesult.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory; }); #if DEBUG // Context.System.Scheduler.ScheduleTellRepeatedly(TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(5), Nobody.Instance, RealTimeInventory, Self); #endif }
public static async Task <OperationResult <IRealTimeInventory> > PlaceHoldAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int toHold) { var newHolds = realTimeInventory.Holds + toHold; if (newHolds > realTimeInventory.Quantity) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.HOLD_EXCEED_QUANTITY_FOR_HOLD, realTimeInventory, toHold).ToFailedOperationResult(realTimeInventory, productId)); } var newRealTimeInventory = new RealTimeInventory(productId, realTimeInventory.Quantity, realTimeInventory.Reserved, newHolds); var result = await inventoryStorage.WriteInventoryAsync(newRealTimeInventory); if (!result.IsSuccessful) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, toHold, result.Errors).ToFailedOperationResult(realTimeInventory, productId)); } return(newRealTimeInventory.ToOperationResult(isSuccessful: true)); }
public static async Task <OperationResult <IRealTimeInventory> > ResetInventoryQuantityReserveAndHoldAsync(this IRealTimeInventory currentInventory, IInventoryStorage inventoryStorage, string productId, int quantity, int reserve, int hold) { IRealTimeInventory realTimeInventory = new RealTimeInventory(currentInventory.ProductId, 0, 0, 0); var result = await realTimeInventory.UpdateQuantityAsync(inventoryStorage, productId, quantity); if (result.IsSuccessful) { result = await result.Data.ReserveAsync(inventoryStorage, productId, reserve); if (result.IsSuccessful) { result = await result.Data.PlaceHoldAsync(inventoryStorage, productId, hold); if (result.IsSuccessful) { return(result.Data.ToOperationResult(isSuccessful: true)); } } } result.Data = currentInventory; return(result); }
public static async Task <OperationResult <IRealTimeInventory> > UpdateQuantityAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int quantity) { var newQuantity = realTimeInventory.Quantity + quantity; var newRealTimeInventory = new RealTimeInventory(productId, newQuantity, realTimeInventory.Reserved, realTimeInventory.Holds); var result = await inventoryStorage.WriteInventoryAsync(newRealTimeInventory); if (!result.IsSuccessful) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, quantity, result.Errors).ToFailedOperationResult(realTimeInventory, productId)); } return(newRealTimeInventory.ToOperationResult(isSuccessful: true)); }
public static async Task <OperationResult <IRealTimeInventory> > ReserveAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int reservationQuantity) { var newReserved = Math.Max(0, realTimeInventory.Reserved + reservationQuantity); if ((reservationQuantity > 0) && (newReserved > realTimeInventory.Quantity - realTimeInventory.Holds)) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.RESERVATION_EXCEED_QUANTITY, realTimeInventory, reservationQuantity).ToFailedOperationResult(realTimeInventory, productId)); } var newRealTimeInventory = new RealTimeInventory(productId, realTimeInventory.Quantity, newReserved, realTimeInventory.Holds); var result = await inventoryStorage.WriteInventoryAsync(newRealTimeInventory); if (!result.IsSuccessful) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, reservationQuantity, result.Errors).ToFailedOperationResult(realTimeInventory, productId)); } return(newRealTimeInventory.ToOperationResult(isSuccessful: true)); }
public static async Task <OperationResult <IRealTimeInventory> > InventoryStorageFlushAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string id) { await inventoryStorage.FlushAsync(); return(realTimeInventory.ToOperationResult(isSuccessful: true)); }
public static async Task <OperationResult <IRealTimeInventory> > ReadInventoryFromStorageAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId) { try { if (string.IsNullOrEmpty(productId)) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.NO_PRODUCT_ID_SPECIFIED, realTimeInventory, 0).ToFailedOperationResult(realTimeInventory)); } var result = await inventoryStorage.ReadInventoryAsync(productId); return(result.Result.ToSuccessOperationResult()); } catch (Exception e) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_READ_INV, realTimeInventory, 0, e).ToFailedOperationResult()); } }
public static async Task <OperationResult <IRealTimeInventory> > PurchaseFromHoldsAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int quantity) { if (quantity < 0) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.NEGATIVE_PURCHASE_FOR_PURCHASEFROMHOLD, realTimeInventory, quantity).ToFailedOperationResult(realTimeInventory, productId)); } var newQuantity = realTimeInventory.Quantity - quantity; var newHolds = realTimeInventory.Holds - quantity; if (newQuantity < 0 || newHolds < 0) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.PURCHASE_EXCEED_QUANTITY_FOR_PURCHASEFROMHOLD, realTimeInventory, quantity).ToFailedOperationResult(realTimeInventory, productId)); } var newrealTimeInventory = new RealTimeInventory(productId, newQuantity, realTimeInventory.Reserved, newHolds); var result = await inventoryStorage.WriteInventoryAsync(newrealTimeInventory).ConfigureAwait(false); if (!result.IsSuccessful) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, quantity, result.Errors).ToFailedOperationResult(realTimeInventory, productId)); } return(newrealTimeInventory.ToOperationResult(isSuccessful: true)); }
public static async Task <OperationResult <IRealTimeInventory> > PurchaseAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int quantity) { if (quantity < 0) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.NEGATIVE_PURCHASE_FOR_PURCHASEFROMRESERVATION, realTimeInventory, quantity).ToFailedOperationResult(realTimeInventory, productId)); } var newQuantity = realTimeInventory.Quantity - quantity; var newReserved = Math.Max(0, realTimeInventory.Reserved - quantity); //todo we still want to sell even though there is reservation //var newReserved = realTimeInventory.Reserved - quantity; //if(newReserved<0) throw new Exception("provided " + quantity + ", available reservations must be less than or equal to quantity for product " + productId); if (newQuantity - realTimeInventory.Holds < 0) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.PURCHASE_EXCEED_QUANTITY_FOR_PURCHASEFROMRESERVATION, realTimeInventory, quantity).ToFailedOperationResult(realTimeInventory, productId)); } var newrealTimeInventory = new RealTimeInventory(productId, newQuantity, newReserved, realTimeInventory.Holds); var result = await inventoryStorage.WriteInventoryAsync(newrealTimeInventory); if (!result.IsSuccessful) { return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, quantity, result.Errors).ToFailedOperationResult(realTimeInventory, productId)); } return(newrealTimeInventory.ToOperationResult(isSuccessful: true)); }
public CheckedInventoryStorage(IInventoryStorage storage) { _storage = storage; }
public InventoryDialogService(IInventoryStorage storage, IInputParserService parser, ICommandCache commandCache) { this.storage = storage; this.parser = parser; this.commandCache = commandCache; }
public static RealTimeInventory InitializeFromStorage(this RealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string id) { var initTask = inventoryStorage.ReadInventoryAsync(id); Task.WaitAll(initTask); var inventory = initTask.Result.Result; if (!initTask.Result.IsSuccessful) { throw initTask.Result.Errors.Flatten(); } return(new RealTimeInventory(id, inventory.Quantity, inventory.Reserved, inventory.Holds)); }