public void TestUpdateField()
{
string localFileName = "GetField.docx";
string remoteFileName = "TestUpdateField.docx";
this.UploadFileToStorage(
remoteDataFolder + "/" + remoteFileName,
null,
null,
File.ReadAllBytes(LocalTestDataFolder + fieldFolder + "/" + localFileName)
);
var request = new UpdateFieldRequest(
name: remoteFileName,
index: 0,
field: new FieldUpdate()
{
FieldCode = "{ NUMPAGES }"
},
nodePath: "sections/0/paragraphs/0",
folder: remoteDataFolder
);
var actual = this.WordsApi.UpdateField(request);
Assert.NotNull(actual.Field);
Assert.AreEqual("{ NUMPAGES }", actual.Field.FieldCode);
Assert.AreEqual("0.0.0.0", actual.Field.NodeId);
}
public ActionResult <UpdateFieldResponse> Update([FromBody] UpdateFieldRequest request)
{
request.CommanderID = User.GetUserId();
var result = _fieldService.Update(request);
return(result);
}
/// <summary>Snippet for UpdateField</summary>
public void UpdateField_RequestObject()
{
// Snippet: UpdateField(UpdateFieldRequest,CallSettings)
// Create client
FirestoreAdminClient firestoreAdminClient = FirestoreAdminClient.Create();
// Initialize request argument(s)
UpdateFieldRequest request = new UpdateFieldRequest
{
Field = new apis::Field(),
};
// Make the request
Operation response = firestoreAdminClient.UpdateField(request);
// End snippet
}
public async Task <IActionResult> Put([FromBody] UpdateFieldRequest request, Guid id)
{
if (OrganisationId == Guid.Empty)
{
return(Forbid());
}
var fieldDto = _mapper.Map <FieldDto>(request);
fieldDto.Id = id;
fieldDto.OrganisationId = OrganisationId;
await _fieldService.UpdateAsync(fieldDto);
return(NoContent());
}
public async Task <bool> UpdateField(int id, UpdateFieldRequest updateFieldRequest)
{
try
{
var response = await JongSnamServices.UpdateFieldWithHttpMessagesAsync(id, updateFieldRequest, CustomHeaders);
return(true);
}
catch (Exception ex)
{
return(false);
throw ex;
}
}
/// <summary>Snippet for UpdateFieldAsync</summary>
public async Task UpdateFieldAsync_RequestObject()
{
// Snippet: UpdateFieldAsync(UpdateFieldRequest,CallSettings)
// Additional: UpdateFieldAsync(UpdateFieldRequest,CancellationToken)
// Create client
FirestoreAdminClient firestoreAdminClient = await FirestoreAdminClient.CreateAsync();
// Initialize request argument(s)
UpdateFieldRequest request = new UpdateFieldRequest
{
Field = new apis::Field(),
};
// Make the request
Operation response = await firestoreAdminClient.UpdateFieldAsync(request);
// End snippet
}
public async Task <ActionResult> Edit(GameFieldEditViewModel viewModel)
{
var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId);
var field = project.ProjectFields.SingleOrDefault(e => e.ProjectFieldId == viewModel.ProjectFieldId);
if (field == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
viewModel.FillNotEditable(field, CurrentUserId);
return(View(viewModel));
}
try
{
var request = new UpdateFieldRequest(project.ProjectId,
viewModel.Name,
viewModel.DescriptionEditable,
viewModel.CanPlayerEdit,
viewModel.CanPlayerView,
viewModel.IsPublic,
(MandatoryStatus)viewModel.MandatoryStatus,
viewModel.ShowForGroups.GetUnprefixedGroups(),
viewModel.ValidForNpc,
viewModel.IncludeInPrint,
viewModel.ShowForUnApprovedClaim,
viewModel.Price,
viewModel.MasterDescriptionEditable,
field.ProjectFieldId,
viewModel.ProgrammaticValue);
await FieldSetupService.UpdateFieldParams(request);
return(ReturnToIndex());
}
catch (Exception exception)
{
ModelState.AddException(exception);
viewModel.FillNotEditable(field, CurrentUserId);
return(View(viewModel));
}
}
public async Task UpdateFieldParams(UpdateFieldRequest request)
{
var field = await ProjectRepository.GetProjectField(request.ProjectId, request.ProjectFieldId);
field.RequestMasterAccess(CurrentUserId, acl => acl.CanChangeFields);
// If we are changing field.CanPlayerEdit, we should update variants to match
if (field.CanPlayerEdit != request.CanPlayerEdit)
{
foreach (var variant in field.DropdownValues)
{
variant.PlayerSelectable = request.CanPlayerEdit;
}
}
await SetFieldPropertiesFromRequest(request, field);
await UnitOfWork.SaveChangesAsync();
}
public async Task UpdateFieldAsync2()
{
Mock <FirestoreAdmin.FirestoreAdminClient> mockGrpcClient = new Mock <FirestoreAdmin.FirestoreAdminClient>(MockBehavior.Strict);
UpdateFieldRequest request = new UpdateFieldRequest
{
Field = new apis::Field(),
};
Operation expectedResponse = new Operation
{
Name = "name3373707",
Done = true,
};
mockGrpcClient.Setup(x => x.UpdateFieldAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Operation>(Task.FromResult(expectedResponse), null, null, null, null));
FirestoreAdminClient client = new FirestoreAdminClientImpl(mockGrpcClient.Object, null);
Operation response = await client.UpdateFieldAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void UpdateField2()
{
Mock <FirestoreAdmin.FirestoreAdminClient> mockGrpcClient = new Mock <FirestoreAdmin.FirestoreAdminClient>(MockBehavior.Strict);
UpdateFieldRequest request = new UpdateFieldRequest
{
Field = new apis::Field(),
};
Operation expectedResponse = new Operation
{
Name = "name3373707",
Done = true,
};
mockGrpcClient.Setup(x => x.UpdateField(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
FirestoreAdminClient client = new FirestoreAdminClientImpl(mockGrpcClient.Object, null);
Operation response = client.UpdateField(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void TestUpdateField()
{
//Create some date field.
var request1 = CreateFieldRequest.Builder()
.Resource(ResourceId.Job)
.Required(false)
.FieldType(FieldType.Date)
.DefaultValue(DateTime.Now.ToString("yyyy/MM/dd"))
.Searchable(false)
.JapaneseLabel("This is the first date field")
.JapaneseCaption("This is the first date field");
var request2 = request1.JapaneseCaption("This is the second date field")
.JapaneseCaption("This is the second date field");
Task <IdModel> result1 = session.CallAsync(request1.GetRequest());
Task <IdModel> result2 = session.CallAsync(request2.GetRequest());
TestContext.Out.WriteLine("Take a cup of coffee in meantime and wait for all tasks completes!");
Task.WaitAll(result1, result2);
TestContext.Out.WriteLine("Start to get the result !");
Assume.That(result1.Result, Is.Not.Null, "Response data is null!");
Assume.That(string.IsNullOrEmpty(result1.Result.Id), Is.False, "Id is null!");
Assume.That(result2.Result, Is.Not.Null, "Response data is null!");
Assume.That(string.IsNullOrEmpty(result2.Result.Id), Is.False, "Id is null!");
fieldIdList.Add(result1.Result.Id);
fieldIdList.Add(result2.Result.Id);
var updateRequest = UpdateFieldRequest.Builder()
.Add(result1.Result.Id, UpdateFieldRequest.SingleFieldBuilder().JapaneseCaption("This is the first EDITED date field")
.JapaneseLabel("This is the first EDITED date field"))
.Add(result2.Result.Id, UpdateFieldRequest.SingleFieldBuilder().JapaneseCaption("This is the second edited date field")
.JapaneseLabel("This is the second edited date field"));
var updateTask = session.CallAsync(updateRequest.GetRequest());
Assert.That(updateTask.Result, Is.True, "Updating is not successful!");
}
public async Task <ActionResult> UpdateField(int id, [FromBody] UpdateFieldRequest updateFieldRequest)
{
var result = await _fieldManager.UpdeteField(id, updateFieldRequest);
return(Ok(result));
}
public async Task <bool> UpdeteField(int id, UpdateFieldRequest updateFieldRequest)
{
try
{
var fieldModel = await _fieldRepository.GetFieldById(id);
if (fieldModel == null)
{
return(false);
}
await _repositoryWrapper.BeginTransactionAsync();
//field = _mapper.Map<FieldModel>(updateFieldRequest.FieldRequest);
fieldModel.Name = updateFieldRequest.Name;
fieldModel.Size = updateFieldRequest.Size;
fieldModel.Price = updateFieldRequest.Price;
fieldModel.IsOpen = updateFieldRequest.IsOpen;
fieldModel.DiscountModel.Percentage = updateFieldRequest.UpdateDiscountRequest.Percentage.Value;
fieldModel.DiscountModel.StartDate = updateFieldRequest.UpdateDiscountRequest.StartDate.Value;
fieldModel.DiscountModel.EndDate = updateFieldRequest.UpdateDiscountRequest.EndDate.Value;
fieldModel.DiscountModel.Detail = updateFieldRequest.UpdateDiscountRequest.Detail;
fieldModel.UpdatedDate = DateTime.Now;
foreach (var item in updateFieldRequest.UpdatePictureFieldRequest)
{
var picToUpdate = fieldModel.ImageFieldModel.Where(w => w.Id == item.Id).FirstOrDefault();
if (picToUpdate == null)
{
fieldModel.ImageFieldModel.Add(
new ImageFieldModel
{
FieldId = fieldModel.Id,
Image = item.Image,
UpdatedDate = DateTime.Now,
CreatedDate = DateTime.Now
});
}
else
{
picToUpdate.Image = item.Image;
picToUpdate.UpdatedDate = DateTime.Now;
}
}
_repositoryWrapper.Field.Updete(fieldModel);
await _repositoryWrapper.SaveAsync();
await _repositoryWrapper.CommitAsync();
return(true);
}
catch (Exception ex)
{
throw ex;
}
finally
{
_repositoryWrapper.Dispose();
}
}
