private void LoadManageMarketListingDetailsPage()
{
var player = GetPC();
var model = MarketService.GetPlayerMarketData(player);
var category = DataService.MarketCategory.GetByID(model.ItemMarketCategoryID);
// Build the header
string header = ColorTokenService.Green("Galactic Trade Market - Manage Market Listing") + "\n\n";
header += ColorTokenService.Green("Item: ") + model.ItemStackSize + "x " + model.ItemName + "\n";
header += ColorTokenService.Green("Category: ") + category.Name + "\n";
if (model.ItemRecommendedLevel > 0)
{
header += ColorTokenService.Green("Recommended Level: ") + model.ItemRecommendedLevel + "\n";
}
header += ColorTokenService.Green("Sell Price: ") + model.SellPrice + " credits\n";
header += ColorTokenService.Green("Seller Note: ") + model.SellerNote + "\n\n";
if (model.IsListingExpired)
{
header += ColorTokenService.Red("This listing has expired.");
}
else
{
DateTime now = DateTime.UtcNow;
var delta = model.ListingExpirationDate - now;
string expirationTime = TimeService.GetTimeLongIntervals(delta.Days, delta.Hours, delta.Minutes, delta.Seconds, false);
header += ColorTokenService.Green("This listing expires in " + expirationTime + ".");
}
SetPageHeader("MarketListingDetailsPage", header);
}
public AcceleratorPackage(
AssortmentService assortmentService,
FieldTemplateService fieldTemplateService,
StructureInfoService structureInfoService,
MarketService marketService,
ChannelService channelService,
CurrencyService currencyService,
WebsiteService websiteService,
InventoryService inventoryService,
PriceListService priceListService,
DomainNameService domainNameService,
GroupService groupService,
FolderService folderService,
PersonService personService,
LanguageService languageService,
SlugifyService slugifyService)
{
_assortmentService = assortmentService;
_fieldTemplateService = fieldTemplateService;
_structureInfoService = structureInfoService;
_marketService = marketService;
_channelService = channelService;
_currencyService = currencyService;
_websiteService = websiteService;
_inventoryService = inventoryService;
_priceListService = priceListService;
_domainNameService = domainNameService;
_groupService = groupService;
_folderService = folderService;
_personService = personService;
_languageService = languageService;
_slugifyService = slugifyService;
}
private void ManageMarketListingsReponses(int responseID)
{
var response = GetResponseByID("MarketListingsPage", responseID);
var player = GetPC();
var model = MarketService.GetPlayerMarketData(player);
model.ManageListingID = (Guid)response.CustomData;
// Populate the temporary data model for use on other pages.
var listing = DataService.PCMarketListing.GetByID(model.ManageListingID);
model.ItemID = new Guid(listing.ItemID);
model.ItemName = listing.ItemName;
model.ItemTag = listing.ItemTag;
model.ItemResref = listing.ItemResref;
model.ItemObject = listing.ItemObject;
model.ItemRecommendedLevel = listing.ItemRecommendedLevel;
model.ItemStackSize = listing.ItemStackSize;
model.ItemMarketCategoryID = listing.MarketCategoryID;
model.SellPrice = listing.Price;
model.SellerNote = listing.Note;
model.ListingExpirationDate = listing.DateExpires;
// Switch to details page.
LoadManageMarketListingDetailsPage();
ChangePage("MarketListingDetailsPage");
}
public void GetAll_ShouldCallMarketRepositoryReadAll_Once()
{
IService <Market> marketService = new MarketService(_repositoryMock.Object);
marketService.GetAll();
_repositoryMock.Verify(repo => repo.ReadAll(), Times.Once);
}
public StrategyViewModel(StrategiesViewModel parent, StrategyModel model, MarketService markets, AccountService accounts, SettingService settings)
{
_parent = parent;
Model = model ?? throw new ArgumentNullException(nameof(model));
_markets = markets;
_accounts = accounts;
_settings = settings;
StartCommand = new RelayCommand(() => DoRunStrategy(), () => true);
StopCommand = new RelayCommand(() => { }, () => false);
CloneCommand = new RelayCommand(() => DoCloneStrategy(), () => true);
CloneAlgorithmCommand = new RelayCommand(() => DoCloneAlgorithm(), () => !string.IsNullOrEmpty(Model.AlgorithmName));
ExportCommand = new RelayCommand(() => DoExportStrategy(), () => true);
DeleteCommand = new RelayCommand(() => _parent?.DoDeleteStrategy(this), () => true);
DeleteAllTracksCommand = new RelayCommand(() => DoDeleteTracks(null), () => true);
DeleteSelectedTracksCommand = new RelayCommand <IList>(m => DoDeleteTracks(m), m => true);
UseParametersCommand = new RelayCommand <IList>(m => DoUseParameters(m), m => true);
AddSymbolCommand = new RelayCommand(() => DoAddSymbol(), () => true);
DeleteSymbolsCommand = new RelayCommand <IList>(m => DoDeleteSymbols(m), m => SelectedSymbol != null);
ImportSymbolsCommand = new RelayCommand(() => DoImportSymbols(), () => true);
ExportSymbolsCommand = new RelayCommand <IList>(m => DoExportSymbols(m), trm => SelectedSymbol != null);
TrackDoubleClickCommand = new RelayCommand <TrackViewModel>(m => DoSelectItem(m));
MoveUpSymbolsCommand = new RelayCommand <IList>(m => OnMoveUpSymbols(m), m => SelectedSymbol != null);
MoveDownSymbolsCommand = new RelayCommand <IList>(m => OnMoveDownSymbols(m), m => SelectedSymbol != null);
SortSymbolsCommand = new RelayCommand(() => Symbols.Sort(), () => true);
Model.NameChanged += StrategyNameChanged;
Model.MarketChanged += MarketChanged;
Model.AlgorithmNameChanged += AlgorithmNameChanged;
DataFromModel();
Model.EndDate = DateTime.Now;
}
private void MainPageResponses(int responseID)
{
var player = GetPC();
var model = MarketService.GetPlayerMarketData(player);
switch (responseID)
{
case 1: // Buy
model.IsSellingItem = false;
ChangePage("BuyPage");
break;
case 2: // Sell
model.IsSellingItem = true;
LoadSellItemPage();
ChangePage("SellItemPage");
break;
case 3: // Manage Market Listings
model.IsSellingItem = false;
LoadManageMarketListingsPage();
ChangePage("MarketListingsPage");
break;
}
}
public async Task Refresh(MarketService marketService)
{
await GetCoinApi();
if (!string.IsNullOrEmpty(ShortName))
{
var priceList = await marketService.GetPricesFullAsync(this);
Prices = new SortableBindingList <MarketPrice>(priceList);
if (Prices.Count > 0)
{
ActualPrice = Prices.OrderByDescending(p => p.Volume).FirstOrDefault().Price;
}
//var t1 = marketService.GetPricesFullAsync(this);
//var t2 = t1.ContinueWith((priceList) =>
//{
// if (priceList.Result.Count > 0)
// ActualPrice = priceList.Result.OrderByDescending(p => p.Volume).FirstOrDefault().Price;
//});
//await t2;
//Prices = new SortableBindingList<MarketPrice>(t1.Result);
}
}
internal void SaveNewMarket(AdminMarketsModel adminStockModel)
{
MarketService.CreateMarket(new MarketModel()
{
name = adminStockModel.name, work_hours = adminStockModel.work_hours
});
}
public void Send(Parcel parcel)
{
if (parcel.Hot < 200)
{
return;
}
var message = string.Format("Parcel [{0},{1}]", parcel.x, parcel.y);
message += " [" + parcel.Hot + "]";
message += " [mana: " + parcel.Price + "]";
if (parcel.tags.proximity.HasRoad)
{
message += " [road: " + parcel.RoadDistance + "]";
}
if (parcel.tags.proximity.HasDistrict)
{
message += " [dist: " + parcel.DistrictDistance + "]";
}
if (parcel.tags.proximity.HasPlaza)
{
message += " [plaza: " + parcel.PlazaDistance + "]";
}
message += "\n" + MarketService.GetDetailUrl(parcel);
message += "\n" + MarketService.GetMapUrl(parcel);
StartCoroutine(SendRoutine(message));
}
private void LoadBrowseBySellerPage()
{
string header = ColorTokenService.Green("Galactic Trade Network - Browse by Seller") + "\n\n";
header += "Please select a seller.";
SetPageHeader("BrowseBySellerPage", header);
NWPlaceable terminal = NWGameObject.OBJECT_SELF;
int marketRegionID = MarketService.GetMarketRegionID(terminal);
IEnumerable <PCMarketListing> listings = DataService.PCMarketListing
.GetAllByMarketRegionID(marketRegionID)
.Where(x => x.DateExpires > DateTime.UtcNow &&
x.DateSold == null &&
x.DateRemoved == null);
IEnumerable <Guid> playerIDs = listings.Select(s => s.SellerPlayerID).Distinct();
IEnumerable <Player> players = DataService.Player.GetAllByIDs(playerIDs)
.OrderBy(o => o.CharacterName);
ClearPageResponses("BrowseBySellerPage");
AddResponseToPage("BrowseBySellerPage", ColorTokenService.Green("Refresh"), true, Guid.Empty);
foreach (var player in players)
{
AddResponseToPage("BrowseBySellerPage", player.CharacterName, true, player.ID);
}
}
private void ItemListPageResponses(int responseID)
{
var player = GetPC();
var response = GetResponseByID("ItemListPage", responseID);
Guid listingID = (Guid)response.CustomData;
// Refresh listing
if (listingID == Guid.Empty)
{
LoadItemListPage();
return;
}
// If the item no longer exists on the market (expired, bought, or listing removed)
// notify the player and refresh the item list page.
var listing = DataService.PCMarketListing.GetByIDOrDefault(listingID);
if (listing == null || listing.DateSold != null || listing.DateExpires <= DateTime.UtcNow)
{
LoadItemListPage();
player.FloatingText("Unfortunately, that item is no longer available.");
return;
}
var model = MarketService.GetPlayerMarketData(player);
model.BrowseListingID = listingID;
LoadItemDetailsPage();
ChangePage("ItemDetailsPage");
}
public SubNavigationViewModelBuilder(
RequestModelAccessor requestModelAccessor,
RouteRequestInfoAccessor routeRequestInfoAccessor,
CategoryService categoryService,
MarketService marketService,
PageService pageService,
UrlService urlService,
SearchQueryBuilderFactory searchQueryBuilderFactory,
PageSearchService pageSearchService,
AuthorizationService authorizationService,
ICollection <IRenderingValidator <Category> > renderingValidators)
{
_requestModelAccessor = requestModelAccessor;
_routeRequestInfoAccessor = routeRequestInfoAccessor;
_categoryService = categoryService;
_marketService = marketService;
_pageService = pageService;
_urlService = urlService;
_searchQueryBuilderFactory = searchQueryBuilderFactory;
_pageSearchService = pageSearchService;
_website = _requestModelAccessor.RequestModel.WebsiteModel;
_channel = _requestModelAccessor.RequestModel.ChannelModel;
_page = _requestModelAccessor.RequestModel.CurrentPageModel;
_authorizationService = authorizationService;
_renderingValidators = renderingValidators;
}
private void LoadBrowseByCategoryPage()
{
string header = ColorTokenService.Green("Galactic Trade Network - Browse by Category") + "\n\n";
header += "Please select a category.";
SetPageHeader("BrowseByCategoryPage", header);
NWPlaceable terminal = NWGameObject.OBJECT_SELF;
int marketRegionID = MarketService.GetMarketRegionID(terminal);
IEnumerable <PCMarketListing> listings = DataService.PCMarketListing
.GetAllByMarketRegionID(marketRegionID)
.Where(x => x.DateExpires > DateTime.UtcNow &&
x.DateSold == null &&
x.DateRemoved == null);
IEnumerable <int> categoryIDs = listings.Select(s => s.MarketCategoryID).Distinct();
IEnumerable <MarketCategory> categories = DataService.MarketCategory.GetAllByIDs(categoryIDs)
.OrderBy(o => o.Name);
ClearPageResponses("BrowseByCategoryPage");
AddResponseToPage("BrowseByCategoryPage", ColorTokenService.Green("Refresh"), true, -1);
foreach (var category in categories)
{
AddResponseToPage("BrowseByCategoryPage", category.Name, true, category.ID);
}
}
internal void UpdateMarket(AdminMarketsModel adminStockModel)
{
MarketService.UpdateMarket(new MarketModel()
{
Id = adminStockModel.Id, name = adminStockModel.name, work_hours = adminStockModel.work_hours
});
}
private void LoadItemListPage()
{
var model = MarketService.GetPlayerMarketData(GetPC());
IEnumerable <PCMarketListing> listings;
DateTime now = DateTime.UtcNow;
int marketRegionID = MarketService.GetMarketRegionID(Object.OBJECT_SELF);
// Pull items by category
if (model.BrowseMode == MarketBrowseMode.ByCategory)
{
listings = DataService.Where <PCMarketListing>(x => x.DateExpires > now &&
x.MarketRegionID == marketRegionID &&
x.MarketCategoryID == model.BrowseCategoryID &&
x.DateSold == null &&
x.DateRemoved == null);
}
// Pull items being sold by a specific player
else
{
listings = DataService.Where <PCMarketListing>(x => x.DateExpires > now &&
x.MarketRegionID == marketRegionID &&
x.SellerPlayerID == model.BrowsePlayerID &&
x.DateSold == null &&
x.DateRemoved == null);
}
// Build the response list.
ClearPageResponses("ItemListPage");
AddResponseToPage("ItemListPage", ColorTokenService.Green("Refresh"), true, Guid.Empty);
foreach (var listing in listings)
{
string listingName = BuildItemName(listing);
AddResponseToPage("ItemListPage", listingName, true, listing.ID);
}
}
private void LoadManageMarketListingsPage()
{
string header = ColorTokenService.Green("Galactic Trade Market - Manage Market Listings") + "\n\n";
header += "The following is a list of items you are currently selling. Pick one to edit or remove the listing.";
SetPageHeader("MarketListingsPage", header);
var player = GetPC();
var regionID = MarketService.GetMarketRegionID(NWGameObject.OBJECT_SELF);
var listings = DataService.PCMarketListing.GetAllBySellerPlayerID(player.GlobalID)
.Where(x => x.DateSold == null &&
x.DateRemoved == null &&
x.MarketRegionID == regionID);
ClearPageResponses("MarketListingsPage");
foreach (var listing in listings)
{
string itemName = BuildItemName(listing);
// Display an EXPIRED tag on the item name if the listing has expired.
if (listing.DateExpires < DateTime.UtcNow)
{
itemName += ColorTokenService.Red(" [EXPIRED]");
}
AddResponseToPage("MarketListingsPage", itemName, true, listing.ID);
}
}
private async void UpdateView(object state)
{
if (PoloniexClient != null)
{
if (semaphoreSlim != null)
{
await semaphoreSlim.WaitAsync();
try
{
MarketService.Instance().MarketList = await PoloniexClient.Markets.GetSummaryAsync();
WalletService.Instance().WalletList = await PoloniexClient.Wallet.GetBalancesAsync();
try
{
FachadaWSSGSService.Instance().getUltimoValorVOResponse = await FachadaWSSGS.getUltimoValorVOAsync(10813);
}
catch
{
}
await ucHeader.LoadLoanOffersAsync(PoloniexClient);
}
finally
{
if (semaphoreSlim != null)
{
semaphoreSlim.Release();
}
}
}
}
}
public override void Initialize()
{
var player = GetPC();
var model = MarketService.GetPlayerMarketData(player);
// Player is returning from an item preview.
// Send them to the Item Details page.
if (model.IsReturningFromItemPreview)
{
NavigationStack = model.TemporaryDialogNavigationStack;
if (model.BrowseMode == MarketBrowseMode.ByCategory)
{
LoadBrowseByCategoryPage();
}
else
{
LoadBrowseBySellerPage();
}
LoadItemListPage();
LoadItemDetailsPage();
ChangePage("ItemDetailsPage", false);
}
// Player is returning from selecting an item to sell.
// Send them to the Sell Item page.
else if (model.IsReturningFromItemPicking)
{
NavigationStack = model.TemporaryDialogNavigationStack;
LoadSellItemPage();
ChangePage("SellItemPage", false);
}
}
// GET: AdminHolidays/Create
public ActionResult Create()
{
ViewBag.market_id = new SelectList(MarketService.GetMarkets().Select(m => new AdminMarketsModel()
{
Id = m.Id, name = m.name, work_hours = m.work_hours
}), "Id", "name");
return(View());
}
public MarketServiceTests()
{
var eventRepo = new EventRepository();
var marketRepo = new MarketRepository();
var betRepo = new BetRepository();
MarketService = new MarketService(marketRepo, new BetService(betRepo, eventRepo, marketRepo));
}
private void DeleteIntradiaryData(string marketName)
{
DateTime marketTime = MarketService.GetMarketCurrentLocalTime(marketName);
if (marketTime.Hour == 5)
{
QuotesService.ClearIntradiaryDataByMarketID(marketName);
}
}
private void LoadChangePricePage()
{
var player = GetPC();
var model = MarketService.GetPlayerMarketData(player);
string header = ColorTokenService.Green("Galactic Trade Network - Change Sell Price") + "\n\n";
header += ColorTokenService.Green("Current Price: ") + model.SellPrice;
SetPageHeader("ChangePricePage", header);
}
public MostSoldEventListener(MostSoldDataHolder mostSoldDataHolder, EventBroker eventBroker, CategoryService categoryService, VariantService variantService, ChannelService channelService, MarketService marketService)
{
_mostSoldDataHolder = mostSoldDataHolder;
_eventBroker = eventBroker;
_categoryService = categoryService;
_variantService = variantService;
_token = Solution.Instance.SystemToken;
_channelService = channelService;
_marketService = marketService;
}
public MarketsViewModel(MarketService markets, SettingService settings)
{
Model = markets;
_settings = settings;
AddCommand = new RelayCommand(() => DoAddMarket(), () => !IsBusy);
SelectedChangedCommand = new RelayCommand <ITreeViewModel>((vm) => DoSelectedChanged(vm), (vm) => vm != null);
DataFromModel();
}
private void UpdateUserTypeExpirationFromMercadoPago()
{
DateTime marketTime = MarketService.GetMarketCurrentLocalTime("BCBA");
LOG.Log($" >> MERCADO PAGO: UPDATE USER TYPE EXPIRATION Starting - {DateTime.Now}");
if (marketTime.Hour == 1)
{
UserService.UpdateUserTypeExpirationFromMercadoPago(DateTime.Now.Date);
}
LOG.Log($" << MERCADO PAGO: UPDATE USER TYPE EXPIRATION End - {DateTime.Now}");
}
internal List <AdminMarketsModel> GetMarkets(bool recalculate = false)
{
if (recalculate || this.markets == null)
{
this.markets = MarketService.GetMarkets().Select(s => new AdminMarketsModel()
{
Id = s.Id, name = s.name, work_hours = s.work_hours
}).ToList();
}
return(this.markets);
}
public void LoadMoreComments(int countToLoad, Action <bool> callback)
{
if (this._isLoadingComments)
{
return;
}
this._isLoadingComments = true;
MarketService instance = MarketService.Instance;
long ownerId = this.OwnerId;
long itemId = this.ItemId;
int totalCommentsCount = this.TotalCommentsCount;
ProductLikesCommentsData likesCommentsData = this._likesCommentsData;
int? nullable;
if (likesCommentsData == null)
{
nullable = new int?();
}
else
{
List <Comment> comments = likesCommentsData.Comments;
nullable = comments != null ? new int?((comments.Count)) : new int?();
}
int offset = nullable ?? 0;
int count = countToLoad;
Action <BackendResult <ProductLikesCommentsData, ResultCode> > callback1 = (Action <BackendResult <ProductLikesCommentsData, ResultCode> >)(res =>
{
if (res.ResultCode == ResultCode.Succeeded)
{
if (this._likesCommentsData == null)
{
this._likesCommentsData = res.ResultData;
this.TotalCommentsCount = this._likesCommentsData.TotalCommentsCount;
}
else
{
List <Comment> comments = this._likesCommentsData.Comments;
this._likesCommentsData.Comments = res.ResultData.Comments;
this._likesCommentsData.Comments.AddRange((IEnumerable <Comment>)comments);
this._likesCommentsData.users.AddRange((IEnumerable <User>)res.ResultData.users);
this._likesCommentsData.groups.AddRange((IEnumerable <Group>)res.ResultData.groups);
}
callback(true);
}
else
{
callback(false);
}
this._isLoadingComments = false;
});
instance.GetComments(ownerId, itemId, totalCommentsCount, offset, count, callback1);
}
public JsonResult OnChangeStatus(int pId = 0)
{
var mMarket = MarketService.LayTheoId(pId);
if (mMarket != null)
{
mMarket.Status = !mMarket.Status;
MpStartEntities.SaveChanges();
return(Json(new { code = 1, message = (mMarket.Status == true? "Kích hoạt thành công!": "Khóa tài khoản thành công!") }));
}
return(Json(new { code = 0, message = "Không tìm thấy tài khoản cần xóa." }));
}
void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
try
{
CancelTimer();
if (currencyItems != null)
{
currencyItems.Clear();
}
if (TradeHistoryWindow != null)
{
TradeHistoryWindow.Close();
}
if (chartWindow != null)
{
chartWindow.Close();
}
if (MarketService.Instance().TradesHistoryList != null)
{
MarketService.Instance().TradesHistoryList.Clear();
}
if (semaphoreSlim != null)
{
semaphoreSlim.Dispose();
}
}
finally
{
updateTimer = null;
semaphoreSlim = null;
PoloniexClient = null;
currencyItems = null;
TradeHistoryWindow = null;
chartWindow = null;
MarketService.Instance().TradesHistoryList = null;
disposedValue = true;
}
}
}
}
public override void EndDialog()
{
var pc = GetPC();
var model = MarketService.GetPlayerMarketData(pc);
// We'll only wipe the data if the player isn't accessing the inventory or otherwise
// changing contexts.
if (!model.IsAccessingInventory)
{
ReturnSellingItem();
MarketService.ClearPlayerMarketData(pc);
}
}
public async Task GetMarketDetails(string id)
{
if (_isBusy)
return;
_isBusy = true;
var service = new MarketService ();
var item = await service.GetMarketDetailById (id);
SelectedMarket = item.MarketDetails;
_isBusy = false;
}
public async Task SearchMarkets(string zipCode)
{
if (_isBusy)
return;
_isBusy = true;
var service = new MarketService ();
var items = await service.GetMarketByZip (zipCode);
if (Markets == null)
Markets = new List<Market> ();
Markets.Clear ();
Markets = items.Results;
_isBusy = false;
}
