public async Task InsertAsync(PropertyPurchase propertyPurchase)
{
using (var context = _msSqlContextFactory.CreateDataContext())
{
await context.AddAsync(_mapper.Map<PropertyPurchaseEntity>(propertyPurchase));
await context.SaveChangesAsync();
}
}
public async Task <Domain.Models.Referral> GetByCustomerIdAsync(Guid customerId)
{
using (var context = _msSqlContextFactory.CreateDataContext())
{
var entity = await context.Referrals
.FirstOrDefaultAsync(c => c.CustomerId == customerId);
return(_mapper.Map <Domain.Models.Referral>(entity));
}
}
public async Task AddAsync(AuditLog model)
{
var entity = AuditLogEntity.Create(model);
using (var context = _contextFactory.CreateDataContext())
{
context.AuditLogs.Add(entity);
await context.SaveChangesAsync();
}
}
public async Task CreateAsync(IPaymentRequest paymentRequest)
{
var entity = _mapper.Map <PaymentRequestEntity>(paymentRequest);
using (var context = _contextFactory.CreateDataContext())
{
context.PaymentRequests.Add(entity);
await context.SaveChangesAsync();
}
}
public async Task <Guid> CreateAsync(VoucherCampaignContent campaignContent)
{
var entity = _mapper.Map <VoucherCampaignContentEntity>(campaignContent);
using (var context = _contextFactory.CreateDataContext())
{
context.CampaignsContents.Add(entity);
await context.SaveChangesAsync();
return(entity.Id);
}
}
public async Task CreatePaymentRequestAsync(Guid paymentRequestId, string voucherShortCode)
{
using (var context = _contextFactory.CreateDataContext())
{
var paymentRequest = new PaymentRequestEntity
{
Id = paymentRequestId,
VoucherShortCode = voucherShortCode,
};
context.PaymentRequests.Add(paymentRequest);
await context.SaveChangesAsync();
}
}
public async Task <long?> GetLastIndexedBlockNumberAsync()
{
using (var context = _contextFactory.CreateDataContext())
{
var lastIndexedBlock = await context.BlocksData
.SingleOrDefaultAsync(b => b.Key == BlocksDataKeys.LastIndexedBlockNumberKey);
if (lastIndexedBlock == null)
{
return(null);
}
return(long.Parse(lastIndexedBlock.Value));
}
}
public async Task <IReadOnlyList <Permission> > GetAsync(string adminId)
{
using (var context = _contextFactory.CreateDataContext())
{
var entities = await context.Permissions.Where(x => x.AdminUserId == adminId).ToListAsync();
return(entities.Select(x =>
new Permission
{
Type = x.Type,
Level = x.Level
})
.ToImmutableList());
}
}
public async Task AddIfNotExistsAsync(IKycInformation model)
{
using (var context = _contextFactory.CreateDataContext())
{
if (await context.KycInformation.FindAsync(model.PartnerId) != null)
return;
var kycInformationEntity = KycInformationEntity.Create(model);
var statusChangeEntity = KycInformationStatusChangeEntity.Create(model.PartnerId, model.AdminUserId,
model.Timestamp, model.Comment, null, model.KycStatus);
context.KycInformation.Add(kycInformationEntity);
context.KycInformationStatusChange.Add(statusChangeEntity);
await context.SaveChangesAsync();
}
}
public async Task <IReadOnlyList <IKycInformationStatusChange> > GetByPartnerIdAsync(Guid partnerId)
{
using (var context = _contextFactory.CreateDataContext())
{
var result = await context.KycInformationStatusChange
.Where(x => x.PartnerId == partnerId)
.ToListAsync();
return(result);
}
}
public async Task CreateOrUpdateAsync(DownPaymentModel downPayment)
{
using (var context = _msSqlContextFactory.CreateDataContext())
{
var existingReferral =
await context.DownPayments.FirstOrDefaultAsync(e => e.ReferralLeadId == downPayment.ReferralLeadId);
if (existingReferral != null)
{
context.DownPayments.Update(_mapper.Map <DownPaymentEntity>(downPayment));
await context.SaveChangesAsync();
return;
}
await context.DownPayments.AddAsync(_mapper.Map <DownPaymentEntity>(downPayment));
await context.SaveChangesAsync();
}
}
public async Task <long> CreateAsync(Voucher voucher)
{
var entity = _mapper.Map <VoucherEntity>(voucher);
using (var context = _contextFactory.CreateDataContext())
{
context.Vouchers.Add(entity);
var campaign = await context.VoucherCampaigns.FindAsync(entity.CampaignId);
campaign.BoughtVouchersCount++;
context.VoucherCampaigns.Update(campaign);
await context.SaveChangesAsync();
return(entity.Id);
}
}
public async Task <IReadOnlyList <AdminUserEncrypted> > GetAllAsync()
{
using (var context = _contextFactory.CreateDataContext())
{
var entities = await context.AdminUser.AsNoTracking().ToListAsync();
return(_mapper.Map <List <AdminUserEncrypted> >(entities));
}
}
public async Task AddAsync(ITransfer model)
{
using (var context = _contextFactory.CreateDataContext())
{
var entity = TransferEventDataEntity.Create(model);
await context.TransferEventsData.AddAsync(entity);
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateException e)
{
if (e.InnerException is SqlException sqlException &&
sqlException.Number == MsSqlErrorCodes.PrimaryKeyConstraintViolation)
{
_log.Warning("Error on transfer event context saving", e);
}
public async Task AddAsync(ITransfer model)
{
using (var context = _contextFactory.CreateDataContext())
{
var entity = TransferEventDataEntity.Create(model);
await context.TransferEventsData.AddAsync(entity);
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateException e)
{
if (e.InnerException is PostgresException sqlException &&
sqlException.SqlState == PostgresErrorCodes.UniqueViolation)
{
_log.Warning("Error on transfer event context saving", e);
}
public async Task <FriendReferralHistory> GetAllReferralsForCustomerAsync(Guid customerId)
{
using (var context = _msSqlContextFactory.CreateDataContext())
{
var referrals = await context.FriendReferrals
.Where(c => c.ReferrerId == customerId)
.ToListAsync();
return(new FriendReferralHistory
{
ReferrerId = customerId.ToString("D"),
ReferredIds = referrals
.Where(e => e.ReferredId.HasValue)
.Select(e => e.ReferredId.Value.ToString("D"))
.ToList()
.AsReadOnly()
});
}
}
public async Task <IWalletFlags> CreateOrUpdateAsync(string customerId, bool isBlocked)
{
var entity = WalletFlagsEntity.Create(customerId, isBlocked);
using (var context = _contextFactory.CreateDataContext())
{
await context.WalletFlags.AddAsync(entity);
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateException e)
{
if (e.InnerException is PostgresException sqlException &&
sqlException.SqlState == PostgresErrorCodes.UniqueViolation)
{
context.WalletFlags.Update(entity);
await context.SaveChangesAsync();
}
public async Task <long> GetNextNonceAsync(string masterWalletAddress, TransactionContext txContext)
{
using (var context = _contextFactory.CreateDataContext(txContext))
{
var nonce = await context.Nonces.FirstOrDefaultAsync(x => x.MasterWalletAddress == masterWalletAddress);
if (nonce == null)
{
nonce = NonceEntity.Create(masterWalletAddress, 0);
context.Add(nonce);
}
else
{
nonce.Nonce += 1;
context.Update(nonce);
}
await context.SaveChangesAsync();
return(nonce.Nonce);
}
}
public async Task <(string Data, string Hash)> GetOrCreateOperationAsync(string operationId)
{
using (var context = _contextFactory.CreateDataContext())
{
var operation = await context.Operations.FindAsync(operationId);
if (operation == null)
{
operation = new OperationEntity
{
Id = operationId,
LastUpdated = DateTime.UtcNow,
OperationStatus = OperationStatus.Created
};
context.Operations.Add(operation);
await context.SaveChangesAsync();
}
return(operation.TransactionData, operation.TransactionHash);
}
}
public async Task <ReferralLeadEncrypted> CreateAsync(ReferralLeadEncrypted referralLeadEncrypted)
{
using (var context = _msSqlContextFactory.CreateDataContext())
{
var entity = _mapper.Map <ReferralLeadEntity>(referralLeadEncrypted);
entity.CreationDateTime = DateTime.UtcNow;
await context.AddAsync(entity);
await context.SaveChangesAsync();
return(_mapper.Map <ReferralLeadEncrypted>(entity));
}
}
