public static OrdStatus?convert(OrderStatusEnum ordStatus, Order order)
{
switch (ordStatus)
{
case OrderStatusEnum.osCanceled:
return(OrdStatus.Canceled);
case OrderStatusEnum.osNew:
return(OrdStatus.New);
case OrderStatusEnum.osReplaced:
return(OrdStatus.Replaced);
case OrderStatusEnum.osRejected:
if (order.ordStatus == OrdStatus.PendingNew)
{
return(OrdStatus.Rejected);
}
return(order.ordStatus);
case OrderStatusEnum.osPartiallyFilled:
if (PriceUtils.EqualGreaterThan(order.cumQty, order.quantity))
{
return(OrdStatus.Filled);
}
else
{
return(OrdStatus.PartiallyFilled);
}
}
return(null);
}
public bool Paid(Map map)
{
CompetitionTableRecord playerRecord = competitionTableRecords?.FirstOrDefault(x => x.Faction == Faction.OfPlayer);
if (playerRecord == null)
{
Messages.Message("Competitions_NeedToStartForPaid".Translate(), MessageTypeDefOf.NeutralEvent);
return(false);
}
if (playerRecord.Paid)
{
Messages.Message("Competitions_AlreadyPaid".Translate(), MessageTypeDefOf.NeutralEvent);
return(false);
}
if (PriceUtils.TakeSilverFromPlayer(600, map))
{
playerRecord.Paid = true;
Find.LetterStack.ReceiveLetter("Competitions_JudgPaidTitle".Translate(), "Competitions_JudgPaidDesc".Translate(), LetterDefOf.PositiveEvent);
return(true);
}
return(false);
}
private bool updateOrder(Order order, IExecutionReportMessage er)
{
// stupid protocol...but this is what the API sends...
if (er.ExecType == ExecTypeEnum.etPartiallyFilled ||
er.ExecType == ExecTypeEnum.etFilled)
{
order.avgPx = (order.avgPx * order.cumQty + er.OrderQty * er.Price) / (order.cumQty + er.OrderQty);
order.cumQty += er.OrderQty;
}
else if (er.ExecType == ExecTypeEnum.etReplaced)
{
if (!PriceUtils.isZero(er.OrderQty))
{
order.quantity = er.OrderQty;
}
if (!PriceUtils.isZero(er.Price))
{
order.price = er.Price;
}
}
ExecType? execType = FieldConverter.convert(er.ExecType, order);
OrdStatus?ordStatus = FieldConverter.convert(er.OrderStatus, order);
if (null != execType && null != ordStatus)
{
order.exchangeOrderId = er.OrderID;
order.ordStatus = ordStatus ?? order.ordStatus;
order.execType = execType ?? order.execType;
order.lastMsg = er.Text;
return(true);
}
return(false);
}
public static ExecType?convert(ExecTypeEnum execType, Order order)
{
switch (execType)
{
case ExecTypeEnum.etCanceled:
return(ExecType.Canceled);
case ExecTypeEnum.etNew:
return(ExecType.New);
case ExecTypeEnum.etReplaced:
return(ExecType.Replace);
case ExecTypeEnum.etRejected:
return(ExecType.Rejected);
case ExecTypeEnum.etPartiallyFilled:
if (PriceUtils.EqualGreaterThan(order.cumQty, order.quantity))
{
return(ExecType.Filled);
}
else
{
return(ExecType.PartiallyFilled);
}
}
return(null);
}
public static void CreateAgreement(Alliance alliance, Settlement settlement, int totalCost, int agreementDelay, List <AgreementGood> items, FactionInteraction signer, int trust, Window windowToClose, int formCaravanDelay)
{
if (totalCost == 0)
{
return;
}
if (agreementDelay == 0)
{
return;
}
if (items == null)
{
return;
}
Map targetMap = Find.Maps.Where(x => x.IsPlayerHome).First(x2 => x2.resourceCounter.Silver >= totalCost);
if (PriceUtils.TakeSilverFromPlayer(totalCost, targetMap))
{
List <Thing> toBuy = new List <Thing>();
foreach (var item in items)
{
if (item.Thing is Pawn pawn)
{
toBuy.Add(item.Thing);
settlement.trader.StockListForReading.Remove(item.Thing);
if (Find.WorldPawns.Contains(pawn))
{
Find.WorldPawns.RemovePawn(pawn);
}
}
else
{
toBuy.Add(item.Thing.SplitOff(item.CountToTransfer));
if (item.Thing.stackCount == 0)
{
settlement.trader.StockListForReading.Remove(item.Thing);
}
}
}
signer.Trust -= trust;
TradeSchedulingAgreementComp comp = new TradeSchedulingAgreementComp(alliance, signer, toBuy, settlement, targetMap, agreementDelay * 60000, formCaravanDelay * 60000);
alliance.AddAgreement(comp);
Find.LetterStack.ReceiveLetter("TradeSchedulingAgreement_CreateSucessTitle".Translate(), "TradeSchedulingAgreement_CreateSucessDesc".Translate(settlement.Faction.Name, totalCost, settlement.Name, agreementDelay), LetterDefOf.PositiveEvent);
if (windowToClose != null)
{
windowToClose.Close();
}
}
}
public void amendOrder(String exchangeOrderId, double price, double qty)
{
logger.Info("Amend Order: " + "exchangeOrderId=" + exchangeOrderId + "; price=" + price + "; qty=" + qty);
Order order;
if (!orders.TryGetValue(exchangeOrderId, out order))
{
throw new DownStreamException("Amend order not found: " + exchangeOrderId);
}
if (PriceUtils.EqualGreaterThan(qty, order.quantity))
{
throw new DownStreamException("Can't amend quantity up: " + exchangeOrderId);
}
if (PriceUtils.EqualLessThan(qty, order.cumQty))
{
throw new DownStreamException("Can't amend quantity to equal or less than filled quantity: " + exchangeOrderId);
}
if (!PriceUtils.isZero(price) && !PriceUtils.Equal(price, order.price) &&
!PriceUtils.isZero(qty) && !PriceUtils.Equal(qty, order.quantity))
{
throw new DownStreamException("Can't amend both price and quantity: " + exchangeOrderId);
}
if (price == order.price && qty == order.quantity)
{
throw new DownStreamException("Can't amend price and qty to same value: " + exchangeOrderId);
}
OrderMessage.ReplaceOrderMessage replaceOrderMessage = new OrderMessage.ReplaceOrderMessage();
replaceOrderMessage.AE = user;
replaceOrderMessage.Account = account;
replaceOrderMessage.BrokerID = brokerID;
replaceOrderMessage.Symbol = order.symbol;
replaceOrderMessage.OrderID = order.exchangeOrderId;
replaceOrderMessage.Side = FieldConverter.convert(order.orderSide);
if (!PriceUtils.isZero(price) && !PriceUtils.Equal(price, order.price))
{
replaceOrderMessage.Price = price;
}
if (!PriceUtils.isZero(qty) && !PriceUtils.Equal(qty, order.quantity))
{
replaceOrderMessage.OrderQty = (int)qty;
}
replaceOrderMessage.Data = formatData(replaceOrderMessage.OrderQty, order.account);
replaceOrderMessage.NID = exchangeConnection.GenerateUniqueID(this.market, OrderMessage.MessageTypeEnum.mtReplace);
exchangeConnection.ReplaceOrder(replaceOrderMessage);
}
public static string ShowCoursePrice(Tuple <decimal?, decimal?> price, decimal discount)
{
if (discount >= 100)
{
return(CommonTexts.FreeCourse);
}
if (discount > 0)
{
var coef = (1 - discount / 100);
return(Htmls2.OldNewPrice(price.Item1,
PriceUtils.GetPriceWithCoefficient(price.Item1, false, coef).Item1));
}
return(Htmls2.OldNewPrice(price.Item2, price.Item1));
}
private void cancelAllOrders()
{
logger.Info("Cancelling all orders");
foreach (KeyValuePair <string, Order> entry in orders)
{
Order order = entry.Value;
if (order.ordStatus == OrdStatus.New ||
order.ordStatus == OrdStatus.PartiallyFilled ||
order.ordStatus == OrdStatus.Replaced && PriceUtils.LessThan(order.cumQty, order.quantity))
{
logger.Info("Start up cancel order: " + order.orderId + ":" + order.exchangeOrderId);
cancelOrder(order.exchangeOrderId);
}
}
}
public decimal?GetPrice(Group group)
{
return(PriceUtils.GetPrice(Prices, group, OrderDetail.Order.CustomerType));
}
public decimal?GetPrice(Group group)
{
return(PriceUtils.GetPrice(Prices, group, OrderCustomerType.PrivatePerson));
}
public AllCourseListVM GetAll(object obj)
{
var courses = obj == null
? CourseService.AllCoursesForList()
: CourseService.GetAllFor(obj);
var track = obj as Course;
var isTrack = track != null;
var isTrackDiplom = track != null && courses.FirstOrDefault(x => x.Course_TC == track.Course_TC)
.GetOrDefault(x => x.IsDiplom);
var trackList = obj as TrackListVM;
var siteTerm = obj as SiteTerm;
var isIntraExtraTerm = siteTerm != null && siteTerm.SiteTerm_ID == Sections.Terms.IntraExtra;
var isOpenClassesTerm = siteTerm != null && siteTerm.SiteTerm_ID == Sections.Terms.OpenClasses;
var isDiplomPage = trackList != null && trackList.IsDiplomPage;
var isTrainingProgramsPage = trackList != null && trackList.IsTrainingProgramsPage;
if (isDiplomPage || isTrainingProgramsPage)
{
courses = courses.Where(x => trackList.Courses.Contains(x.Course_TC)).ToList();
}
var isIntraExtraTrackPage = (isTrack && CourseService.IntraExtraTracks().Contains(track.Course_TC)) ||
isDiplomPage;
var trackFullPrices = TrackService.TrackFullPrices();
var items =
courses.Select(c => {
var nearestGroupAndWebinar = GroupService.GetNearestGroupAndWebinar(c,
isIntraExtraTrackPage || isIntraExtraTerm, isOpenClassesTerm);
var coefficient = isTrack
? null
: GroupService.GetGroupsForCourse(c.Course_TC).Where(x => !x.IsIntraExtramural)
.Select(x => PriceUtils.GetCoefficient(x)).Min();
var prices = PriceService.GetAllPricesForCourse(c.Course_TC, null);
var trackPrices = c.IsTrackBool
? trackFullPrices.GetValueOrDefault(c.Course_TC)
: null;
return(new CommonCourseListItemVM
{
Course = c,
IsIntraExtraTrackPage = isIntraExtraTrackPage,
IsTrackPage = isTrack,
TrackFullPrices = trackPrices,
NearestGroup = nearestGroupAndWebinar.Item1,
NearestWebinar = nearestGroupAndWebinar.Item2,
Prices = prices,
PriceCoefficent = coefficient
});
})
.ToList();
var commonCourseListVM = new CommonCourseListVM
{
Items = items,
IsTrackPage = isTrack,
IsDiplomPage = isDiplomPage,
IsTrainingProgramsPage = isTrainingProgramsPage
};
return
(new AllCourseListVM
{
MainList = courses,
TrackCounts = CourseService.TrackCourseCounts(),
TrackLastCourseDiscounts = TrackService.TrackLastCourseDiscounts(),
Common = commonCourseListVM,
IsTrack = isTrack,
IsDiplomPage = isDiplomPage,
IsTrainingProgramsPage = isTrainingProgramsPage,
IsIntraExtra = isIntraExtraTrackPage,
IsTrackDiplom = isTrackDiplom,
HideIntraGroup = isIntraExtraTerm || isOpenClassesTerm,
IsOpenClasses = isOpenClassesTerm,
CourseWithUnlimit = PriceService.CourseWithUnlimite(),
});
}
