public void RenameDirectory(string directoryName, string newDirectoryName)
{
CreateDirectory(newDirectoryName);
directoryName = StorageUtils.NormalizeDirectoryName(directoryName);
newDirectoryName = StorageUtils.NormalizeDirectoryName(newDirectoryName);
CloudBlobDirectory directory = PublicContainer.GetDirectoryReference(directoryName);
foreach (IListBlobItem item in directory.ListBlobsSegmentedAsync(null).GetAwaiter().GetResult().Results)
{
string fileName = string.Empty;
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
fileName = Path.GetFileName(blob.Name);
Copy(blob.Name, GxFileType.Public, newDirectoryName + fileName, GxFileType.Public);
Delete(blob.Name, GxFileType.Public);
}
else if (item.GetType() == typeof(CloudPageBlob))
{
CloudPageBlob pageBlob = (CloudPageBlob)item;
fileName = Path.GetFileName(pageBlob.Name);
Copy(directoryName + fileName, GxFileType.Public, newDirectoryName + fileName, GxFileType.Public);
}
else if (item.GetType() == typeof(CloudBlobDirectory))
{
CloudBlobDirectory dir = (CloudBlobDirectory)item;
RenameDirectory(directoryName + dir.Prefix, newDirectoryName + dir.Prefix);
}
}
DeleteDirectory(directoryName);
}
public void DeleteDirectory(string directoryName)
{
directoryName = StorageUtils.NormalizeDirectoryName(directoryName);
CloudBlobDirectory directory = PublicContainer.GetDirectoryReference(directoryName);
foreach (IListBlobItem item in directory.ListBlobsSegmentedAsync(null).GetAwaiter().GetResult().Results)
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
blob.DeleteAsync().GetAwaiter().GetResult();
}
else if (item.GetType() == typeof(CloudPageBlob))
{
CloudPageBlob pageBlob = (CloudPageBlob)item;
pageBlob.DeleteAsync().GetAwaiter().GetResult();
}
else if (item.GetType() == typeof(CloudBlobDirectory))
{
CloudBlobDirectory dir = (CloudBlobDirectory)item;
DeleteDirectory(dir.Prefix);
}
}
}
public bool ExistsDirectory(string directoryName)
{
directoryName = StorageUtils.NormalizeDirectoryName(directoryName);
CloudBlobDirectory directory = PublicContainer.GetDirectoryReference(directoryName);
return(directory.ListBlobsSegmentedAsync(null).GetAwaiter().GetResult().Results.Any());
}
public void CreateDirectory(string directoryName)
{
directoryName = StorageUtils.NormalizeDirectoryName(directoryName);
CloudBlockBlob blob = PublicContainer.GetBlockBlobReference(directoryName);
blob.UploadFromByteArrayAsync(Array.Empty <byte>(), 0, 0).GetAwaiter().GetResult();
}
private CloudBlockBlob GetCloudBlockBlob(string externalFileName, GxFileType fileType)
{
CloudBlockBlob blob;
if (fileType.HasFlag(GxFileType.Private))
{
blob = PrivateContainer.GetBlockBlobReference(externalFileName);
}
else
{
blob = PublicContainer.GetBlockBlobReference(externalFileName);
}
return(blob);
}
public List <string> GetSubDirectories(string directoryName)
{
List <string> directories = new List <string>();
directoryName = StorageUtils.NormalizeDirectoryName(directoryName);
CloudBlobDirectory directory = PublicContainer.GetDirectoryReference(directoryName);
foreach (IListBlobItem item in directory.ListBlobsSegmentedAsync(null).GetAwaiter().GetResult().Results)
{
if (item.GetType() == typeof(CloudBlobDirectory))
{
CloudBlobDirectory dir = (CloudBlobDirectory)item;
directories.Add(dir.Prefix);
}
}
return(directories);
}
public List <string> GetFiles(string directoryName, string filter = "")
{
List <string> files = new List <string>();
directoryName = StorageUtils.NormalizeDirectoryName(directoryName);
CloudBlobDirectory directory = PublicContainer.GetDirectoryReference(directoryName);
foreach (IListBlobItem item in directory.ListBlobsSegmentedAsync(null).GetAwaiter().GetResult().Results)
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
if (String.IsNullOrEmpty(filter) || blob.Name.Contains(filter))
{
files.Add(blob.Name);
}
}
}
return(files);
}
public void SendDeliveryMessage(PublicContainer container)
{
var privateResult = new Dictionary <string, object>
{
{ k.assignment, ToPrivateDictionary() }
};
if (volunteercharacter != Character.None)
{
Message.Builder.SetCommand(Commands.TransportAssignmentDelivered).WithData(privateResult).ToCharacter(volunteercharacter).Send();
}
var principalResult = new Dictionary <string, object>
{
{ k.assignment, ToDictionary() },
{ k.container, container.ToDictionary() }
};
Message.Builder.SetCommand(Commands.TransportAssignmentDelivered).WithData(principalResult).ToCharacter(ownercharacter).Send();
}
// A sell order was found so the deal is done instantly
public void FulfillBuyOrderInstantly(Character buyer, bool useBuyerCorporationWallet, MarketOrder marketSellOrder, double pricePerPiece, int duration, int quantity, PublicContainer publicContainer, long?forMembersOf)
{
var forCorporation = forMembersOf != null;
var seller = Character.GetByEid(marketSellOrder.submitterEID);
Item itemOnMarket;
if (!marketSellOrder.isVendorItem)
{
//the seller is NOT a vendor
itemOnMarket = GetItemByMarketOrder(marketSellOrder);
seller.ThrowIfEqual(null, ErrorCodes.CharacterNotFound);
if (itemOnMarket.Quantity > quantity)
{
// unstack a fraction
var fractionItem = itemOnMarket.Unstack(quantity);
fractionItem.Owner = buyer.Eid;
// save the remaining item
itemOnMarket.Save();
// add to public container and change owner
publicContainer.AddItem(fractionItem, true);
//the remaining amount
marketSellOrder.quantity = itemOnMarket.Quantity;
// update remaining amount
_orderRepository.UpdateQuantity(marketSellOrder);
//cash in
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, marketSellOrder.price, marketSellOrder.itemDefinition, quantity, TransactionType.marketBuy);
//pay out
this.PayOutToSeller(seller, marketSellOrder.useCorporationWallet, itemOnMarket.Definition, marketSellOrder.price, quantity, TransactionType.marketSell, marketSellOrder.IsAffectsAverage(), forCorporation);
}
else if (itemOnMarket.Quantity == quantity)
{
itemOnMarket.Owner = buyer.Eid;
// add to public container and change owner
publicContainer.AddItem(itemOnMarket, true);
//delete the sell order coz it's done
_orderRepository.Delete(marketSellOrder);
//cash in
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, marketSellOrder.price, marketSellOrder.itemDefinition, quantity, TransactionType.marketBuy);
//pay out
this.PayOutToSeller(seller, marketSellOrder.useCorporationWallet, itemOnMarket.Definition, marketSellOrder.price, quantity, TransactionType.marketSell, marketSellOrder.IsAffectsAverage(), forCorporation);
marketSellOrder.quantity = 0; //signal the sell order delete to the client
}
else if (itemOnMarket.Quantity < quantity)
{
//a part of the buy order is fulfilled immediately
itemOnMarket.Owner = buyer.Eid;
// add to public container and change owner
publicContainer.AddItem(itemOnMarket, true);
_orderRepository.Delete(marketSellOrder);
// create a buy order for the rest of the quantity
var newBuyOrder = CreateBuyOrder(buyer, marketSellOrder.itemDefinition, duration, pricePerPiece, quantity - itemOnMarket.Quantity, marketSellOrder.useCorporationWallet, forMembersOf);
// cash in for the actual transaction
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, marketSellOrder.price, marketSellOrder.itemDefinition, itemOnMarket.Quantity, TransactionType.marketBuy);
// cash in for the deposit - for the rest of the quantity
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, pricePerPiece, marketSellOrder.itemDefinition, quantity - itemOnMarket.Quantity, TransactionType.buyOrderDeposit);
AddCentralBank(TransactionType.buyOrderDeposit, pricePerPiece * (quantity - itemOnMarket.Quantity));
//pay out for the current market item
this.PayOutToSeller(seller, marketSellOrder.useCorporationWallet, itemOnMarket.Definition, marketSellOrder.price, itemOnMarket.Quantity, TransactionType.marketSell, marketSellOrder.IsAffectsAverage(), forCorporation);
marketSellOrder.quantity = 0; //signal to the client
//the item he just bought, the sell order update
//the new buy order
Message.Builder.SetCommand(Commands.MarketBuyOrderCreated)
.WithData(new Dictionary <string, object> {
{ k.buyOrder, newBuyOrder.ToDictionary() }
})
.ToCharacter(buyer)
.Send();
}
Market.SendMarketItemBoughtMessage(buyer, itemOnMarket);
Message.Builder.SetCommand(Commands.MarketSellOrderUpdate)
.WithData(new Dictionary <string, object> {
{ k.sellOrder, marketSellOrder.ToDictionary() }
})
.ToCharacters(seller, buyer)
.Send();
return;
}
//check VENDOR sell order's quantity
if (marketSellOrder.quantity > 0)
{
//finite order cases
var boughtQuantity = quantity;
if (marketSellOrder.quantity == quantity)
{
_orderRepository.Delete(marketSellOrder);
marketSellOrder.quantity = 0; //signal client
}
else if (marketSellOrder.quantity > quantity)
{
marketSellOrder.quantity -= quantity; //signal client
_orderRepository.UpdateQuantity(marketSellOrder);
}
else if (marketSellOrder.quantity < quantity)
{
_orderRepository.Delete(marketSellOrder);
boughtQuantity = marketSellOrder.quantity;
//create buyorder for the rest of the quantity
var buyOrder = CreateBuyOrder(buyer, marketSellOrder.itemDefinition, duration, pricePerPiece, quantity - marketSellOrder.quantity, marketSellOrder.useCorporationWallet, forMembersOf);
Message.Builder.SetCommand(Commands.MarketBuyOrderCreated)
.WithData(new Dictionary <string, object> {
{ k.item, buyOrder.ToDictionary() }
})
.ToCharacter(buyer)
.Send();
marketSellOrder.quantity = 0; //signal client
//cash in deposit
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, pricePerPiece, marketSellOrder.itemDefinition, quantity - boughtQuantity, TransactionType.buyOrderDeposit);
AddCentralBank(TransactionType.buyOrderDeposit, pricePerPiece * (quantity - boughtQuantity));
}
//take the money for the quantity bought
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, marketSellOrder.price, marketSellOrder.itemDefinition, boughtQuantity, TransactionType.marketBuy);
Message.Builder.SetCommand(Commands.MarketSellOrderUpdate)
.WithData(new Dictionary <string, object> {
{ k.sellOrder, marketSellOrder.ToDictionary() }
})
.ToCharacter(buyer)
.Send();
// vendor stuff
itemOnMarket = publicContainer.CreateAndAddItem(marketSellOrder.itemDefinition, false, item =>
{
item.Owner = buyer.Eid;
item.Quantity = boughtQuantity;
});
Market.SendMarketItemBoughtMessage(buyer, itemOnMarket);
//average price
_marketHandler.InsertAveragePrice(this, marketSellOrder.itemDefinition, boughtQuantity * marketSellOrder.price, boughtQuantity);
AddCentralBank(TransactionType.marketBuy, boughtQuantity * pricePerPiece); //vendor income
return;
}
//infinite quantity case
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, marketSellOrder.price, marketSellOrder.itemDefinition, quantity, TransactionType.marketBuy);
itemOnMarket = publicContainer.CreateAndAddItem(marketSellOrder.itemDefinition, false, item =>
{
item.Owner = buyer.Eid;
item.Quantity = quantity;
});
Market.SendMarketItemBoughtMessage(buyer, itemOnMarket);
//average price
_marketHandler.InsertAveragePrice(this, marketSellOrder.itemDefinition, quantity * marketSellOrder.price, quantity);
AddCentralBank(TransactionType.marketBuy, quantity * pricePerPiece); //vendor income
}
private void GetLocalPublicContainer(Character characterForVolumeWrapper, out VolumeWrapperContainer volumeWrapperContainer, Character characterForPublicContainer, out PublicContainer publicContainer)
{
volumeWrapperContainer = (VolumeWrapperContainer)Container.GetWithItems(containereid, characterForVolumeWrapper, ContainerAccess.List);
var storage = Container.GetOrThrow(volumeWrapperContainer.Parent);
publicContainer = Container.GetFromStructure(storage.Parent);
publicContainer.ReloadItems(characterForPublicContainer);
}
public void PrepareProductionForPublicContainer <TFacility>(long facilityEid, Character character, out TFacility facility, out PublicContainer container) where TFacility : ProductionFacility
{
GetFacilityAndCheckDocking(facilityEid, character, out facility);
container = character.GetPublicContainerWithItems();
}
public static void SendCommandWithTransportAssignmentsAndContainer(Command command, PublicContainer publicContainer, Character character, Dictionary <string, object> extraInfo = null)
{
Transaction.Current.OnCommited(() =>
{
var containerInfo = publicContainer.ToDictionary();
var transportInfos = GetRunningTransportAssignments(character).ToDictionary(true, character);
var result = new Dictionary <string, object>
{
{ k.container, containerInfo },
{ k.transportAssignments, transportInfos }
};
if (extraInfo != null)
{
result.AddRange(extraInfo);
}
result.Add(k.count, GetCountInfo(character));
Message.Builder.SetCommand(command)
.WithData(result)
.ToCharacter(character)
.Send();
});
}
private static void AdministerDelivery(TransportAssignment transportAssignmentInfo, VolumeWrapperContainer volumeWrapperContainer, PublicContainer container)
{
//normal procedure
//successful delivery
transportAssignmentInfo.PayOutReward();
volumeWrapperContainer.ReloadItems(transportAssignmentInfo.volunteercharacter);
volumeWrapperContainer.PrintDebug();
container.AddItem(volumeWrapperContainer, transportAssignmentInfo.ownercharacter.Eid, false);
volumeWrapperContainer.Owner = transportAssignmentInfo.ownercharacter.Eid;
volumeWrapperContainer.ClearAssignmentId();
volumeWrapperContainer.Save();
volumeWrapperContainer.PrintDebug();
//owner
transportAssignmentInfo.WriteLog(TransportAssignmentEvent.deliver, container.Parent);
transportAssignmentInfo.DeleteFromDb();
transportAssignmentInfo.SendDeliveryMessage(container);
}
public void GiveToVolunteer(out VolumeWrapperContainer volumeWrapperContainer, out PublicContainer publicContainer)
{
if (volunteercharacter == Character.None)
{
throw new PerpetuumException(ErrorCodes.WTFErrorMedicalAttentionSuggested);
}
GetLocalPublicContainer(ownercharacter, out volumeWrapperContainer, volunteercharacter, out publicContainer);
volumeWrapperContainer.Owner = volunteercharacter.Eid;
publicContainer.AddItem(volumeWrapperContainer, false);
volumeWrapperContainer.Save();
}
//storage => base => public container -> owner character
public void ReturnToLocalPublicContainer(out VolumeWrapperContainer volumeWrapperContainer, out PublicContainer publicContainer)
{
GetLocalPublicContainer(ownercharacter, out volumeWrapperContainer, ownercharacter, out publicContainer);
publicContainer.AddItem(volumeWrapperContainer, false);
volumeWrapperContainer.Owner = ownercharacter.Eid;
volumeWrapperContainer.ClearAssignmentId();
volumeWrapperContainer.Save();
}
public ErrorCodes PrepareResearchKitMerge(
PublicContainer publicContainer,
Character character, long target, int quantity,
out int nextDefinition,
out int nextLevel,
out double fullPrice,
out int availableQuantity,
out int searchDefinition)
{
ErrorCodes ec;
nextDefinition = 0;
nextLevel = 0;
fullPrice = 0;
availableQuantity = 0;
searchDefinition = 0;
var researchKit = (ResearchKit)publicContainer.GetItem(target, true);
if (researchKit == null)
{
return(ErrorCodes.ItemNotFound);
}
var definition = researchKit.Definition;
searchDefinition = definition;
EntityDefault ed;
if (!EntityDefault.TryGet(definition, out ed))
{
return(ErrorCodes.DefinitionNotSupported);
}
int level = ed.Options.Level;
if (level == 0)
{
Logger.Error("no level was defined for research kit: " + ed.Name + " " + ed.Definition);
return(ErrorCodes.ConsistencyError);
}
if (level == 10)
{
return(ErrorCodes.MaximumResearchLevelReached);
}
nextLevel = level + 1;
var sameDefinitions = publicContainer.GetItems().Where(i => i.Definition == definition).Sum(i => i.Quantity);
if (sameDefinitions % 2 == 1)
{
sameDefinitions--;
}
var pairs = sameDefinitions / 2;
if ((ec = ProductionHelper.FindResearchKitDefinitionByLevel(nextLevel, out nextDefinition)) != ErrorCodes.NoError)
{
return(ec);
}
availableQuantity = Math.Min(pairs, quantity);
fullPrice = GetReserchKitMergePrice(nextLevel, character) * availableQuantity;
return(ec);
}
public ErrorCodes DoResearchKitMerge(PublicContainer publicContainer, Character character, int nextDefinition,
int nextLevel, double fullPrice, int availableQuantity, int searchDefinition, out Dictionary <string, object> result, bool useCorporationWallet)
{
var ec = ErrorCodes.NoError;
var foundQuantity = 0;
result = new Dictionary <string, object>();
var amountToLookFor = availableQuantity * 2;
foreach (var item in publicContainer.GetItems().Where(i => i.Definition == searchDefinition))
{
if (item.Quantity <= amountToLookFor - foundQuantity)
{
foundQuantity += item.Quantity;
Repository.Delete(item);
}
else
{
item.Quantity = item.Quantity - (amountToLookFor - foundQuantity);
foundQuantity = amountToLookFor;
break;
}
}
if (foundQuantity != amountToLookFor)
{
//safe check
return(ErrorCodes.ItemNotFound);
}
publicContainer.CreateAndAddItem(nextDefinition, true, item =>
{
item.Owner = character.Eid;
item.Quantity = availableQuantity;
});
var wallet = character.GetWalletWithAccessCheck(useCorporationWallet, TransactionType.ResearchKitMerge, CorporationRole.ProductionManager);
wallet.Balance -= fullPrice;
var b = TransactionLogEvent.Builder()
.SetTransactionType(TransactionType.ResearchKitMerge)
.SetCreditBalance(wallet.Balance)
.SetCreditChange(-fullPrice)
.SetCharacter(character);
var corpWallet = wallet as CorporationWallet;
if (corpWallet != null)
{
b.SetCorporation(corpWallet.Corporation);
corpWallet.Corporation.LogTransaction(b);
}
else
{
character.LogTransaction(b);
}
result = new Dictionary <string, object> {
{ k.container, publicContainer.ToDictionary() }
};
return(ec);
}
protected override void ConfigureContainer()
{
base.ConfigureContainer();
PublicContainer = Container;
PublicContainer.ComposeParts(this);
}
