private static List <OrgUnitAvailability> GetStoreAvailabilities(IList <ItemAvailabilityStore> inventoryInfo, ReadOnlyCollection <OrgUnitLocation> stores, string unitOfMeasure)
{
List <OrgUnitAvailability> storeAvailabilities = new List <OrgUnitAvailability>();
for (int i = 0; i < inventoryInfo.Count; i++)
{
var storesFound = from c in stores where c.OrgUnitName == inventoryInfo[i].OrgUnitName select c;
if (!storesFound.Any())
{
continue;
}
ItemAvailability itemAvailibility = new ItemAvailability
{
ItemId = inventoryInfo[i].ItemId,
InventoryLocationId = inventoryInfo[i].InventoryLocationId,
AvailableQuantity = inventoryInfo[i].AvailableQuantity,
UnitOfMeasure = unitOfMeasure
};
OrgUnitAvailability storeAvailability = new OrgUnitAvailability(storesFound.First(), new List <ItemAvailability> {
itemAvailibility
});
storeAvailabilities.Add(storeAvailability);
}
return(storeAvailabilities);
}
static void Postfix(ref bool __result, ItemAvailability __instance, ThingCountClass need, Pawn pawn)
{
if (!__result && pawn != null && pawn.Faction == Faction.OfPlayer)
{
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(pawn.Map))
{
if (storage.IsOperational &&
storage.Spawned &&
need != null && need.thing != null)
{
Thing thing;
if (storage.TryGetValue(need.thing.def, out thing))
{
if (thing.stackCount >= need.Count)
{
List <Thing> removed;
int toDrop = (need.Count < thing.def.stackLimit) ? thing.def.stackLimit : need.Count;
if (storage.TryRemove(thing, toDrop, out removed))
{
foreach (Thing t in removed)
{
BuildingUtil.DropThing(t, t.stackCount, storage, storage.Map);
}
__result = true;
((Dictionary <int, bool>)CachedResultsFI.GetValue(__instance))[Gen.HashCombine <Faction>(need.GetHashCode(), pawn.Faction)] = __result;
}
break;
}
}
}
}
}
}
//public bool ThingsAvailableAnywhere(ThingDefCountClass need, Pawn pawn)
public static bool OrInInventory(ItemAvailability item, ThingDefCountClass need, Pawn pawn)
{
if (item.ThingsAvailableAnywhere(need, pawn))
{
return(true);
}
return(pawn.Map.GetComponent <ItemInvAvailabilityMapComp>().ThingsAvailableInventories(need.thingDef, pawn));
}
public void Show(ItemInstance item)
{
_item = item;
_menuItemName.Text = item.Item.Name;
ItemAvailability availability = Character.GetItemAvailability(_item);
string gemmedId = string.Empty;
bool allEnabled = false;
switch (availability)
{
case ItemAvailability.Available:
gemmedId = string.Format("{0}.{1}.{2}.{3}", item.Id, item.Gem1Id, item.Gem2Id, item.Gem3Id);
allEnabled = true;
break;
case ItemAvailability.AvailableWithEnchantRestrictions:
gemmedId = string.Format("{0}.{1}.{2}.{3}", item.Id, item.Gem1Id, item.Gem2Id, item.Gem3Id);
break;
case ItemAvailability.RegemmingAllowed:
allEnabled = true;
break;
case ItemAvailability.RegemmingAllowedWithEnchantRestrictions:
gemmedId = item.Id.ToString() + ".*.*.*";
break;
case ItemAvailability.NotAvailable:
gemmedId = item.Id.ToString() + ".*.*.*";
break;
}
((ToolStripMenuItem)Items[2]).Checked = allEnabled;
List <Enchant> list = Enchant.FindEnchants(_item.Slot, Character);
for (int i = 0; i < list.Count; i++)
{
if (Items.Count <= i + 3)
{
ToolStripMenuItem _menuItem = new ToolStripMenuItem();
_menuItem.Click += new EventHandler(_menuItem_Click);
this.Items.Add(_menuItem);
}
Items[i + 3].Tag = list[i];
Items[i + 3].Text = list[i].ToString();
Items[i + 3].Visible = true;
((ToolStripMenuItem)Items[i + 3]).Checked = (!allEnabled && Character.AvailableItems.Contains(gemmedId + "." + list[i].Id));
}
for (int i = list.Count + 3; i < Items.Count; i++)
{
Items[i].Visible = false;
}
this.Show(Control.MousePosition);
}
//public bool ThingsAvailableAnywhere(ThingDefCountClass need, Pawn pawn)
public static bool OrInInventory(ItemAvailability item, ThingDefCountClass need, Pawn pawn)
{
if (item.ThingsAvailableAnywhere(need, pawn))
{
return(true);
}
return
(pawn.carryTracker.GetDirectlyHeldThings().Contains(need.thingDef) ||
pawn.Map.GetComponent <ItemInvAvailabilityMapComp>().ThingsAvailableInventories(need.thingDef, pawn.Faction));
}
public static Offer CreateNewOffer( decimal price, ItemAvailability availability, ItemCondition itemCondition )
{
var result = new Offer {
Id = Guid.NewGuid(),
Availability = availability,
Condition = itemCondition,
Currency = "USD",
Price = price,
PriceValidityStartDate = System.DateTime.Now,
PriceValidityEndDate = System.DateTime.Now.AddYears( 100 )
};
return result;
}
void Awake()
{
coinSound = Resources.Load("Sounds/coins") as AudioClip;
sellingAbility = ItemAvailability.Regular;
itemsForSale = new LinkedList<Item>();
var dict = ItemFactory.GetAllItems();
foreach (Item i in dict.Values)
{
if (i.availability == sellingAbility)
{
itemsForSale.AddLast(i);
}
}
animation.Play("Idle01");
skin = Resources.Load("ISEGUISkin") as GUISkin;
}
/// <summary>
/// Convert unit of measure for item availabilities.
/// </summary>
/// <param name="context">The request context.</param>
/// <param name="itemAvailabilities">The item availabilities.</param>
/// <param name="itemUnits">The desired item unit of measures.</param>
/// <returns>The converted item availabilities.</returns>
internal static IEnumerable <ItemAvailability> ConvertUnitOfMeasure(RequestContext context, IEnumerable <ItemAvailability> itemAvailabilities, IEnumerable <ItemUnit> itemUnits)
{
List <ItemAvailability> convertedItemAvailabilities = new List <ItemAvailability>();
IEnumerable <ItemUnit> distinctItemUnits = itemUnits.Distinct();
IEnumerable <ItemUnitQuantity> itemUnitQuantities = itemAvailabilities.Select(itemAvailability => itemAvailability.GetItemUnitQuantity());
Dictionary <ItemUnitConversion, UnitOfMeasureConversion> conversions = GetUnitOfMeasureConversions(context, itemUnitQuantities, distinctItemUnits);
ILookup <ItemVariantInventoryDimension, ItemUnit> itemUnitLookupByItem = distinctItemUnits.ToLookup(itemUnit => itemUnit.GetItem());
foreach (ItemAvailability itemAvailability in itemAvailabilities)
{
bool hasInventoryUnit = false;
foreach (ItemUnit itemUnit in itemUnitLookupByItem[itemAvailability.GetItem()])
{
ItemUnitConversion itemUnitConversion = ChannelAvailabilityHelper.GetItemUnitConversion(itemAvailability.GetItemUnitQuantity(), itemUnit);
UnitOfMeasureConversion unitOfMeasureConversion;
if (!conversions.TryGetValue(itemUnitConversion, out unitOfMeasureConversion))
{
if (!StringDataHelper.Equals(itemAvailability.UnitOfMeasure, itemUnit.UnitOfMeasure))
{
context.Notify(new UnableToConvertUnitOfMeasureNotification(itemUnitConversion));
}
if (!hasInventoryUnit)
{
convertedItemAvailabilities.Add(itemAvailability);
hasInventoryUnit = true;
}
}
else
{
ItemAvailability convertedItemAvailability = new ItemAvailability();
convertedItemAvailability.CopyPropertiesFrom(itemAvailability);
convertedItemAvailability.AvailableQuantity = unitOfMeasureConversion.Convert(itemAvailability.AvailableQuantity);
convertedItemAvailability.UnitOfMeasure = itemUnitConversion.ToUnitOfMeasure;
convertedItemAvailabilities.Add(convertedItemAvailability);
}
}
}
return(convertedItemAvailabilities.AsEnumerable());
}
private Boolean IsAvailableByType(ItemType type, ItemAvailability available)
{
switch (type)
{
case ItemType.File:
return(available != ItemAvailability.notavailable);
case ItemType.Folder:
return(available != ItemAvailability.notavailable);
case ItemType.Link:
return(available != ItemAvailability.notavailable);
case ItemType.Multimedia:
case ItemType.ScormPackage:
case ItemType.SharedDocument:
case ItemType.VideoStreaming:
return(available == ItemAvailability.available || available == ItemAvailability.waitingsettings);
}
return(false);
}
private static void SetSalesLineInventoryForShipping(RequestContext context, IEnumerable <SalesLine> salesLines, IEnumerable <ItemAvailability> itemAvailabilities, Dictionary <string, decimal> salesLineInventoryQuantities)
{
ILookup <ItemVariantInventoryDimension, ItemAvailability> itemAvailabilityLookup = itemAvailabilities.ToLookup(itemAvailability => itemAvailability.GetItem());
ILookup <ItemVariantInventoryDimension, SalesLine> salesLineLookup = salesLines.ToLookup(salesLine => salesLine.GetItemVariantInventoryDimension());
foreach (IGrouping <ItemVariantInventoryDimension, SalesLine> grouping in salesLineLookup)
{
ItemVariantInventoryDimension item = grouping.Key;
SortedSet <ItemAvailability> itemAvailabilitySortedSet = new SortedSet <ItemAvailability>(itemAvailabilityLookup[item], new ItemAvailabilityByQuantityDescendingComparer());
foreach (SalesLine salesLine in grouping.OrderByDescending(salesLine => salesLineInventoryQuantities[salesLine.LineId]))
{
ItemAvailability itemAvailability = itemAvailabilitySortedSet.FirstOrDefault();
if (SetSalesInventory(context, salesLine, itemAvailability, salesLineInventoryQuantities))
{
// Remove and add to force sort the set if available quantity is reduced.
itemAvailabilitySortedSet.Remove(itemAvailability);
itemAvailabilitySortedSet.Add(itemAvailability);
}
}
}
}
public NesuiLocationWithQuantity(ItemAvailability availability)
{
this.LocationId = availability.locationId.internalId;
this.Quantity = availability.quantityOnHand;
}
public void InitView(RepositoryIdentifier identifier, Boolean loadSelectedItems, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, Boolean allowSelectFolder, List <long> idSelectedItems, List <long> idRemovedItems = null)
{
if (SessionTimeout())
{
return;
}
if (idRemovedItems == null)
{
idRemovedItems = new List <long>();
}
if (!loadSelectedItems)
{
idRemovedItems.AddRange(idSelectedItems);
idSelectedItems = new List <long>();
}
InitView(identifier, adminMode, showHiddenItems, disableNotAvailableItems, typesToLoad, availability, new List <StatisticType>(), idRemovedItems, idSelectedItems);
}
public List <dtoRepositoryItemToSelect> ItemsToSelectGet(Int32 idCurrentUser, String rootFolder, ModuleRepository module, RepositoryIdentifier identifier, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, List <StatisticType> displayStatistics, List <long> idRemovedItems, List <long> idSelectedItems, Boolean selectAll, Boolean removeFolder)
{
Dictionary <long, String> foldersPath = FoldersFullPathGet(identifier, rootFolder);
List <dtoRepositoryItemToSelect> results = new List <dtoRepositoryItemToSelect>();
var query = GetQuery(identifier).Where(i => i.Deleted == BaseStatusDeleted.None && (showHiddenItems || (i.IsVisible && (i.IdCreatedBy == idCurrentUser && !i.IsVisible))) && !i.IsInternal);
query = query.Where(i => (availability == ItemAvailability.ignore || (availability == i.Availability)) && typesToLoad.Contains(i.Type) && (!removeFolder || (removeFolder && i.IsFile)));
List <liteRepositoryItem> fItems = query.ToList().Where(i => !idRemovedItems.Contains(i.Id)).ToList();
if (!adminMode)
{
Int32 idRole = (Int32)RoleTypeStandard.Guest;
Int32 idProfileType = Manager.GetIdProfileType(idCurrentUser);
List <liteItemAssignments> assignments = new List <liteItemAssignments>();
switch (identifier.Type)
{
case RepositoryType.Community:
case RepositoryType.Portal:
assignments = GetAssignments(fItems.Select(i => i.Id).ToList());
idRole = (identifier.Type == RepositoryType.Community) ? Manager.GetActiveSubscriptionIdRole(idCurrentUser, identifier.IdCommunity) : idRole;
break;
}
fItems = fItems.Where(i => HasValidAssignments(i.Id, idCurrentUser, idRole, idProfileType, assignments)).ToList();
}
if (idSelectedItems == null)
{
idSelectedItems = new List <long>();
}
results = fItems.Select(i => new dtoRepositoryItemToSelect(i, (foldersPath.ContainsKey(i.IdFolder) ? foldersPath[i.IdFolder] : ""), (!disableNotAvailableItems || (disableNotAvailableItems && i.Availability == ItemAvailability.available)), (selectAll || idSelectedItems.Contains(i.Id)))).ToList();
if (displayStatistics.Any())
{
List <StatisticType> statistics = new List <StatisticType>();
if (displayStatistics.Contains(StatisticType.downloads) && (adminMode || module.Administration || module.EditOthersFiles))
{
statistics.Add(StatisticType.downloads);
}
if (displayStatistics.Contains(StatisticType.plays) && (adminMode || module.Administration || module.EditOthersFiles))
{
statistics.Add(StatisticType.plays);
}
if (statistics.Any())
{
if (statistics.Contains(StatisticType.plays))
{
Dictionary <long, long> plays = PlayStatisticsGetFull(results.Where(i => i.Type == ItemType.Multimedia || i.Type == ItemType.ScormPackage || i.Type == ItemType.VideoStreaming).Select(i => i.Id).ToList());
if (plays != null)
{
List <long> idItems = plays.Keys.ToList();
foreach (dtoRepositoryItemToSelect item in results.Where(r => idItems.Contains(r.Id)))
{
item.Plays = (plays != null && plays.ContainsKey(item.Id) ? plays[item.Id] : 0);
}
}
}
}
}
return(results);
}
public AvailItemsChangedEventArgs(string thingChanging, ItemAvailability newAvailability) {
ThingChanging = thingChanging;
NewAvailability = newAvailability;
}
public void OnAvailableItemsChanged(string thingChanging, ItemAvailability newAvailability)
{
if (thingChanging.StartsWith("-")) {
ItemSlot slot = ItemSlot.None;
// Enchants
if (thingChanging.Length == ("-1" + "1000").Length) { slot = (ItemSlot)int.Parse(thingChanging.Substring(1, 1), System.Globalization.CultureInfo.InvariantCulture); }
else if (thingChanging.Length == ("-10" + "1000").Length) { slot = (ItemSlot)int.Parse(thingChanging.Substring(1, 2), System.Globalization.CultureInfo.InvariantCulture); }
// Reforges, the availabiility on these never change
//else if(thingChanging.Length== ("-1" + "000" + "1000").Length) { slot = (ItemSlot)int.Parse(thingChanging.Substring(1, 1)); }
//else if(thingChanging.Length== ("-10" + "000" + "1000").Length) { slot = (ItemSlot)int.Parse(thingChanging.Substring(1, 2)); }
// Tinkerings
else if (thingChanging.Length == ("-1" + "00000" + "1000").Length) { slot = (ItemSlot)int.Parse(thingChanging.Substring(1, 1), System.Globalization.CultureInfo.InvariantCulture); }
else if (thingChanging.Length == ("-10" + "00000" + "1000").Length) { slot = (ItemSlot)int.Parse(thingChanging.Substring(1, 2), System.Globalization.CultureInfo.InvariantCulture); }
// Wipe out the stored relevants list for this slot
_relevantItemInstances.Remove(GetCharacterSlotByItemSlot(slot));
}
if (AvailableItemsChanged != null)
AvailableItemsChanged(this, new AvailItemsChangedEventArgs(thingChanging, newAvailability));
}
public void LoadItems(RepositoryIdentifier identifier, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, List <StatisticType> displayStatistics, List <long> idRemovedItems, List <long> idSelectedItems, Boolean selectAll, OrderBy orderBy, Boolean ascending, Int32 pageIndex, Int32 pageSize)
{
if (!SessionTimeout())
{
LoadItems(Service.GetPermissions(identifier, UserContext.CurrentUserID), UserContext.CurrentUserID, true, identifier, adminMode, showHiddenItems, disableNotAvailableItems, typesToLoad, availability, displayStatistics, idRemovedItems, idSelectedItems, selectAll, orderBy, ascending, pageIndex, pageSize);
}
}
public void InitView(Boolean allowPaging, Boolean selectAll, Int32 pageSize, RepositoryIdentifier identifier, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, List <StatisticType> displayStatistics, List <long> idRemovedItems, List <long> idSelectedItems = null, OrderBy orderBy = OrderBy.name, Boolean ascending = true)
{
if (SessionTimeout())
{
return;
}
View.IdUserLoader = UserContext.CurrentUserID;
View.AvailableTypes = typesToLoad;
View.CurrentAvailability = availability;
View.IdRemovedItems = idRemovedItems;
View.LoadForModule = false;
View.ModuleCode = ModuleRepository.UniqueCode;
View.RepositoryIdentifier = identifier;
View.CurrentOrderBy = orderBy;
View.CurrentAscending = ascending;
View.isInitialized = true;
View.CurrentAdminMode = adminMode;
View.CurrentShowHiddenItems = showHiddenItems;
View.CurrentDisableNotAvailableItems = disableNotAvailableItems;
if (!typesToLoad.Any(t => t == ItemType.Multimedia || t == ItemType.ScormPackage || t == ItemType.VideoStreaming))
{
displayStatistics.Remove(StatisticType.plays);
displayStatistics.Remove(StatisticType.myplays);
}
if (!typesToLoad.Any(t => t != ItemType.Folder && t != ItemType.Link))
{
displayStatistics.Remove(StatisticType.downloads);
displayStatistics.Remove(StatisticType.mydownloads);
}
View.DisplayStatistics = displayStatistics;
LoadItems(Service.GetPermissions(identifier, UserContext.CurrentUserID), UserContext.CurrentUserID, allowPaging, identifier, adminMode, showHiddenItems, disableNotAvailableItems, typesToLoad, availability, displayStatistics, idRemovedItems, idSelectedItems, selectAll, orderBy, ascending, 0, pageSize);
}
private void LoadItems(ModuleRepository module, Int32 idCurrentUser, Boolean allowPaging, RepositoryIdentifier identifier, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, List <StatisticType> displayStatistics, List <long> idRemovedItems, List <long> idSelectedItems, Boolean selectAll, OrderBy orderBy, Boolean ascending, Int32 pageIndex, Int32 pageSize)
{
List <long> selectedItems = idSelectedItems;
if (!selectAll)
{
Dictionary <Boolean, List <long> > selections = View.GetCurrentSelection();
selectedItems = selectedItems.Except(selections[false]).ToList();
selectedItems.AddRange(selections[true]);
View.IdSelectedItems = selectedItems;
}
List <dtoRepositoryItemToSelect> items = Service.ItemsToSelectGet(idCurrentUser, "/", module, identifier, adminMode, showHiddenItems, disableNotAvailableItems, typesToLoad, availability, displayStatistics, idRemovedItems, idSelectedItems, selectAll, !typesToLoad.Contains(ItemType.Folder));
PagerBase pager = new PagerBase();
if (allowPaging)
{
Int32 itemsCount = (items == null ? 0 : items.Count());
pager.PageSize = pageSize;
pager.Count = (itemsCount > 0) ? itemsCount - 1 : 0;
pager.PageIndex = pageIndex;
View.Pager = pager;
pageIndex = pager.PageIndex;
}
if (items == null)
{
View.LoadItems(null);
}
else
{
items = Service.ItemsToSelectReorder(items, orderBy, ascending);
if (items != null)
{
if (allowPaging)
{
View.LoadItems(items.Skip(pageIndex * pageSize).Take(pageSize).ToList());
}
else
{
View.LoadItems(items);
}
}
else
{
View.LoadItems(new List <dtoRepositoryItemToSelect>());
}
}
}
private void LoadItems(ModuleRepository module, Int32 idCurrentUser, RepositoryIdentifier identifier, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, List <StatisticType> displayStatistics, List <long> idRemovedItems, List <long> idSelectedItems)
{
List <ItemType> aTypes = new List <ItemType>();
if (!typesToLoad.Contains(ItemType.Folder))
{
aTypes.Add(ItemType.Folder);
}
aTypes.AddRange(typesToLoad);
List <dtoRepositoryItemToSelect> items = Service.ItemsToSelectGet(idCurrentUser, "/", module, identifier, adminMode, showHiddenItems, disableNotAvailableItems, aTypes, availability, displayStatistics, idRemovedItems, idSelectedItems, false, false);
idSelectedItems = idSelectedItems.Where(i => items.Any(x => x.Id == i)).ToList();
View.IdSelectedItems = idSelectedItems;
if (items == null)
{
View.LoadItems(null);
}
else
{
View.LoadItems(items);
}
}
private ItemAvailability StatusToAvailability(FileTransferBase file, ItemAvailability current)
{
return(StatusToAvailability(file.Status, current));
}
/// <summary>
/// Initializes a new instance of the <see cref="ItemAvailabilityModel"/> class.
/// </summary>
/// <param name="availability">The availability.</param>
public ItemAvailabilityModel(ItemAvailability availability)
{
_availability = availability;
}
public void InitView(RepositoryIdentifier identifier, Boolean loadSelectedItems, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, ItemAvailability availability, Boolean allowSelectFolder, List <long> idSelectedItems, List <long> idRemovedItems = null)
{
if (SessionTimeout())
{
return;
}
if (idRemovedItems == null)
{
idRemovedItems = new List <long>();
}
if (!loadSelectedItems)
{
idRemovedItems.AddRange(idSelectedItems);
idSelectedItems = new List <long>();
}
List <ItemType> typesToLoad = new List <ItemType>()
{
{ ItemType.File }, { ItemType.Multimedia }, { ItemType.Link }, { ItemType.ScormPackage }, { ItemType.SharedDocument }, { ItemType.VideoStreaming }
};
InitView(identifier, adminMode, showHiddenItems, disableNotAvailableItems, typesToLoad, availability, new List <StatisticType>(), idRemovedItems, idSelectedItems);
}
/// <summary>
/// Processes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// Available quantities of specified listings at the requested warehouse.
/// </returns>
protected override GetListingAvailableQuantitiesResponse Process(GetListingAvailableQuantitiesRequest request)
{
ThrowIf.Null(request, "request");
ThrowIf.NullOrEmpty(request.ProductIds, "No Ids have been provided");
QueryResultSettings settings = QueryResultSettings.AllRecords;
var productIds = request.ProductIds.Distinct().ToList();
ProductSearchCriteria queryCriteria = new ProductSearchCriteria(this.Context.GetPrincipal().ChannelId)
{
Ids = productIds,
DataLevel = CommerceEntityDataLevel.Identity,
};
var productSearchResult = request.RequestContext.Runtime.Execute <ProductSearchServiceResponse>(
new ProductSearchServiceRequest(queryCriteria, settings), request.RequestContext).ProductSearchResult;
if (productSearchResult.Results.IsNullOrEmpty())
{
string nonResolvedProductIdsInfo = string.Join(" ", productIds);
//// This is a valid situtation for cross channel scenarios, wish lists for example.
NetTracer.Warning("None of the specified product ids were found on the current channel {0}. ProductIds = {1}", this.Context.GetPrincipal().ChannelId, nonResolvedProductIdsInfo);
return(new GetListingAvailableQuantitiesResponse());
}
var productMap = productSearchResult.Results.ToDictionary(p => p.RecordId, p => p);
var items = this.GetItemAndInventDimId(productIds, productSearchResult, productMap);
settings = new QueryResultSettings(new PagingInfo(items.Count(), 0));
var itemAvailabilities = new HashSet <ItemAvailability>();
var itemUnits = new HashSet <ItemUnit>();
if (request.ChannelId == 0)
{
var itemVariantInventoryDimensions = new HashSet <ItemVariantInventoryDimension>();
foreach (var item in items)
{
itemVariantInventoryDimensions.Add(new ItemVariantInventoryDimension(item.Item1, item.Item2));
}
var itemAvailableQuantitiesRequest = new GetItemAvailableQuantitiesByItemsServiceRequest(settings, itemVariantInventoryDimensions, string.Empty);
var itemAvailableQuantitiesResponse = this.Context.Execute <GetItemAvailableQuantitiesByItemsServiceResponse>(itemAvailableQuantitiesRequest);
foreach (var quantity in itemAvailableQuantitiesResponse.ItemAvailableQuantities.Results)
{
if (quantity != null)
{
var productAvailableQuantity = new ItemAvailability
{
ItemId = quantity.ItemId,
VariantInventoryDimensionId = quantity.VariantInventoryDimensionId,
AvailableQuantity = quantity.AvailableQuantity,
UnitOfMeasure = quantity.UnitOfMeasure
};
itemAvailabilities.Add(productAvailableQuantity);
var itemUnit = new ItemUnit
{
ItemId = quantity.ItemId,
VariantInventoryDimensionId = quantity.VariantInventoryDimensionId,
UnitOfMeasure = items.Where(i => i.Item1.Equals(quantity.ItemId) && i.Item2.Equals(quantity.VariantInventoryDimensionId)).SingleOrDefault().Item3
};
itemUnits.Add(itemUnit);
}
}
}
else
{
var itemWarehouses = new HashSet <ItemWarehouse>();
foreach (var item in items)
{
var itemWarehouse = new ItemWarehouse()
{
ItemId = item.Item1,
VariantInventoryDimensionId = item.Item2,
InventoryLocationId = this.Context.GetChannelConfiguration().InventLocation
};
itemWarehouses.Add(itemWarehouse);
}
var warehouseRequest = new GetItemAvailabilitiesByItemWarehousesServiceRequest(settings, itemWarehouses);
var warehouseResponse = this.Context.Execute <GetItemAvailabilitiesByItemWarehousesServiceResponse>(warehouseRequest);
foreach (var quantity in warehouseResponse.ItemAvailabilities.Results)
{
if (quantity != null)
{
itemAvailabilities.Add(quantity);
var itemUnit = new ItemUnit
{
ItemId = quantity.ItemId,
VariantInventoryDimensionId = quantity.VariantInventoryDimensionId,
UnitOfMeasure = items.Where(i => i.Item1.Equals(quantity.ItemId) && i.Item2.Equals(quantity.VariantInventoryDimensionId)).SingleOrDefault().Item3
};
itemUnits.Add(itemUnit);
}
}
}
var itemAvailabilitiesList = ChannelAvailabilityHelper.ConvertUnitOfMeasure(this.Context, itemAvailabilities.ToList(), itemUnits.ToList());
var processedAvailabilities = this.ProcessItemAvailabilities(itemAvailabilitiesList, productIds, productSearchResult, productMap);
return(new GetListingAvailableQuantitiesResponse(processedAvailabilities.AsPagedResult()));
}
private static bool SetSalesInventory(RequestContext context, SalesLine salesLine, ItemAvailability itemAvailability, Dictionary <string, decimal> salesLineInventoryQuantities)
{
decimal salesLineInventoryQuantity = salesLineInventoryQuantities[salesLine.LineId];
if (itemAvailability == null)
{
var notification = new InventoryNotFoundNotification(salesLine.LineId);
context.Notify(notification);
}
else
{
if (itemAvailability.AvailableQuantity < salesLineInventoryQuantity)
{
var notification = new InsufficientQuantityAvailableNotification(salesLine.LineId, salesLine.ItemId);
context.Notify(notification);
}
salesLine.InventoryLocationId = itemAvailability.InventoryLocationId;
itemAvailability.AvailableQuantity -= salesLineInventoryQuantity;
return(true);
}
return(false);
}
public void ConstructComponents()
{
this.spawnedThings = new ThingOwner <Thing>(this);
this.cellIndices = new CellIndices(this);
this.listerThings = new ListerThings(ListerThingsUse.Global);
this.listerBuildings = new ListerBuildings();
this.mapPawns = new MapPawns(this);
this.dynamicDrawManager = new DynamicDrawManager(this);
this.mapDrawer = new MapDrawer(this);
this.tooltipGiverList = new TooltipGiverList();
this.pawnDestinationReservationManager = new PawnDestinationReservationManager();
this.reservationManager = new ReservationManager(this);
this.physicalInteractionReservationManager = new PhysicalInteractionReservationManager();
this.designationManager = new DesignationManager(this);
this.lordManager = new LordManager(this);
this.debugDrawer = new DebugCellDrawer();
this.passingShipManager = new PassingShipManager(this);
this.haulDestinationManager = new HaulDestinationManager(this);
this.gameConditionManager = new GameConditionManager(this);
this.weatherManager = new WeatherManager(this);
this.zoneManager = new ZoneManager(this);
this.resourceCounter = new ResourceCounter(this);
this.mapTemperature = new MapTemperature(this);
this.temperatureCache = new TemperatureCache(this);
this.areaManager = new AreaManager(this);
this.attackTargetsCache = new AttackTargetsCache(this);
this.attackTargetReservationManager = new AttackTargetReservationManager(this);
this.lordsStarter = new VoluntarilyJoinableLordsStarter(this);
this.thingGrid = new ThingGrid(this);
this.coverGrid = new CoverGrid(this);
this.edificeGrid = new EdificeGrid(this);
this.blueprintGrid = new BlueprintGrid(this);
this.fogGrid = new FogGrid(this);
this.glowGrid = new GlowGrid(this);
this.regionGrid = new RegionGrid(this);
this.terrainGrid = new TerrainGrid(this);
this.pathGrid = new PathGrid(this);
this.roofGrid = new RoofGrid(this);
this.fertilityGrid = new FertilityGrid(this);
this.snowGrid = new SnowGrid(this);
this.deepResourceGrid = new DeepResourceGrid(this);
this.exitMapGrid = new ExitMapGrid(this);
this.linkGrid = new LinkGrid(this);
this.glowFlooder = new GlowFlooder(this);
this.powerNetManager = new PowerNetManager(this);
this.powerNetGrid = new PowerNetGrid(this);
this.regionMaker = new RegionMaker(this);
this.pathFinder = new PathFinder(this);
this.pawnPathPool = new PawnPathPool(this);
this.regionAndRoomUpdater = new RegionAndRoomUpdater(this);
this.regionLinkDatabase = new RegionLinkDatabase();
this.moteCounter = new MoteCounter();
this.gatherSpotLister = new GatherSpotLister();
this.windManager = new WindManager(this);
this.listerBuildingsRepairable = new ListerBuildingsRepairable();
this.listerHaulables = new ListerHaulables(this);
this.listerMergeables = new ListerMergeables(this);
this.listerFilthInHomeArea = new ListerFilthInHomeArea(this);
this.reachability = new Reachability(this);
this.itemAvailability = new ItemAvailability(this);
this.autoBuildRoofAreaSetter = new AutoBuildRoofAreaSetter(this);
this.roofCollapseBufferResolver = new RoofCollapseBufferResolver(this);
this.roofCollapseBuffer = new RoofCollapseBuffer();
this.wildAnimalSpawner = new WildAnimalSpawner(this);
this.wildPlantSpawner = new WildPlantSpawner(this);
this.steadyEnvironmentEffects = new SteadyEnvironmentEffects(this);
this.skyManager = new SkyManager(this);
this.overlayDrawer = new OverlayDrawer();
this.floodFiller = new FloodFiller(this);
this.weatherDecider = new WeatherDecider(this);
this.fireWatcher = new FireWatcher(this);
this.dangerWatcher = new DangerWatcher(this);
this.damageWatcher = new DamageWatcher();
this.strengthWatcher = new StrengthWatcher(this);
this.wealthWatcher = new WealthWatcher(this);
this.regionDirtyer = new RegionDirtyer(this);
this.cellsInRandomOrder = new MapCellsInRandomOrder(this);
this.rememberedCameraPos = new RememberedCameraPos(this);
this.mineStrikeManager = new MineStrikeManager();
this.storyState = new StoryState(this);
this.retainedCaravanData = new RetainedCaravanData(this);
this.components.Clear();
this.FillComponents();
}
private ItemAvailability StatusToAvailability(TransferStatus status, ItemAvailability current)
{
ItemAvailability avail = current;
switch (status)
{
case TransferStatus.Multimedia_AnalyzeError:
avail = ItemAvailability.witherrors;
break;
case TransferStatus.Scorm_AnalyzeError:
avail = ItemAvailability.witherrors;
break;
case TransferStatus.FileTypeError:
avail = ItemAvailability.witherrors;
break;
case TransferStatus.UnableToDeleteAfterUnzip:
avail = ItemAvailability.witherrors;
break;
case TransferStatus.UnzipFileNotFound:
avail = ItemAvailability.witherrors;
break;
case TransferStatus.UploadFileNotFound:
avail = ItemAvailability.witherrors;
break;
case TransferStatus.UnableToUnzip:
avail = ItemAvailability.unabletounzip;
break;
case TransferStatus.Error:
avail = ItemAvailability.witherrors;
break;
case TransferStatus.ReadyForTransfer:
avail = ItemAvailability.transfer;
break;
case TransferStatus.Copying:
avail = ItemAvailability.transfer;
break;
case TransferStatus.ReadyToUnzip:
avail = ItemAvailability.transfer;
break;
case TransferStatus.Unzipping:
avail = ItemAvailability.transfer;
break;
case TransferStatus.Unzipped:
//current
break;
case TransferStatus.ReadyToDelete:
//current
break;
case TransferStatus.Completed:
avail = ItemAvailability.available;
break;
case TransferStatus.Deleting:
//current
break;
case TransferStatus.Deleted:
//current
break;
case TransferStatus.ReadyToAnalyze:
avail = ItemAvailability.analyzing;
break;
case TransferStatus.Analyzed:
//current
break;
case TransferStatus.Multimedia_NoCandidates:
avail = ItemAvailability.waitingsettings;
break;
default:
//current
break;
}
return(avail);
}
