public async Task <ProjectSettingsResult> UpsertProjectColors([FromBody] ProjectSettingsRequest request)
{
if (string.IsNullOrEmpty(request?.projectUid))
{
ServiceExceptionHandler.ThrowServiceException(HttpStatusCode.BadRequest, 68);
}
LogCustomerDetails("UpsertProjectSettings", request?.projectUid);
Logger.LogDebug($"UpsertProjectSettings: {JsonConvert.SerializeObject(request)}");
request.ProjectSettingsType = ProjectSettingsType.Colors;
var projectSettingsRequest = _requestFactory.Create <ProjectSettingsRequestHelper>(r => r
.CustomerUid(CustomerUid))
.CreateProjectSettingsRequest(request.projectUid, request.Settings, request.ProjectSettingsType);
projectSettingsRequest.Validate();
var result = (await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <UpsertProjectSettingsExecutor>(LoggerFactory, ConfigStore, ServiceExceptionHandler,
CustomerUid, UserId, headers: customHeaders,
productivity3dV2ProxyCompaction: Productivity3dV2ProxyCompaction,
projectRepo: ProjectRepo, cwsProjectClient: CwsProjectClient)
.ProcessAsync(projectSettingsRequest)
)) as ProjectSettingsResult;
await NotifyChanges(UserId, request.projectUid);
Logger.LogResult(this.ToString(), JsonConvert.SerializeObject(request), result);
return(result);
}
public async Task <Node> Node()
{
var requestFactory = _requestFactory.Create("/");
var response = await requestFactory.Get <Node>().ConfigureAwait(false);
return(response);
}
public void WhenUrlIsNull_ThrowsException()
{
// Arrange
// Act
Action act = () => _sut.Create(null, 0, new Dictionary <string, string>());
// Assert
act.Should().Throw <ArgumentException>();
}
public async Task <IApi> Create(ApiData data)
{
var response = await _requestFactory.Post <Api>(data).ConfigureAwait(false);
var requestFactory = _requestFactory.Create("/{id}", new Dictionary <string, string> {
{ "id", response.Id }
});
response.Configure(requestFactory);
return(response);
}
public async Task <IPlugin> Create(PluginData data)
{
var response = await _requestFactory.Post <Plugin>(data).ConfigureAwait(false);
var requestFactory = _requestFactory.Create("/{plugin_id}", new Dictionary <string, string> {
{ "plugin_id", response.Id }
});
response.Configure(requestFactory);
return(response);
}
private async Task <BitfinexApiResult <T> > ExecutePublicRequest <T>(Uri uri, string httpMethod)
{
var uriString = uri.ToString();
var request = RequestFactory.Create(uriString);
request.ContentType = "application/json";
request.Accept = "application/json";
request.Method = httpMethod;
return(await GetResponse <T>(request));
}
/// <summary>
/// Sets activated state for imported files.
/// </summary>
protected async Task <IEnumerable <Guid> > SetFileActivatedState(string projectUid, Dictionary <Guid, bool> fileUids)
{
Logger.LogDebug($"SetFileActivatedState: projectUid={projectUid}, {fileUids.Keys.Count} files with changed state");
var deactivatedFileList = await ImportedFileRequestDatabaseHelper.GetImportedFileProjectSettings(projectUid, UserId, ProjectRepo).ConfigureAwait(false) ?? new List <ActivatedFileDescriptor>();
Logger.LogDebug($"SetFileActivatedState: originally {deactivatedFileList.Count} deactivated files");
var missingUids = new List <Guid>();
foreach (var key in fileUids.Keys)
{
//fileUids contains only uids of files whose state has changed.
//In the project settings we store only deactivated files.
//Therefore if the value is true remove from the list else add to the list
if (fileUids[key])
{
var item = deactivatedFileList.SingleOrDefault(d => d.ImportedFileUid == key.ToString());
if (item != null)
{
deactivatedFileList.Remove(item);
}
else
{
missingUids.Add(key);
Logger.LogInformation($"SetFileActivatedState: ImportFile '{key}' not found in project settings.");
}
}
else
{
deactivatedFileList.Add(new ActivatedFileDescriptor {
ImportedFileUid = key.ToString(), IsActivated = false
});
}
}
Logger.LogDebug($"SetFileActivatedState: now {deactivatedFileList.Count} deactivated files, {missingUids.Count} missingUids");
var projectSettingsRequest =
_requestFactory.Create <ProjectSettingsRequestHelper>(r => r
.CustomerUid(CustomerUid))
.CreateProjectSettingsRequest(projectUid, JsonConvert.SerializeObject(deactivatedFileList), ProjectSettingsType.ImportedFiles);
projectSettingsRequest.Validate();
_ = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <UpsertProjectSettingsExecutor>(LoggerFactory, ConfigStore, ServiceExceptionHandler,
CustomerUid, UserId, headers : customHeaders,
productivity3dV2ProxyCompaction : Productivity3dV2ProxyCompaction,
projectRepo : ProjectRepo, cwsProjectClient : CwsProjectClient)
.ProcessAsync(projectSettingsRequest)
) as ProjectSettingsResult;
var changedUids = fileUids.Keys.Except(missingUids);
Logger.LogDebug($"SetFileActivatedState: {changedUids.Count()} changedUids");
return(changedUids);
}
private void AcceptNewMessage()
{
string message = Console.ReadLine();
var strategy = _requestFactory.Create(_client, message);
_ = Task.Run(async() => await HandleMessage(strategy, message));
AcceptNewMessage();
}
public Task Delete(ClusterNode node)
{
var requestFactory = _requestFactory.Create(new Dictionary <string, string> {
{ "name", node.Name }
});
return(requestFactory.Delete());
}
public bool Sync()
{
if (string.IsNullOrWhiteSpace(_panelUrl) || string.IsNullOrWhiteSpace(_secret))
{
throw new ArgumentNullException();
}
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
var syncUrl = _urlProvider.GetUrl(Verb.Sync);
var challenge = _requestFactory.Create(_urlProvider.GetUrl(Verb.Challenge), 360000, null).Execute();
var signature = _signatureService.CreateSignature(challenge, syncUrl, null);
return(_requestFactory
.Create(syncUrl, 10800000,
new Dictionary <string, string>
{
{ "X-MC-MAC", signature.SignatureHash }, { "X-MC-Nonce", challenge }
})
.Execute(_streamProcessor) &&
!_log.HasLoggedErrors);
}
/// <summary>
/// Creates a new instance of the specified TRequest request, configures and invokes it and returns its response.
/// </summary>
/// <typeparam name="TRequest">The request interface to invoke.</typeparam>
/// <typeparam name="TResponse">The type of the request response result.</typeparam>
/// <param name="configure">Action that configures a type instance that implements TRequest.</param>
/// <param name="token">Cancellation token.</param>
/// <returns>Returns the result of the request invocation.</returns>
private async Task <TResponse> InvokeRequestAsync <TRequest, TResponse>(Action <TRequest> configure,
CancellationToken token)
where TRequest : IRequest <TResponse>
{
EnsureIsConnected();
var request = requestFactory.Create <TRequest>(ServerInfo);
configure(request);
var result = await request.InvokeAsync(httpClient, token);
return(result);
}
public void Execute(int groupId, string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name), "name cannot be null when added to database");
}
var group = _uow.RequestGroups.Include(c => c.Requests).Single(c => c.Id == groupId);
var domainObject = _factory.Create(groupId, name);
group.Requests.Add(_dataFactory.Create(domainObject));
_uow.RequestGroups.Update(group);
_uow.SaveChanges();
}
public async Task <bool> SendValidCodeByEmail(string emailAddresss, string body, string subject)
{
m_paramsDict.Add("emailBody", body);
m_paramsDict.Add("toAddress", emailAddresss);
m_paramsDict.Add("subject", subject);
m_paramsDict.Add("timestamp", DateTimeHelper.DateTimeToUnixTimestamp(DateTime.Now).ToString());
var request = m_requestFactory.Create("/api/DirectEmail/SingleSendMailByBody", Method.Get, false);
foreach (var item in m_paramsDict)
{
request.AddParameter("mailParams." + item.Key.ToLower(), item.Value);
}
request.AddParameter("mailParams." + "sign", JeuciAccessTokenHelper.GetSignStr(m_paramsDict));
var result = await request.Execute <DirectEmailMessage>();
return(result.StatusCode == HttpStatusCode.OK && result.Data.Code == ResultCode.Success);
}
public Task Delete(string id)
{
return(_requestFactory.Create("/{credential_id}", new Dictionary <string, string> {
{ "credential_id", id }
}).Delete());
}
internal static WebRequest CreateRequest(RequestInfoBase info, IRequestFactory requestFactory)
{
WebRequest Request = requestFactory.Create(info.Uri.AbsoluteUri);
Request.Method = info.Method.ToString();
if ((info.Method == RequestMethod.POST || info.Method == RequestMethod.PUT))
{
Request.ContentType = info.RequestContentType.ToHeaderValue();
}
if (Request is HttpWebRequest)
{
var request = ((HttpWebRequest)Request);
switch (info.ResponseContentType)
{
case ContentType.JSON:
request.Accept = "text/plain, text/json, application/json";
break;
case ContentType.FORM:
request.Accept = "text/plain, text/json, application/json, text/xml, application/xml";
break;
case ContentType.XML:
request.Accept = "text/xml, application/xml";
break;
case ContentType.TEXT:
request.Accept = "text/plain";
break;
}
request.UserAgent = info.UserAgent;
var headers = info.Headers;
if (headers != null)
{
foreach (var header in headers)
{
request.Headers[header.Key] = header.Value.ToString();
}
}
}
if ((info.Method == RequestMethod.POST || info.Method == RequestMethod.PUT))
{
if (string.IsNullOrEmpty(info.RequestBody))
{
#if !WINDOWS_PHONE
Request.ContentLength = 0;
#endif
}
else
{
// set request stream
var gate = new AutoResetEvent(false);
byte[] bodyValue = Encoding.UTF8.GetBytes(info.RequestBody);
Exception exception = null;
Request.BeginGetRequestStream(ac =>
{
try
{
using (
Stream requestStream =
Request.EndGetRequestStream(ac))
{
requestStream.Write(bodyValue, 0, bodyValue.Length);
requestStream.Flush();
}
}
catch (Exception ex)
{
exception = ex;
}
finally
{
gate.Set();
}
}, null);
gate.WaitOne();
// #FIXME: logic to catch stalls conflicts with throttle
//if (!gate.WaitOne(10000))
//{
// throw new Exception("timed out setting request body");
//}
if (exception != null)
{
throw exception;
}
}
}
return Request;
}
/// <summary>
/// Execute request
/// </summary>
/// <param name="request">The request</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public async Task <ApiResponse <TResponse> > Execute(ApiRequest <TRequest> request, CancellationToken cancellationToken)
{
Argument.NotNull(request, nameof(request));
var client = _clientFactory.Create(request);
var apiRequest = _requestFactory.Create(request);
ApiDownloadFileResponse downloadFile = null;
if (request.IsFileDownload == true)
{
client.ConfigureWebRequest(x => x.AllowReadStreamBuffering = false);
downloadFile = new ApiDownloadFileResponse();
apiRequest.AdvancedResponseWriter = (stream, httpResponse) => SetDownloadFile(downloadFile, stream, httpResponse);
}
_ = apiRequest.AddHeader(HttpRequestHeaderConstants.CacheControl, "no-cache");
if (request.IsFileUpload == true)
{
client.ConfigureWebRequest(x => x.AllowWriteStreamBuffering = false);
_ = apiRequest.AddFile(
request.UploadFile.ParameterName,
request.UploadFile.File.CopyTo,
request.UploadFile.FileName,
request.UploadFile.Size.Value,
request.UploadFile.ContentType);
}
else
{
client.ConfigureWebRequest(x => x.AllowWriteStreamBuffering = true);
AddBody(request, apiRequest);
}
var apiResponse = await client
.ExecuteAsync <TResponse>(apiRequest, cancellationToken)
.ConfigureAwait(Await.Default);
var response = new RestSharpApiResponse <TResponse>
{
RestRequest = apiRequest,
RestResponse = apiResponse,
IsSuccessful = apiResponse.IsSuccessful,
ErrorException = apiResponse.ErrorException,
StatusCode = apiResponse.StatusCode,
ResponseStatus = _converter.Convert(apiResponse.ResponseStatus)
.ThrowIfNoValue()
.Value,
Content = apiResponse.Content,
DownloadFile = downloadFile,
};
if (apiResponse.IsSuccessful == true)
{
response.Model = apiResponse.Data;
response.ContentModel = apiResponse.Data;
}
if (apiResponse.Headers != null)
{
var headers = apiResponse.Headers
.Where(x => x.Type == ParameterType.HttpHeader)
.Where(x => x.Value is string)
.Select(x => new ResponseHeader
{
Name = x.Name,
Value = x.Value as string
})
.ToList();
response.Headers = new ResponseHeaders(headers)
{
ContentLength = apiResponse.ContentLength,
ContentType = apiResponse.ContentType
};
SetContentDispositionHeader(response, apiResponse);
}
return(response);
}
public ICloudFilesResponse Submit(IAddToWebRequest requesttype, string authtoken)
{
return(commonSubmit(requesttype, () => _requestfactory.Create(requesttype.CreateUri()), authtoken));
}
protected IRestResponse PutBase(string body, object parameters)
{
var request = _requestFactory.Create(parameters, body);
return(_clientFactory.Create().Execute(request, Method.PUT));
}
