private async Task <string> RunSproAsync(string sessionType, string username)
{
try
{
var spro = await GetOrCreateSproServiceInstanceAsync(sessionType, username);
var fabricClient = new FabricClient();
var channel = new Channel(spro.Ip, spro.Port, ChannelCredentials.Insecure);
var client = new NativeSession.NativeSessionClient(channel);
var request = new GenerateRequest
{
Username = username,
Type = sessionType,
Payload = DateTime.Now.Ticks.ToString()
};
var generateReply = await client.GenerateAsync(request, new CallOptions());
var response = generateReply.Response;
await channel.ShutdownAsync();
return(response);
} catch (Exception e)
{
throw;
}
}
public string GetPaymentExpressHostUrl(PaymentUrl paymentUrl, Order order)
{
string url = "";
var paymentProxy = new PaymentProxy()
{
Account = new Account()
{
PaymentGatewayUrl = _appSettings.RequestUrl,
PxPayUserId = _appSettings.PxPayUserId,
PxPayKey = _appSettings.PxPayKey,
PaymentGatewayUrlSuccess = paymentUrl.Success,
PaymentGatewayUrlFail = paymentUrl.Fail
}
};
var generateRequest = new GenerateRequest()
{
TxnType = TxnType.Purchase,
AmountInput = (decimal)order.Total,
CurrencyInput = Currency.NZD,
MerchantReference = order.OrderId.ToString(),
TxnData1 = order.UserName,
//TxnData2 = order.UserId.ToString(),
//TxnData3 = order.SubTotal.ToString(),
EmailAddress = order.UserEmail
};
url = paymentProxy.RequestUrl(generateRequest);
return(url);
}
internal void OpenCreateReguestForm_Click(object sender, RoutedEventArgs e)
{
string header0 = "Create Request";
IEnumerable <TabablzControl> tctrl;
GetTabablzData(out header0, out tctrl);
header0 = "Create Request";
GenerateRequest gr = new GenerateRequest();
if (loadedUserForm == null || loadedUserForm != gr)
{
loadedUserForm = gr;
}
//mainGrid.Child = loadedUserForm;
//TabContent tc1 = new TabContent("Create Request", loadedUserForm);
TabContent tc1 = new TabContent(header0, loadedUserForm);
AddTabablzData(header0, tctrl, tc1);
//MenuItem mi = (MenuItem)sender;
//sbiSelectedMenuOption.Content = mi.Header;
sbiSelectedMenuOption.Content = header0;
}
public Stream Download(GenerateRequest request)
{
var tempRoot = Path.GetTempPath();
if (!Directory.Exists(tempRoot))
{
Directory.CreateDirectory(tempRoot);
}
var tempFile = Path.Combine(tempRoot, $"{Guid.NewGuid().ToString()}.zip");
var tempDir = Path.Combine(tempRoot, $"{Guid.NewGuid().ToString()}");
try
{
return(CreateDownloadStream(request, tempFile, tempDir));
}
catch (Exception e)
{
ErrorService.LogException(e, request.Data);
return(null);
}
finally
{
TryToDeleteDirectory(tempDir);
TryToDeleteFile(tempFile);
}
}
private VirtualDisk LoadStaticFiles(GenerateRequest request)
{
var backendDisk = GetServerPlugin(request).Files;
var frontendDisk = GetClientPlugin(request).Files;
var virtualDisk = SetNamespace(backendDisk, request.NameSpace);
Mount(virtualDisk, frontendDisk, "ClientApp");
return(virtualDisk);
}
/// <summary>
/// Get the link that has been generated before.
/// </summary>
/// <param name="request">The request from <see cref="GenerateLink"/></param>
/// <returns>Return the generated link if there are any, otherwise <see langword="null"/>.</returns>
protected Link GetDuplicatedLink(GenerateRequest request)
{
return(ctx.Link.Where(
l =>
l.RedirectURL == new Uri(request.Url) && // the redirect url is same, and
l.Password == request.Password && // the password is same
request.CustomId == null
).FirstOrDefault());
}
public async Task <GenerateResponse> Generate(GenerateRequest request)
{
if (!(request is GenerateReferralsRequest r))
{
throw new InvalidOperationException($"{nameof(ISupportGenerationStrategy)} of type {nameof(SingleDocumentStrategy)} can only handle {nameof(GenerateReferralsRequest)} request types");
}
return(await GenerateSingleReferralDocument(r));
}
public Task Generate([FromBody] GenerateRequest request)
{
return(_interlocutorsGenerator.Generate(request.Url,
request.AccessToken,
request.CampaignId,
request.GroupId,
request.InterlocutorsCount,
request.HaveConstSentences));
}
public IActionResult Generate([FromBody] GenerateRequest request)
{
var response = service.Generate(request);
#if DEBUG
Thread.Sleep(1500);
#endif
return(Ok(response));
}
public ActionResult <String> generate(GenerateRequest request)
{
User user = _authService.CheckUserPassword(request.Username, request.Password);
if (user == null)
{
return(Unauthorized());
}
return(_tokenService.generateToken(user));
}
public IHttpActionResult Generate(GenerateRequest request)
{
var email = request.Email;
var result = GenerateUserResetPassword.Generate(email);
return(Ok(new
{
success = result.Status == WebGenerateUserResetPasswordStatus.Success || result.Status == WebGenerateUserResetPasswordStatus.UserNotFound
}));
}
public ActionResult <GenericResponse <GenerateResponse> > GenerateLink([FromBody] GenerateRequest request)
{
string newShortenLink = Consts.NewShortenLink;
Uri redirectURL;
Link link;
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (GetLinkWithSameId(request.CustomId) != null)
{
return(BadRequest(PredefinedErrors.IdHasBeenTaken));
}
while (GetLinkWithSameId(newShortenLink) != null)
{
newShortenLink = Consts.NewShortenLink;
}
try
{
redirectURL = new Uri(request.Url);
link = GetDuplicatedLink(request);
}
catch (UriFormatException)
{
return(BadRequest(PredefinedErrors.BadUrl));
}
if (link == null)
{
link = new Link
{
LinkBrowseId = request.CustomId ?? newShortenLink,
Password = request.Password ?? null,
RedirectURL = redirectURL,
Stat = new Stat()
};
ctx.Link.Add(link);
ctx.SaveChanges();
}
return(new GenericResponse <GenerateResponse>
{
Data = new GenerateResponse
{
Id = link.LinkBrowseId,
Password = link.Password
}
});
}
/// <summary>
/// Generates the specified maze by the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException"></exception>
public Maze GenerateMaze(GenerateRequest request)
{
// if there is a maze with this name
if (mazes.ContainsKey(request.MazeName))
{
throw new InvalidOperationException(string.Format("Maze with the name \"{0}\" already exists!", request.MazeName));
}
Maze m = mazeGen.Generate(request.Rows, request.Columns);
m.Name = request.MazeName;
mazes[request.MazeName] = m;
return(m);
}
public IActionResult Download([FromBody] GenerateRequest request)
{
var result = service.Download(request);
if (result == null)
{
return(BadRequest());
}
#if DEBUG
Thread.Sleep(1500);
#endif
return(File(result, "application/zip", $"{request.NameSpace}.zip"));
}
private Tuple <ServerProject, ClientProject> InitProject(GenerateRequest request, IDisk serverDisk, IDisk clientDisk)
{
DataModel dataModel = new DataModel();
var jObject = JObject.Parse(request.Data, new JsonLoadSettings {
CommentHandling = CommentHandling.Load, DuplicatePropertyNameHandling = DuplicatePropertyNameHandling.Error
});
dataModel.Load(jObject);
var collection = new ResourceCollection(dataModel);
var userClass = dataModel.Classes.FirstOrDefault(c => c.Name == "User");
if (userClass == null)
{
throw new Exception("The model must contain a user class.");
}
if (userClass.Properties.Any(p => p.Name == "PasswordHash" || p.Name == "Password"))
{
throw new Exception("You must not explicitly set passwords for users. A password hash will be automatically added to the user class.");
}
CheckMandatoryUserProperty(userClass, "Email");
CheckMandatoryUserProperty(userClass, "UserName");
userClass.Properties.Add(new Property
{
Name = "PasswordHash",
IsServerOnly = true,
BuiltInType = BuiltInType.String
});
var seedStore = new SeedDataStore(collection);
seedStore.Load(jObject);
var serverPlugin = GetServerPlugin(request);
var serverProject = new ServerProject
{
Config = serverPlugin.Config,
Disk = serverDisk,
ResourceCollection = collection,
SeedStore = seedStore,
Templates = serverPlugin.Templates
};
var clientPlugin = GetClientPlugin(request);
var clientProject = new ClientProject
{
Config = clientPlugin.Config,
Disk = clientDisk,
ResourceCollection = collection,
SeedStore = seedStore,
Templates = clientPlugin.Templates
};
return(Tuple.Create(serverProject, clientProject));
}
public GenerateResponse Generate(GenerateRequest request)
{
try
{
var virtualDisk = LoadStaticFiles(request);
var clientDisk = new VirtualDisk();
(var serverProject, var clientProject) = InitProject(request, virtualDisk, clientDisk);
serverProject.GenerateFiles(request.NameSpace, "http://localhost:5000");
clientProject.GenerateFiles(request.NameSpace, "http://localhost:5000");
virtualDisk.Mount(clientDisk, "ClientApp/src");
var files = new List <GeneratedFile>();
foreach (var file in virtualDisk.Files)
{
files.Add(new GeneratedFile
{
Name = file.Name,
Path = file.Path.Replace("\\", "/"),
Content = file.Content
});
}
StatisticsService.OnGenerated(serverProject.ResourceCollection.DataModel, request.Data, StatEvent.Generate);
return(new GenerateResponse
{
Success = true,
GeneratedFiles = files
});
}
catch (Exception e)
{
if (!(e is JsonReaderException))
{
ErrorService.LogException(e, request.Data);
}
return(new GenerateResponse
{
Success = false,
ErrorMessage = e.Message,
ErrorLine = e is JsonReaderException?GetLine(e) : null,
GeneratedFiles = new List <GeneratedFile>()
});
}
}
public async Task <IActionResult> Generate([FromBody] GenerateRequest generateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var getOSSObjectResult = m_PreviewManager.GetOSSObject(generateRequest.OSSPath);
if (!getOSSObjectResult.IsSuccess)
{
return(Json(getOSSObjectResult));
}
var ossObjectDto = getOSSObjectResult.Data;
var result = ossObjectDto.IsHtml
? await m_HtmlPreviewManager.GenerateAsync(ossObjectDto, generateRequest.IsRegenerate)
: await m_PreviewManager.GenerateAsync(ossObjectDto, generateRequest.IsRegenerate);
return(Json(result));
}
public async Task <GenerateQrDto> GenerateQr(decimal productPrice, string message)
{
var requestData = new GenerateRequest
{
Amount = productPrice,
Currency = "RUB",
QrType = QrType.Dynamic,
MerchantId = _options.MerchantId,
AccountNumber = _options.AccountNumber,
PaymentPurpose = message
};
var request = new StringContent(JsonConvert.SerializeObject(requestData), Encoding.UTF8,
"application/json");
var token = await GetAuthToken();
var httpMessage = new HttpRequestMessage
{
Content = request,
Method = HttpMethod.Post,
RequestUri = new Uri(_options.Url + "/v1/qr/generate"),
Headers = { { "Authorization", $"Bearer {token}" } }
};
var response = await _httpClient.SendAsync(httpMessage);
response.EnsureSuccessStatusCode();
var responseContent = await response.Content.ReadAsStringAsync();
var responseData = JsonConvert.DeserializeObject <GenerateResponse>(responseContent);
return(new GenerateQrDto
{
QrId = responseData.QrId,
Payload = responseData.PayLoad
});
}
private MemoryStream CreateDownloadStream(GenerateRequest request, string tempFile, string tempDir)
{
var virtualDisk = LoadStaticFiles(request);
Directory.CreateDirectory(tempDir);
foreach (var file in virtualDisk.Files)
{
var dir = Path.Combine(tempDir, file.Path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
File.WriteAllText(Path.Combine(dir, file.Name), file.Content);
}
var serverDisk = new Disk(tempDir);
var clientDisk = new Disk(Path.Combine(tempDir, "ClientApp/src"));
ReplaceNamespace(tempDir, request.NameSpace);
(var serverProject, var clientProject) = InitProject(request, serverDisk, clientDisk);
serverProject.GenerateFiles(request.NameSpace, "http://localhost:5000");
clientProject.GenerateFiles(request.NameSpace, "http://localhost:5000");
ZipFile.CreateFromDirectory(tempDir, tempFile);
var reader = new BinaryReader(File.Open(tempFile, FileMode.Open));
const int bufferSize = 4096;
var ms = new MemoryStream();
byte[] buffer = new byte[bufferSize];
int count;
while ((count = reader.Read(buffer, 0, buffer.Length)) != 0)
{
ms.Write(buffer, 0, count);
}
ms.Position = 0;
StatisticsService.OnGenerated(serverProject.ResourceCollection.DataModel, request.Data, StatEvent.Download);
return(ms);
}
public override Task <GenerateReply> Generate(GenerateRequest request, ServerCallContext context)
{
Console.WriteLine($"SPRO Generate for {request.Username} / {request.Type}");
string response = "";
Timer userTimer;
if (_sessionsType != null && _sessionsType == request.Type &&
_usersInSession.TryGetValue(request.Username, out userTimer))
{
userTimer.Stop();
response = request.Payload;
userTimer.Start();
Console.WriteLine($"SPRO Generate for {request.Username} / {request.Type} GRANTED");
}
// HACK TEST CALL NICLERC
// TODO : correct code
// generate a fake answer because of a bug in spro.exe
response = "{ \"id\":\"" + Guid.NewGuid().ToString() + "\", \"answer\": \"" +
$"Request for ({request.Username},{request.Type}) succedded at {DateTime.Now.ToLongTimeString()}"
+ "\" }";
return(Task.FromResult(new GenerateReply {
Response = response
}));
}
public async Task <IActionResult> Generate([FromBody] GenerateRequest request)
{
var generated = await enclave.GenerateKey(request.KeyType);
return(Ok(generated));
}
public Task <GenerateResponse> GenerateAsync(GenerateRequest generateRequest)
{
return(Task.FromResult(new GenerateResponse()));
}
private ServerPlugin GetServerPlugin(GenerateRequest request)
{
return(Cache.GetOrCreate <ServerPlugin>(request.Backend, entry => LoadPlugin <ServerPlugin, ServerConfig>("plugins/server", request.Backend)));
}
private ClientPlugin GetClientPlugin(GenerateRequest request)
{
return(Cache.GetOrCreate <ClientPlugin>(request.Frontend, entry => LoadPlugin <ClientPlugin, ClientConfig>("plugins/client", request.Frontend)));
}
/// <summary>
/// Generates the specified maze by the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public Maze GenerateMaze(GenerateRequest request)
{
return(mazeManager.GenerateMaze(request));
}
public async Task <GenerateResponse> Generate(GenerateRequest request) =>
request switch
{
