public async Task <IActionResult> CreateAsync([FromBody] CreateRecordRequest record)
{
var createRecordCommand = new CreateRecord.Command(record);
var res = await _mediator.Send(createRecordCommand);
return(Ok(res));
}
public async Task <IActionResult> Create([FromBody] CreateRecordRequest request)
{
var record = new Record
{
Id = Guid.NewGuid(),
Teacher = request.Teacher,
Room = request.Room,
Note = request.Note,
ClassNumber = request.ClassNumber,
ClassLetter = request.ClassLetter,
Lessons = request.Lessons,
Date = request.Date
};
var created = await _recordService.CreateRecord(record);
if (created == false)
{
return(BadRequest());
}
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUri = baseUrl + "/" + ApiRoutes.AdminRecords.Get.Replace("{recordId}", record.Id.ToString());
var response = new RecordResponse {
Id = record.Id
};
return(Created(locationUri, response));
}
public void CreateRecordTest()
{
var request = new CreateRecordRequest(RawRequests.CreateRecord);
var handler = new CreateRecordHandler(null, request);
handler.Handle();
}
public async Task <int> CreateRecordAsync(string zoneName, CreateRecordRequest req)
{
if (string.IsNullOrEmpty(zoneName))
{
throw new Client.Exception.ANSClientValidationException("Invalid zone name");
}
return((await this.Client.PostAsync <Record>($"/safedns/v1/zones/{zoneName}/records", req)).ID);
}
public async Task <string> CreateDomainRecordAsync(string domainName, CreateRecordRequest req)
{
if (string.IsNullOrWhiteSpace(domainName))
{
throw new UKFastClientValidationException("Invalid domain name");
}
return((await Client.PostAsync <Record>($"/ddosx/v1/domains/{domainName}/records", req)).ID);
}
public async Task <int> CreateRecordAsync(int templateID, CreateRecordRequest req)
{
if (templateID < 1)
{
throw new Client.Exception.ANSClientValidationException("Invalid template id");
}
return((await this.Client.PostAsync <T>($"/safedns/v1/templates/{templateID}/records", req)).ID);
}
private static CreateRecordRequest.IBuilderWithResource PrepareRecords(Dictionary <Enums.ResourceType, string[]> fieldNames)
{
return((CreateRecordRequest.IBuilderWithResource)ItemsGenerator(CreateRecordRequest.Builder(), fieldNames,
(result, fieldName, fieldValueType, resource) => result.Append(resource.ToPrivateEnum(), content =>
PrepareInitialRecordContent(content, resource.ToPrivateEnum()).Append(fieldName, GetFieldValue(fieldName, fieldValueType)).Build(),
new RecordDescriptor
{
FieldName = fieldName,
FieldValue = fieldValueType,
Resource = resource
})));
}
public async Task <RecordDto> CreateRecord(CreateRecordRequest createRecord, string userId)
{
var record = mapper.Map <Record>(createRecord);
record.UserId = Convert.ToInt64(userId);
await unitOfWork.RecordRepository.Add(record);
await unitOfWork.Save();
var recordDto = mapper.Map <RecordDto>(record);
return(recordDto);
}
public void CreateRecord()
{
var request = new CreateRecordRequest(RawRequests.CreateRecord);
request.Parse();
Assert.Equal("0", request.GameId.ToString());
Assert.Equal("XXXXXX", request.SecretKey);
Assert.Equal("xxxxxxxx_YYYYYYYYYY__", request.LoginTicket);
Assert.Equal("test", request.TableId);
// Assert.Equal("score", request.Values[0].FieldName);
// Assert.Equal("string", request.Values[0].FiledType);
// Assert.Equal("recordid", request.Values[1].FieldName);
// Assert.Equal("string", request.Values[1].FiledType);
}
public async Task CreateDomainRecordAsync_ExpectedResult()
{
var req = new CreateRecordRequest()
{
Name = "test-record.test-domain.co.uk"
};
_client.PostAsync <Record>($"/ddosx/v1/domains/test-domain.co.uk/records", req).Returns(new Record()
{
ID = "00000000-0000-0000-0000-000000000000"
});
var ops = new DomainRecordOperations <Record>(_client);
var recordID = await ops.CreateDomainRecordAsync("test-domain.co.uk", req);
Assert.AreEqual("00000000-0000-0000-0000-000000000000", recordID);
}
public void CreateRecordTest()
{
var request = new CreateRecordRequest(RawRequests.CreateRecord);
request.Parse();
var result = new CreateRecordResult()
{
RecordID = "0",
TableID = "0",
};
result.Fields.Add("hello0");
result.Fields.Add("hello1");
result.Fields.Add("hello2");
var response = new CreateRecordResponse(request, result);
response.Build();
}
public async Task CreateTemplateRecordAsync_ExpectedResult()
{
CreateRecordRequest req = new CreateRecordRequest()
{
Name = "test.example.com"
};
IANSSafeDNSClient client = Substitute.For <IANSSafeDNSClient>();
client.PostAsync <Record>("/safedns/v1/templates/123/records", req).Returns(new Record()
{
ID = 123
});
var ops = new TemplateRecordOperations <Record>(client);
int id = await ops.CreateRecordAsync(123, req);
Assert.AreEqual(123, id);
}
public async Task <IActionResult> CreateRecord([FromBody] CreateRecordRequest createRecord)
{
try
{
var userIdClaim = HttpContext.User.Claims.FirstOrDefault(c => c.Type == "userId");
if (userIdClaim == null)
{
return(BadRequest(new { message = "Invalid token" }));
}
var record = await recordService.CreateRecord(createRecord, userIdClaim.Value);
return(Ok(new { record }));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
private static CreateRecordRequest.IBuilderWithResource PrepareRecords(Dictionary <Enums.ResourceType, string[]> fieldNames, Func <string, bool, string> valuesProvider = null)
{
valuesProvider = valuesProvider ?? GetFieldValue;
return((CreateRecordRequest.IBuilderWithResource)ItemsGenerator(CreateRecordRequest.Builder(), fieldNames,
(result, fieldName, resource) => result
.Append(resource.ToPrivateEnum(), content =>
PrepareInitialRecordContent(content, resource.ToPrivateEnum()).Append(fieldName, valuesProvider(fieldName, false)).Build(),
new RecordDescriptor
{
FieldName = fieldName,
IsPrimary = false,
Resource = resource
})
.Append(resource.ToPrivateEnum(), content =>
PrepareInitialRecordContent(content, resource.ToPrivateEnum()).Append(fieldName, valuesProvider(fieldName, true)).Build(),
new RecordDescriptor
{
FieldName = fieldName,
IsPrimary = true,
Resource = resource
})));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateRecordRequest request;
try
{
request = new CreateRecordRequest
{
CreateRecordDetails = CreateRecordDetails,
OpcRetryToken = OpcRetryToken,
OpcRequestId = OpcRequestId
};
response = client.CreateRecord(request).GetAwaiter().GetResult();
WriteOutput(response, response.Record);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public Command(CreateRecordRequest record)
{
Record = record;
}
protected async Task <RecordResponse> CreateRecordAsync(CreateRecordRequest request)
{
var response = await TestClient.PostAsJsonAsync(ApiRoutes.Records.Create, request);
return(await response.Content.ReadAsAsync <RecordResponse>());
}
