public ReferralHotelsService(
IStakeService stakeService,
ICustomerProfileClient customerProfileClient,
ICurrencyConvertorClient currencyConverterClient,
ICampaignClient campaignClient,
IPartnerManagementClient partnerManagementClient,
IRabbitPublisher <HotelReferralUsedEvent> rabbitPublisher,
INotificationPublisherService notificationPublisherService,
IReferralHotelsRepository referralHotelsRepository,
ISettingsService settingsService,
IHashingManager hashingManager,
TimeSpan referralExpirationPeriod,
TimeSpan referralLimitPeriod,
int referralLimit,
IMapper mapper,
string globalBaseCurrencyCode,
ILogFactory logFactory)
{
_stakeService = stakeService;
_customerProfileClient = customerProfileClient;
_currencyConverterClient = currencyConverterClient;
_campaignClient = campaignClient;
_partnerManagementClient = partnerManagementClient;
_rabbitPublisher = rabbitPublisher;
_notificationPublisherService = notificationPublisherService;
_referralHotelsRepository = referralHotelsRepository;
_settingsService = settingsService;
_hashingManager = hashingManager;
_referralExpirationPeriod = referralExpirationPeriod;
_referralLimitPeriod = referralLimitPeriod;
_referralLimit = referralLimit;
_mapper = mapper;
_globalBaseCurrencyCode = globalBaseCurrencyCode;
_log = logFactory.CreateLog(this);
}
public ReferralLeadService(
IStakeService stakeService,
IMAVNPropertyIntegrationClient propertyIntegrationClient,
IRabbitPublisher <PropertyLeadApprovedReferralEvent> propertyLeadApprovedReferralPublisher,
IReferralLeadRepository referralLeadRepository,
INotificationPublisherService notificationPublisherService,
ISettingsService settingsService,
IHashingManager hashingManager,
IAgentManagementClient agentManagementClient,
ICustomerProfileClient customerProfileClient,
IDictionariesClient dictionariesClient,
IPropertyPurchaseRepository propertyPurchaseRepository,
IRabbitPublisher <LeadStateChangedEvent> leadStateChangedPublisher,
IMapper mapper,
ILogFactory logFactory)
{
_stakeService = stakeService;
_propertyIntegrationClient = propertyIntegrationClient;
_propertyLeadApprovedReferralPublisher = propertyLeadApprovedReferralPublisher;
_referralLeadRepository = referralLeadRepository;
_notificationPublisherService = notificationPublisherService;
_settingsService = settingsService;
_hashingManager = hashingManager;
_agentManagementClient = agentManagementClient;
_customerProfileClient = customerProfileClient;
_dictionariesClient = dictionariesClient;
_propertyPurchaseRepository = propertyPurchaseRepository;
_leadStateChangedPublisher = leadStateChangedPublisher
?? throw new ArgumentNullException(nameof(propertyLeadApprovedReferralPublisher));
_mapper = mapper;
_log = logFactory.CreateLog(this);
}
public StakeController(
IOptions <AppSettings> appSettings,
IStakeService stakeService,
IScopedCancellationToken scopedCancellationToken)
: base(appSettings)
{
this.stakeService = stakeService;
this.scopedCancellationToken = scopedCancellationToken;
}
public PropertyPurchaseService(
IReferralLeadRepository referralLeadRepository,
IPropertyPurchaseRepository propertyPurchaseRepository,
IStakeService stakeService,
CommissionManager commissionManager)
{
_referralLeadRepository = referralLeadRepository;
_propertyPurchaseRepository = propertyPurchaseRepository;
_stakeService = stakeService;
_commissionManager = commissionManager;
}
public AddressController(
IOptions <AppSettings> appSettings,
IFundService fundService,
IStakeService stakeService,
IInvestmentService investmentService,
IScopedCancellationToken scopedCancellationToken)
: base(appSettings)
{
this.fundService = fundService;
this.stakeService = stakeService;
this.investmentService = investmentService;
this.scopedCancellationToken = scopedCancellationToken;
}
public InvestmentService(
IOptions <AppSettings> appSettings,
IFundService fundService,
IStakeService stakeService,
IQuantityProviderFactory quantityProviderFactory,
ICurrencyConverter currencyConverter,
ITransactionRepository transactionRepository,
IOperationRepository operationRepository,
IHttpContextAccessor httpContextAccessor,
IScopedCancellationToken scopedCancellationToken)
: base(appSettings, currencyConverter, transactionRepository, operationRepository, httpContextAccessor, scopedCancellationToken)
{
this.fundService = fundService;
this.stakeService = stakeService;
this.quantityProviderFactory = quantityProviderFactory;
}
private async Task SyncStakingPowerAsync(
IFundService fundService,
IStakeService stakeService,
IStakingPowerRepository stakingRepository,
IStakeSettings stake,
DateTimeOffset startDate,
DateTimeOffset endDate,
CancellationToken cancellationToken)
{
var currentDate = GetHourlyDate(startDate.UtcDateTime).UtcDateTime;
var lastStakingPower = await stakingRepository.GetStakingPowerAsync(stake.ContractAddress, currentDate.AddHours(-1));
var stakingEvents = await stakeService.ListStakeEventsAsync(stake.Symbol, startDate.UtcDateTime, endDate.UtcDateTime)
.ToListAsync(cancellationToken);
var hourlyGroups = stakingEvents
.OrderBy(x => x.ConfirmedAt)
.GroupBy(x => GetHourlyDate(x.ConfirmedAt))
.ToList();
do
{
try
{
var fundPowers = new List <DataStakingPowerFund>();
var hourlyEvents = hourlyGroups.SingleOrDefault(g => g.Key == currentDate)
?? Enumerable.Empty <IStakeEvent>();
foreach (var symbol in stake.FundMultipliers.Keys)
{
var fund = AppSettings.Funds
.Cast <IFundSettings>()
.Single(x => x.Symbol == symbol);
var events = lastStakingPower?.Breakdown.SingleOrDefault(x =>
x.ContractAddress.Equals(fund.ContractAddress.Address, StringComparison.OrdinalIgnoreCase))
?.Events.ToList()
?? new List <DataStakingEvent>();
events.AddRange(hourlyEvents
.Where(e =>
e.ContractAddress == fund.ContractAddress &&
e.Type == StakeEventType.Lockup)
.Select(e => new DataStakingEvent()
{
UserAddress = e.UserAddress,
StakedAt = e.ConfirmedAt,
Quantity = e.Change,
ExpiresAt = e.Lock.ExpiresAt,
TimeModifier = stake.TimeMultipliers
.SingleOrDefault(tm =>
tm.RangeMin <= e.Lock.Duration.Days &&
tm.RangeMax >= e.Lock.Duration.Days)
?.Multiplier ?? 1
}));
foreach (var releaseEvent in hourlyEvents
.Where(e =>
e.ContractAddress == fund.ContractAddress &&
e.Type != StakeEventType.Lockup))
{
var approximateQuantity = releaseEvent.Release.Quantity + (releaseEvent.Release.FeeQuantity ?? decimal.Zero);
var userStakes = events
.Where(e => e.UserAddress.Equals(releaseEvent.UserAddress.Address, StringComparison.OrdinalIgnoreCase))
.ToList();
var lockUp = userStakes.Count > 0
? userStakes.Count == 1
? userStakes.Single()
: userStakes
.OrderBy(x => x.StakedAt)
.FirstOrDefault(e => Math.Abs(e.Quantity - approximateQuantity) <= Precision)
: null;
if (lockUp != null)
{
events.Remove(lockUp);
}
}
if (events.Any())
{
var prices = await fundService.ListPerformanceAsync(
symbol,
PriceMode.Raw,
currentDate.Date.AddDays(-1),
currentDate.Date.AddDays(2),
CurrencyCode.USD)
.ToListAsync(cancellationToken);
var closestPrice = prices
.OrderBy(i => Math.Abs(
new DateTimeOffset(i.Date, TimeSpan.Zero).ToUnixTimeSeconds() -
new DateTimeOffset(currentDate, TimeSpan.Zero).ToUnixTimeSeconds()))
.FirstOrDefault()
?? throw new PermanentException($"No Price data could be found for date {currentDate}");
fundPowers.Add(new DataStakingPowerFund()
{
ContractAddress = fund.ContractAddress,
FundModifier = stake.FundMultipliers[symbol],
PricePerToken = closestPrice.NetAssetValuePerToken,
Events = events
});
}
}
lastStakingPower = new DataStakingPower()
{
Address = stake.ContractAddress,
Date = currentDate.AddHours(1),
Power = fundPowers.Sum(fp => fp.PricePerToken * fp.Events.Sum(fpe => fpe.Quantity * fpe.TimeModifier * fp.FundModifier)),
Breakdown = fundPowers,
Summary = fundPowers
.Select(fp => new DataStakingPowerSummary()
{
ContractAddress = fp.ContractAddress,
Power = fp.PricePerToken * fp.Events.Sum(fpe => fpe.Quantity * fpe.TimeModifier * fp.FundModifier)
})
.ToList()
};
await stakingRepository.UploadItemsAsync(lastStakingPower);
}
finally
{
currentDate = currentDate.AddHours(1);
}
}while (!cancellationToken.IsCancellationRequested && currentDate < endDate.Round());
}