private IList<ValueTuple<Checksum, object>> ReadAssets(
Stream stream, int sessionId, ISet<Checksum> checksums, CancellationToken cancellationToken)
{
var results = new List<ValueTuple<Checksum, object>>();
using (var reader = StreamObjectReader.TryGetReader(stream))
{
Debug.Assert(reader != null,
@"We only ge a reader for data transmitted between live processes.
This data should always be correct as we're never persisting the data between sessions.");
var responseSessionId = reader.ReadInt32();
Contract.ThrowIfFalse(sessionId == responseSessionId);
var count = reader.ReadInt32();
Contract.ThrowIfFalse(count == checksums.Count);
for (var i = 0; i < count; i++)
{
var responseChecksum = new Checksum(reader.ReadArray<byte>());
Contract.ThrowIfFalse(checksums.Contains(responseChecksum));
var kind = reader.ReadString();
// in service hub, cancellation means simply closed stream
var @object = _owner.RoslynServices.AssetService.Deserialize<object>(kind, reader, cancellationToken);
results.Add(ValueTuple.Create(responseChecksum, @object));
}
return results;
}
}
public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
{
var currentSolution = s_primaryWorkspace.CurrentSolution;
var primarySolutionChecksum = await currentSolution.State.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
if (primarySolutionChecksum == solutionChecksum)
{
// nothing changed
return currentSolution;
}
var lastSolution = s_lastSolution;
if (lastSolution?.Item1 == solutionChecksum)
{
return lastSolution.Item2;
}
// make sure there is always only one that creates a new solution
using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
{
if (s_lastSolution?.Item1 == solutionChecksum)
{
return s_lastSolution.Item2;
}
var solution = await CreateSolution_NoLockAsync(solutionChecksum, currentSolution, cancellationToken).ConfigureAwait(false);
s_lastSolution = Tuple.Create(solutionChecksum, solution);
return solution;
}
}
public async Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
{
var currentSolution = s_primaryWorkspace.CurrentSolution;
var primarySolutionChecksum = await currentSolution.State.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
if (primarySolutionChecksum == solutionChecksum)
{
// nothing changed
return;
}
using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
{
var updater = new SolutionCreator(_assetService, currentSolution, cancellationToken);
if (await updater.IsIncrementalUpdateAsync(solutionChecksum).ConfigureAwait(false))
{
// solution has updated
s_primaryWorkspace.UpdateSolution(await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false));
return;
}
// new solution. bulk sync all asset for the solution
await _assetService.SynchronizeSolutionAssetsAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
s_primaryWorkspace.ClearSolution();
s_primaryWorkspace.AddSolution(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
}
}
public ChecksumObject GetChecksumObject(Checksum checksum, CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.SolutionChecksumServiceFactory_GetChecksumObject, GetChecksumLogInfo, checksum, cancellationToken))
{
return _caches.GetChecksumObject(checksum, cancellationToken);
}
}
private IList<ValueTuple<Checksum, object>> ReadAssets(
Stream stream, int sessionId, ISet<Checksum> checksums, CancellationToken cancellationToken)
{
var results = new List<ValueTuple<Checksum, object>>();
using (var reader = new ObjectReader(stream))
{
var responseSessionId = reader.ReadInt32();
Contract.ThrowIfFalse(sessionId == responseSessionId);
var count = reader.ReadInt32();
Contract.ThrowIfFalse(count == checksums.Count);
for (var i = 0; i < count; i++)
{
var responseChecksum = new Checksum(reader.ReadArray<byte>());
Contract.ThrowIfFalse(checksums.Contains(responseChecksum));
var kind = reader.ReadString();
// in service hub, cancellation means simply closed stream
var @object = _owner.RoslynServices.AssetService.Deserialize<object>(kind, reader, cancellationToken);
results.Add(ValueTuple.Create(responseChecksum, @object));
}
return results;
}
}
public async Task<Compilation> GetCompilationAsync(Checksum solutionChecksum, ProjectId projectId, CancellationToken cancellationToken)
{
var solution = await RoslynServices.SolutionService.GetSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
// TODO: need to figure out how to deal with exceptions in service hub
return await solution.GetProject(projectId).GetCompilationAsync(cancellationToken).ConfigureAwait(false);
}
public RemotableData GetRemotableData(Checksum checksum, CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.PinnedRemotableDataScope_GetRemotableData, Checksum.GetChecksumLogInfo, checksum, cancellationToken))
{
return _storages.GetRemotableData(this, checksum, cancellationToken);
}
}
public RemotableData GetRemotableData(Checksum checksum, CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.SolutionSynchronizationService_GetRemotableData, Checksum.GetChecksumLogInfo, checksum, cancellationToken))
{
return _assetStorages.GetRemotableData(scope: null, checksum: checksum, cancellationToken: cancellationToken);
}
}
public async Task SynchronizeProjectAssetsAsync(Checksum projectChecksum, CancellationToken cancellationToken)
{
using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
using (var pooledObject = SharedPools.Default<HashSet<Checksum>>().GetPooledObject())
{
var checksums = pooledObject.Object;
var projectChecksumObject = await _assetService.GetAssetAsync<ProjectStateChecksums>(projectChecksum, cancellationToken).ConfigureAwait(false);
AddIfNeeded(checksums, projectChecksumObject.Children);
foreach (var checksum in projectChecksumObject.Documents)
{
var documentChecksumObject = await _assetService.GetAssetAsync<DocumentStateChecksums>(checksum, cancellationToken).ConfigureAwait(false);
AddIfNeeded(checksums, documentChecksumObject.Children);
}
foreach (var checksum in projectChecksumObject.AdditionalDocuments)
{
var documentChecksumObject = await _assetService.GetAssetAsync<DocumentStateChecksums>(checksum, cancellationToken).ConfigureAwait(false);
AddIfNeeded(checksums, documentChecksumObject.Children);
}
await _assetService.SynchronizeAssetsAsync(checksums, cancellationToken).ConfigureAwait(false);
}
}
public ChecksumObject GetChecksumObject(Checksum checksum, CancellationToken cancellationToken)
{
// search snapshots we have
foreach (var cache in _rootTreeNodes.Values)
{
var checksumObject = cache.TryGetChecksumObject(checksum, cancellationToken);
if (checksumObject != null)
{
return checksumObject;
}
}
// search global assets
foreach (var asset in _globalAssets.Values)
{
cancellationToken.ThrowIfCancellationRequested();
if (asset.Checksum == checksum)
{
return asset;
}
}
// as long as solution snapshot is pinned. it must exist in one of the trees.
throw ExceptionUtilities.UnexpectedValue(checksum);
}
public void ChecksumTestUnsupportedAlg()
{
Checksum task = new Checksum();
task.BuildEngine = new MockBuild();
task.Files = TaskUtility.StringArrayToItemArray( inputFiles );
task.Algorithm = "foo";
Assert.IsFalse( task.Execute(), "Execute Failed" );
}
public async Task<Compilation> GetCompilationAsync(Checksum solutionChecksum, ProjectId projectId, CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.CompilationService_GetCompilationAsync, GetLogInfo, solutionChecksum, projectId, cancellationToken))
{
var solution = await RoslynServices.SolutionService.GetSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
return await solution.GetProject(projectId).GetCompilationAsync(cancellationToken).ConfigureAwait(false);
}
}
public void ChecksumTestSHA1()
{
Checksum task = new Checksum();
task.BuildEngine = new MockBuild();
task.Files = TaskUtility.StringArrayToItemArray( inputFiles );
task.Algorithm = "SHA1";
Assert.IsTrue( task.Execute(), "Execute Failed" );
}
public virtual void Initialize(int sessionId, byte[] solutionChecksum)
{
// set session related information
_sessionId = sessionId;
if (solutionChecksum != null)
{
_solutionChecksumOpt = new Checksum(solutionChecksum);
}
}
public PinnedRemotableDataScope(
AssetStorages storages,
AssetStorages.Storage storage,
Checksum solutionChecksum)
{
_storages = storages;
_storage = storage;
SolutionChecksum = solutionChecksum;
_storages.RegisterSnapshot(this, storage);
}
public void TestGetAssets()
{
var storage = new AssetStorage();
var checksum = new Checksum(Guid.NewGuid().ToByteArray());
var data = new object();
Assert.True(storage.TryAddAsset(checksum, data));
object stored;
Assert.True(storage.TryGetAsset(checksum, out stored));
}
private static Exception ReadFileHeader(Stream stream, long mStreamLength, out byte mMajorVersion, out byte mMinorVersion, out long mMetadataOffset, out long mMetadataLength, out Checksum mMetadataChecksum)
{
mMajorVersion = 0;
mMinorVersion = 0;
mMetadataOffset = 0;
mMetadataLength = 0;
mMetadataChecksum = default(Checksum);
var header = new byte[ArchiveMetadataFormat.kHeaderLength];
int offset = 0;
do
{
int result = stream.Read(header, offset, ArchiveMetadataFormat.kHeaderLength - offset);
if (result <= 0)
return new EndOfStreamException();
offset += result;
}
while (offset < ArchiveMetadataFormat.kHeaderLength);
for (int i = 0; i < 6; i++)
if (header[i] != ArchiveMetadataFormat.kFileSignature[i])
return new InvalidDataException("File is not a 7z archive.");
mMajorVersion = header[6];
mMinorVersion = header[7];
if (mMajorVersion != 0)
return new InvalidDataException("Invalid header version.");
mMetadataOffset = GetInt64(header, 12);
mMetadataLength = GetInt64(header, 20);
mMetadataChecksum = new Checksum(GetInt32(header, 28));
uint crc = CRC.kInitCRC;
crc = CRC.Update(crc, mMetadataOffset);
crc = CRC.Update(crc, mMetadataLength);
crc = CRC.Update(crc, mMetadataChecksum.Value);
crc = CRC.Finish(crc);
if ((int)crc != GetInt32(header, 8))
return new InvalidDataException("Invalid header checksum.");
if (mMetadataOffset < header.Length || mMetadataOffset > mStreamLength - ArchiveMetadataFormat.kHeaderLength)
return new InvalidDataException("Invalid metadata offset.");
if (mMetadataLength < 0 || mMetadataLength > mStreamLength - ArchiveMetadataFormat.kHeaderLength - mMetadataOffset)
return new InvalidDataException("Invalid metadata length.");
return null;
}
public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, OptionSet optionSet, CancellationToken cancellationToken)
{
// since option belong to workspace, we can't share solution
// create new solution
var solution = await CreateSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
// set merged options
solution.Workspace.Options = MergeOptions(solution.Workspace.Options, optionSet);
// return new solution
return solution;
}
public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
{
if (s_lastSolution.Item1 == solutionChecksum)
{
return s_lastSolution.Item2;
}
// create new solution
var solution = await CreateSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
// save it
s_lastSolution = ValueTuple.Create(solutionChecksum, solution);
return solution;
}
public void TestGetAssets()
{
var sessionId = 0;
var storage = new AssetStorage(enableCleanup: false);
var source = new MyAssetSource(storage, sessionId);
var checksum = new Checksum(Guid.NewGuid().ToByteArray());
var data = new object();
Assert.True(storage.TryAddAsset(checksum, data));
object stored;
Assert.True(storage.TryGetAsset(checksum, out stored));
}
public static RemotableData Create(Checksum checksum, object value, Serializer serializer)
{
// treat SourceText specially since we get TextDocumentState rather than SourceText when searching the checksum
// from solution due to it requiring async-ness when retrieving SourceText.
//
// right now, SourceText is the only one that requires async-ness and making all calls async just for this
// one makes us to have a lot of unnecessary allocations due to Task and overall slow down of several seconds.
//
// all calls used to be all async and converted back to synchronous due to all those unnecessary overhead of tasks.
if (value is TextDocumentState)
{
return new SourceTextAsset(checksum, (TextDocumentState)value, serializer);
}
return new SimpleSolutionAsset(checksum, value, serializer);
}
public DiagnosticArguments(
bool reportSuppressedDiagnostics,
bool logAnalyzerExecutionTime,
ProjectId projectId,
Checksum optionSetChecksum,
ImmutableArray<Checksum> hostAnalyzerChecksums,
string[] analyzerIds)
{
ReportSuppressedDiagnostics = reportSuppressedDiagnostics;
LogAnalyzerExecutionTime = logAnalyzerExecutionTime;
ProjectId = projectId;
OptionSetChecksum = optionSetChecksum;
HostAnalyzerChecksums = hostAnalyzerChecksums.ToArray();
AnalyzerIds = analyzerIds;
}
public override async Task<object> RequestAssetAsync(int serviceId, Checksum checksum, CancellationToken callerCancellationToken)
{
// it should succeed as long as matching VS is alive
// TODO: add logging mechanism using Logger
// this can be called in two ways.
// 1. Connection to get asset is closed (the asset source we were using is disconnected - _assetChannelCancellationToken)
// if this asset source's channel is closed, service will move to next asset source to get the asset as long as callerCancellationToken
// is not cancelled
//
// 2. Request to required this asset has cancelled. (callerCancellationToken)
using (var mergedCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(_assetChannelCancellationToken, callerCancellationToken))
{
return await _rpc.InvokeAsync(WellKnownServiceHubServices.AssetService_RequestAssetAsync,
new object[] { serviceId, checksum.ToArray() },
(s, c) => ReadAssetAsync(s, _logger, serviceId, checksum, c), mergedCancellationToken.Token).ConfigureAwait(false);
}
}
public async Task SynchronizeSolutionAssetsAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
{
using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
{
// this will make 4 round trip to data source (VS) to get all assets that belong to the given solution checksum
// first, get solution checksum object for the given solution checksum
var solutionChecksumObject = await _assetService.GetAssetAsync<SolutionStateChecksums>(solutionChecksum, cancellationToken).ConfigureAwait(false);
// second, get direct children of the solution
await SynchronizeSolutionAsync(solutionChecksumObject, cancellationToken).ConfigureAwait(false);
// third, get direct children for all projects in the solution
await SynchronizeProjectsAsync(solutionChecksumObject, cancellationToken).ConfigureAwait(false);
// last, get direct children for all documents in the solution
await SynchronizeDocumentsAsync(solutionChecksumObject, cancellationToken).ConfigureAwait(false);
}
}
public async Task TestAssets()
{
var sessionId = 0;
var checksum = new Checksum(Guid.NewGuid().ToByteArray());
var data = new object();
var storage = new AssetStorage();
var source = new TestAssetSource(storage, sessionId, checksum, data);
var service = new AssetService(sessionId, storage);
var stored = await service.GetAssetAsync<object>(checksum, CancellationToken.None);
Assert.Equal(data, stored);
var stored2 = await service.GetAssetsAsync<object>(new[] { checksum }, CancellationToken.None);
Assert.Equal(1, stored2.Count);
Assert.Equal(checksum, stored2[0].Item1);
Assert.Equal(data, stored2[0].Item2);
}
private static Task<object> ReadAssetAsync(
Stream stream, TraceSource logger, int serviceId, Checksum checksum, CancellationToken cancellationToken)
{
using (var reader = new ObjectReader(stream))
{
var responseServiceId = reader.ReadInt32();
Contract.ThrowIfFalse(serviceId == responseServiceId);
var responseChecksum = new Checksum(reader.ReadArray<byte>());
Contract.ThrowIfFalse(checksum == responseChecksum);
var kind = reader.ReadString();
// in service hub, cancellation means simply closed stream
var @object = RoslynServices.AssetService.Deserialize<object>(kind, reader, cancellationToken);
return Task.FromResult(@object);
}
}
public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, OptionSet optionSet, CancellationToken cancellationToken)
{
if (optionSet == null)
{
return await GetSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
}
// get solution
var baseSolution = await GetSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
// since options belong to workspace, we can't share solution
// create temporary workspace
var tempWorkspace = new TemporaryWorkspace(baseSolution);
// set merged options
tempWorkspace.Options = MergeOptions(tempWorkspace.Options, optionSet);
// return new solution
return tempWorkspace.CurrentSolution;
}
public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
{
if (s_lastSolution.Item1 == solutionChecksum)
{
return s_lastSolution.Item2;
}
// make sure there is always only one that creates a new solution
using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
{
if (s_lastSolution.Item1 == solutionChecksum)
{
return s_lastSolution.Item2;
}
var solution = await CreateSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
s_lastSolution = ValueTuple.Create(solutionChecksum, solution);
return solution;
}
}
public RemotableData GetRemotableData(PinnedRemotableDataScope scope, Checksum checksum, CancellationToken cancellationToken)
{
if (checksum == Checksum.Null)
{
// check nil case
return RemotableData.Null;
}
// search snapshots we have
foreach (var storage in GetStorages(scope))
{
var syncObject = storage.TryGetRemotableData(checksum, cancellationToken);
if (syncObject != null)
{
return syncObject;
}
}
// search global assets
foreach (var kv in _globalAssets)
{
cancellationToken.ThrowIfCancellationRequested();
var asset = kv.Value;
if (asset.Checksum == checksum)
{
return asset;
}
}
// if it reached here, it means things get cancelled. due to involving 2 processes,
// current design can make slightly staled requests to running even when things cancelled.
// if it is other case, remote host side will throw and close connection which will cause
// vs to crash.
// this should be changed once I address this design issue
cancellationToken.ThrowIfCancellationRequested();
return null;
}
public async Task SynchronizePrimaryWorkspaceAsync(byte[] solutionChecksum)
{
var checksum = new Checksum(solutionChecksum);
using (RoslynLogger.LogBlock(FunctionId.RemoteHostService_Synchronize, c => c.ToString(), checksum, CancellationToken))
{
try
{
await RoslynServices.SolutionService.UpdatePrimaryWorkspaceAsync(checksum, CancellationToken).ConfigureAwait(false);
}
catch (IOException)
{
// stream to send over assets has closed before we
// had chance to check cancellation
}
catch (OperationCanceledException)
{
// rpc connection has closed.
// this can happen if client side cancelled the
// operation
}
}
}
/// <summary>
/// Post process payment (used by payment gateways that require redirecting to a third-party URL)
/// </summary>
/// <param name="postProcessPaymentRequest">Payment info required for an order processing</param>
public void PostProcessPayment(PostProcessPaymentRequest postProcessPaymentRequest)
{
//create common query parameters for the request
var queryParameters = new Dictionary <string, string>();// CreateQueryParameters(postProcessPaymentRequest); //mayank
//whether to include order items in a transaction
/*if (_PaytmPaymentSettings.PassProductNamesAndTotals) //mayank
* {
* //add order items query parameters to the request
* var parameters = new Dictionary<string, string>(queryParameters);
* AddItemsParameters(parameters, postProcessPaymentRequest);
*
* //remove null values from parameters
* parameters = parameters.Where(parameter => !string.IsNullOrEmpty(parameter.Value))
* .ToDictionary(parameter => parameter.Key, parameter => parameter.Value);
*
* //ensure redirect URL doesn't exceed 2K chars to avoid "too long URL" exception
* var redirectUrl = QueryHelpers.AddQueryString(GetPaytmUrl(), parameters);
* if (redirectUrl.Length <= 2048)
* {
* _httpContextAccessor.HttpContext.Response.Redirect(redirectUrl);
* return;
* }
* }*/
//or add only an order total query parameters to the request
string mid, mkey, amount, orderid;
mid = _paytmPaymentSettings.MerchantId.Trim().ToString();
mkey = _paytmPaymentSettings.MerchantKey.Trim().ToString();
amount = postProcessPaymentRequest.Order.OrderTotal.ToString("0.00");
orderid = postProcessPaymentRequest.Order.Id.ToString();
queryParameters.Add("MID", _paytmPaymentSettings.MerchantId.Trim().ToString());
queryParameters.Add("WEBSITE", _paytmPaymentSettings.Website.Trim().ToString());
queryParameters.Add("CHANNEL_ID", "WEB");
queryParameters.Add("INDUSTRY_TYPE_ID", _paytmPaymentSettings.IndustryTypeId.Trim().ToString());
queryParameters.Add("TXN_AMOUNT", postProcessPaymentRequest.Order.OrderTotal.ToString("0.00"));
queryParameters.Add("ORDER_ID", postProcessPaymentRequest.Order.Id.ToString());
queryParameters.Add("EMAIL", postProcessPaymentRequest.Order.BillingAddress.Email);
queryParameters.Add("MOBILE_NO", postProcessPaymentRequest.Order.BillingAddress.PhoneNumber);
queryParameters.Add("CUST_ID", postProcessPaymentRequest.Order.BillingAddress.Email);
if (_paytmPaymentSettings.UseDefaultCallBack)
{
queryParameters.Add("CALLBACK_URL", _webHelper.GetStoreLocation(false) + "Plugins/PaymentPaytm/Return");
}
else
{
queryParameters.Add("CALLBACK_URL", _paytmPaymentSettings.CallBackUrl.Trim());
}
//queryParameters.Add("CHECKSUMHASH",
// paytm.CheckSum.generateCheckSum(_paytmPaymentSettings.MerchantKey, queryParameters));
queryParameters.Add("CHECKSUMHASH",
Checksum.generateSignature(queryParameters, _paytmPaymentSettings.MerchantKey));
string txntoken = GetTxnToken(amount, mid, orderid, mkey);
//AddOrderTotalParameters(queryParameters, postProcessPaymentRequest);
//remove null values from parameters
queryParameters = queryParameters.Where(parameter => !string.IsNullOrEmpty(parameter.Value))
.ToDictionary(parameter => parameter.Key, parameter => parameter.Value);
string scheme = _httpContextAccessor.HttpContext.Request.Scheme;
string host = _httpContextAccessor.HttpContext.Request.Host.ToString();
_httpContextAccessor.HttpContext.Response.Cookies.Append("token", txntoken);
_httpContextAccessor.HttpContext.Response.Cookies.Append("orderid", orderid);
_httpContextAccessor.HttpContext.Response.Cookies.Append("amount", amount);
_httpContextAccessor.HttpContext.Response.Cookies.Append("mid", mid);
var url = QueryHelpers.AddQueryString(GetPaytmUrl(), queryParameters);
// _httpContextAccessor.HttpContext.Response.Redirect(url);
var absoluteUri = string.Concat(scheme, "://", host, "/Plugins/PaymentPaytm/JSCheckoutView");
_httpContextAccessor.HttpContext.Response.Redirect(absoluteUri);
}
void AddChecksum(byte[] bytes)
{
checksum = Checksum.GetChecksum(bytes, checksum);
}
public UnitTestingChecksumWrapper(Checksum underlyingObject) =>
public Task SynchronizeTextAsync(DocumentId documentId, Checksum baseTextChecksum, IEnumerable <TextChange> textChanges, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (RoslynLogger.LogBlock(FunctionId.RemoteHostService_SynchronizeTextAsync, Checksum.GetChecksumLogInfo, baseTextChecksum, cancellationToken))
{
var service = SolutionService.PrimaryWorkspace.Services.GetService <ISerializerService>();
if (service == null)
{
return;
}
var text = await TryGetSourceTextAsync().ConfigureAwait(false);
if (text == null)
{
// it won't bring in base text if it is not there already.
// text needed will be pulled in when there is request
return;
}
var newText = new WrappedText(text.WithChanges(textChanges));
var newChecksum = service.CreateChecksum(newText, cancellationToken);
// save new text in the cache so that when asked, the data is most likely already there
//
// this cache is very short live. and new text created above is ChangedText which share
// text data with original text except the changes.
// so memory wise, this doesn't put too much pressure on the cache. it will not duplicates
// same text multiple times.
//
// also, once the changes are picked up and put into Workspace, normal Workspace
// caching logic will take care of the text
AssetStorage.TryAddAsset(newChecksum, newText);
}
async Task <SourceText> TryGetSourceTextAsync()
{
// check the cheap and fast one first.
// see if the cache has the source text
if (AssetStorage.TryGetAsset <SourceText>(baseTextChecksum, out var sourceText))
{
return sourceText;
}
// do slower one
// check whether existing solution has it
var document = SolutionService.PrimaryWorkspace.CurrentSolution.GetDocument(documentId);
if (document == null)
{
return null;
}
// check checksum whether it is there.
// since we lazily synchronize whole solution (SynchronizePrimaryWorkspaceAsync) when things are idle,
// soon or later this will get hit even if text changes got out of sync due to issues in VS side
// such as file is first opened and there is no SourceText in memory yet.
if (!document.State.TryGetStateChecksums(out var state) ||
!state.Text.Equals(baseTextChecksum))
{
return null;
}
return await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
}
}, cancellationToken));
}
private string GetTxnToken(string amount, string mid, string orderid, string mkey)
{
APIResponse apiresponse = new APIResponse();
Dictionary <string, object> body = new Dictionary <string, object>();
Dictionary <string, string> head = new Dictionary <string, string>();
Dictionary <string, object> requestBody = new Dictionary <string, object>();
Dictionary <string, string> txnAmount = new Dictionary <string, string>();
string scheme = _httpContextAccessor.HttpContext.Request.Scheme;
string host = _httpContextAccessor.HttpContext.Request.Host.ToString();
string displayToken = string.Empty;
txnAmount.Add("value", amount);
txnAmount.Add("currency", "INR");
Dictionary <string, string> userInfo = new Dictionary <string, string>();
userInfo.Add("custId", "cust_001");
body.Add("requestType", "Payment");
body.Add("mid", mid);
body.Add("websiteName", _paytmPaymentSettings.Website.Trim().ToString());
body.Add("orderId", orderid);
body.Add("txnAmount", txnAmount);
body.Add("userInfo", userInfo);
body.Add("callbackUrl", string.Concat(scheme, "://", host, "/Plugins/PaymentPaytm/Return"));
/*
* Generate checksum by parameters we have in body
* Find your Merchant Key in your Paytm Dashboard at https://dashboard.paytm.com/next/apikeys
*/
string paytmChecksum = Checksum.generateSignature(JsonConvert.SerializeObject(body), mkey);
head.Add("signature", paytmChecksum);
requestBody.Add("body", body);
requestBody.Add("head", head);
string post_data = JsonConvert.SerializeObject(requestBody);
string url = string.Empty;
if (_paytmPaymentSettings.env == "Stage")
{
//For Staging
url = "https://securegw-stage.paytm.in/theia/api/v1/initiateTransaction?mid=" + mid + "&orderId=" + orderid + " ";
}
if (_paytmPaymentSettings.env == "Prod")
{
//For Production
url = "https://securegw.paytm.in/theia/api/v1/initiateTransaction?mid=" + mid + "&orderId=" + orderid + "";
}
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url);
webRequest.Method = "POST";
webRequest.ContentType = "application/json";
webRequest.ContentLength = post_data.Length;
using (StreamWriter requestWriter = new StreamWriter(webRequest.GetRequestStream()))
{
requestWriter.Write(post_data);
}
string responseData = string.Empty;
using (StreamReader responseReader = new StreamReader(webRequest.GetResponse().GetResponseStream()))
{
responseData = responseReader.ReadToEnd();
apiresponse = JsonConvert.DeserializeObject <APIResponse>(responseData);
JObject jObject = JObject.Parse(responseData);
displayToken = jObject.SelectToken("body.txnToken").Value <string>();
// Console.WriteLine(responseData);
}
return(displayToken);
}
