public async Task <IActionResult> PutValue(long id, ValueDto valueDto)
{
if (id != valueDto.Id)
{
return(BadRequest());
}
var value = _context.Values.First(v => v.Id == valueDto.Id);
value.Content = valueDto.Content;
value.Atribute = _context.Atributes.First(a => a.Id == valueDto.AtributeId);
value.LocalItem = _context.LocalItems.First(li => li.Id == valueDto.LocalItemId);
_context.Entry(value).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ValueExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Post([FromBody] ValueDto value)
{
foreach (var valueValue in value.Values)
{
_logger.LogInformation(valueValue.ToString());
}
}
public void MissingMemberHandlingIgnore()
{
var dto = ValueDto.Create(true);
var json = "{\"booleanValue\":true,\"missing\":false}";
JsonSerializer.FromJson <ValueDto>(json).Should().BeDto(dto);
}
public async Task <IActionResult> NameExists([FromBody] ValueDto valueDto)
{
var Id = GetTokenId();
var status = await groceriesService.GroceryExistsName(valueDto.value, Id);
return(Ok(ret(status, "done")));
}
public ValueDto Add(ValueDto dto)
{
Values.Add(dto.Value);
return(new ValueDto {
Value = dto.Value
});
}
public void MetadataPropertyHandlingIgnore()
{
var dto = ValueDto.Create(true);
var json = "{\"$ref\":\"xyzzy\",\"booleanValue\":true}";
JsonSerializer.FromJson <ValueDto>(json).Should().BeDto(dto);
}
public void CamelCase()
{
var dto = ValueDto.Create(true);
var json = "{\"booleanValue\":true}";
JsonSerializer.ToJson(dto).Should().Be(json);
JsonSerializer.FromJson <ValueDto>(json).Should().BeDto(dto);
}
public void DateParseHandlingNone()
{
var dto = ValueDto.Create("2016-10-21T15:31:00Z");
var json = $"{{\"stringValue\":\"{dto.StringValue}\"}}";
JsonSerializer.ToJson(dto).Should().Be(json);
JsonSerializer.FromJson <ValueDto>(json).Should().BeDto(dto);
}
public void NullValueHandlingIgnore()
{
var dto = ValueDto.Create(default(bool?));
var json = "{}";
JsonSerializer.ToJson(dto).Should().Be(json);
JsonSerializer.FromJson <ValueDto>(json).Should().BeDto(dto);
}
public async Task <IActionResult> Put(ValueDto value)
{
var dbValue = value?.Adapt <Value>();
_unitOfWork.GetRepository <Value>().Update(dbValue);
await _unitOfWork.SaveChangesAsync();
return(Ok(dbValue.Adapt <ValueDto>()));
}
public void ServiceResultClone()
{
var result = ServiceResult.Success(ValueDto.Create(true));
var clone = Serializer.Clone(result);
clone.Should().NotBeSameAs(result);
ServiceDataUtility.AreEquivalentResults(clone, result).Should().Be(true);
}
public static ValueDto CreateValue()
{
var next = new ValueDto()
{
CreateOn = DateTime.Now, Value = GenerateValue()
};
UpdateBefore(next);
return(next);
}
public async Task <IActionResult> Post(ValueDto value)
{
value.Id = 0;
var dbValue = value?.Adapt <Value>();
await _unitOfWork.GetRepository <Value>().InsertAsync(dbValue);
await _unitOfWork.SaveChangesAsync();
return(CreatedAtAction(nameof(Get), new { id = dbValue.Id }, dbValue?.Adapt <ValueDto>()));
}
public ActionResult <string> GetValue(int id)
{
var valueModel = new ValueDto
{
Name = "SomeName",
Id = id
};
return(Content(JsonConvert.SerializeObject(valueModel)));
}
public void CamelCaseExceptDictionaryKeys()
{
var dto = ValueDto.Create(new Dictionary <string, bool> {
["Key"] = true
});
var json = "{\"booleanMapValue\":{\"Key\":true}}";
JsonSerializer.ToJson(dto).Should().Be(json);
JsonSerializer.FromJson <ValueDto>(json).Should().BeDto(dto);
}
public async Task <IActionResult> Post([FromBody] ValueDto dto)
{
if (string.IsNullOrEmpty(dto.Message))
{
return(BadRequest());
}
Source.Add(dto);
await Context.Clients.All.SendAsync("Add", dto);
return(Ok(dto));
}
public ValueDto Add(ValueDto value)
{
if (value == null)
{
throw new ArgumentNullException();
}
var entity = _mapper.Map <ValueDto, Value>(value);
value = _mapper.Map <Value, ValueDto>(_valueRepository.Add(entity));
return(value);
}
public async Task <ActionResult <ValueDto> > PostValue(ValueDto valueDto)
{
_context.Values.Add(new Value
{
Content = valueDto.Content,
Atribute = _context.Atributes.First(a => a.Id == valueDto.AtributeId),
LocalItem = _context.LocalItems.First(li => li.Id == valueDto.LocalItemId)
});
await _context.SaveChangesAsync();
return(CreatedAtAction("GetValue", new { id = valueDto.Id }, valueDto));
}
private IEnumerable <ValueDto> MapCondutorToValueDto(IEnumerable <Condutor> condutores)
{
foreach (var item in condutores)
{
var valueDto = new ValueDto
{
Id = item.Codigo,
Value = item.Descricao
};
yield return(valueDto);
}
}
public IActionResult Post([FromBody, Required] ValueDto value)
{
try
{
value = _valueLogic.Add(value);
return(CreatedAtAction("Get", new { id = value.Id }, value));
}
catch (Exception)
{
return(BadRequest());
}
}
private IEnumerable <ValueDto> MapTransformadorToValueDto(IEnumerable <Transformador> transformadores)
{
foreach (var item in transformadores)
{
var valueDto = new ValueDto
{
Id = item.Codigo,
Value = item.Descricao
};
yield return(valueDto);
}
}
private IEnumerable <ValueDto> MapChaveToValueDto(IEnumerable <Chave> chaves)
{
foreach (var item in chaves)
{
var valueDto = new ValueDto
{
Id = item.Codigo,
Value = item.Descricao
};
yield return(valueDto);
}
}
private IEnumerable <ValueDto> MapTopologiaToValueDto(IEnumerable <Topologia> topologias)
{
foreach (var item in topologias)
{
var valueDto = new ValueDto
{
Id = item.Codigo,
Value = item.Descricao
};
yield return(valueDto);
}
}
public void DateParseHandlingNone()
{
var dto = ValueDto.Create("2016-10-21T15:31:00Z");
var json = $"{{\"stringValue\":\"{dto.StringValue}\"}}";
ServiceJsonUtility.ToJson(dto).Should().Be(json);
ServiceJsonUtility.FromJson <ValueDto>(json).Should().BeDto(dto);
var token = ServiceJsonUtility.FromJson <JToken>(json);
token["stringValue"].Type.Should().Be(JTokenType.String);
ServiceJsonUtility.ToJson(token).Should().Be(json);
}
public void CamelCase()
{
var dto = ValueDto.Create(true);
var json = "{\"booleanValue\":true}";
ServiceJsonUtility.ToJson(dto).Should().Be(json);
ServiceJsonUtility.FromJson <ValueDto>(json).Should().BeDto(dto);
var token = ServiceJsonUtility.FromJson <JToken>(json);
token["booleanValue"].Type.Should().Be(JTokenType.Boolean);
ServiceJsonUtility.ToJson(token).Should().Be(json);
}
public void NullValueHandlingIgnore()
{
var dto = ValueDto.Create(default(bool?));
var json = "{}";
ServiceJsonUtility.ToJson(dto).Should().Be(json);
ServiceJsonUtility.FromJson <ValueDto>(json).Should().BeDto(dto);
var token = ServiceJsonUtility.FromJson <JToken>(json);
token["stringValue"].Should().BeNull();
ServiceJsonUtility.ToJson(token).Should().Be(json);
}
public void CamelCaseExceptDictionaryKeys()
{
var dto = ValueDto.Create(new Dictionary <string, bool> {
["Key"] = true
});
var json = "{\"booleanMapValue\":{\"Key\":true}}";
ServiceJsonUtility.ToJson(dto).Should().Be(json);
ServiceJsonUtility.FromJson <ValueDto>(json).Should().BeDto(dto);
var token = ServiceJsonUtility.FromJson <JToken>(json);
token["booleanMapValue"].Type.Should().Be(JTokenType.Object);
ServiceJsonUtility.ToJson(token).Should().Be(json);
}
public IActionResult Put(int id, [FromBody, Required] ValueDto value)
{
try
{
value = _valueLogic.Update(id, value);
return(Ok(value));
}
catch (NotFoundException)
{
return(NotFound());
}
catch (Exception ex)
{
return(BadRequest());
}
}
public ValueDto Update(int id, ValueDto value)
{
if (id < 0)
{
throw new ArgumentOutOfRangeException();
}
if (value == null)
{
throw new ArgumentNullException();
}
var entity = _mapper.Map <ValueDto, Value>(value);
value = _mapper.Map <Value, ValueDto>(_valueRepository.Update(id, entity));
return(value);
}
/// <summary>
/// テキスト紐付け取得
/// </summary>
/// <param name="blocks">BlocksのJSON</param>
/// <returns>テキスト紐付け</returns>
private static Dictionary <string, Dictionary <ValueDto, List <ValueDto> > > GetTextRelationships(ArrayList blocks)
{
// Relationships格納用Dictionary
Dictionary <string, List <string> > pageRelationships = new Dictionary <string, List <string> >();
Dictionary <string, List <string> > lineRelationships = new Dictionary <string, List <string> >();
Dictionary <string, Dictionary <ValueDto, List <ValueDto> > > textRelationships = new Dictionary <string, Dictionary <ValueDto, List <ValueDto> > >();
// blocksをループ
foreach (Dictionary <string, object> blocksValue in blocks)
{
string blockType = blocksValue[JsonKeys.BLOCK_TYPE] as string;
string id = blocksValue[JsonKeys.ID] as string;
// Relationshipsが存在する場合、RelationshipsのDictionaryに格納する。
if (blocksValue.ContainsKey(JsonKeys.RELATIONSHIPS))
{
ArrayList relationships = blocksValue[JsonKeys.RELATIONSHIPS] as ArrayList;
if (JsonValues.BLOCK_TYPE_PAGE == blockType)
{
SetRelationships(ref pageRelationships, relationships, id);
}
else if (JsonValues.BLOCK_TYPE_LINE == blockType)
{
SetRelationships(ref lineRelationships, relationships, id);
}
}
// Pageの場合、文字列の紐付けは存在しないので、以降の処理はなし。
if (JsonValues.BLOCK_TYPE_PAGE == blockType)
{
// 結果Dictionaryのインスタンスのみ設定しておく。
textRelationships.Add(id, new Dictionary <ValueDto, List <ValueDto> >());
continue;
}
string text = blocksValue[JsonKeys.TEXT] as string;
ValueDto valueDto = new ValueDto()
{
ID = id, Text = text
};
// Relationshipsから紐付け元を特定し、結果に設定する。
SetTextRelationships(ref textRelationships, pageRelationships, lineRelationships, valueDto, blockType);
}
return(textRelationships);
}
//get value for key (name)
public object Get(ValueDto req)
{
var value = new Value ().PopulateWith (req);
value.Hash=DHTServerCtx.HashFunction.apply (req.Key);
var redir = this.checkRedirect (value.Hash, req.Key);
if (redir != null) {
return redir;
}
var found = Db.Select<Value> (q => q.HashHexString == value.HashHexString);
if (found.IsEmpty()) {
return new HttpResult { StatusCode = HttpStatusCode.NotFound };
}
var valueDto = found.Select (v => new ValueDto ().PopulateWith (v)).First ();
return new ValueDtoResponse (valueDto);
}
//create or update value for key (name)
public object Put(ValueDto req)
{
var value = new Value ().PopulateWith (req);
value.Hash=DHTServerCtx.HashFunction.apply (req.Key);
var redir = this.checkRedirect (value.Hash, req.Key);
if (redir != null) {
return redir;
}
var found = Db.Select<Value> (q => q.HashHexString == value.HashHexString);
if (found.IsEmpty()) {
Db.Insert<Value> (value);
} else {
Db.Save<Value> (value);
}
return new HttpResult { StatusCode = HttpStatusCode.Accepted };
}
//delete value for key (name)
public object Delete(ValueDto req)
{
var value = new Value ().PopulateWith (req);
value.Hash=DHTServerCtx.HashFunction.apply (req.Key);
var redir = this.checkRedirect (value.Hash, req.Key);
if (redir != null) {
return redir;
}
var found = Db.Select<Value> (q => q.HashHexString == value.HashHexString);
if (found.IsEmpty()) {
return new HttpResult { StatusCode = HttpStatusCode.NotFound };
}
Db.Delete<Value> (q => q.HashHexString == value.HashHexString);
return new HttpResult { StatusCode = HttpStatusCode.NoContent };
}
