public void ValidatePerformsValidatorsIteration()
{
var iocInstance = IoCContainer.Instance;
var iocInstanceMock = new Mock <IIoCContainer>(MockBehavior.Strict);
IoCContainer.Instance = iocInstanceMock.Object;
var firstValidatorMock = new Mock <IValidator <UpdateServiceRequest> >(MockBehavior.Strict);
var secondValidatorMock = new Mock <IValidator <UpdateServiceRequest> >(MockBehavior.Strict);
iocInstanceMock.Setup(x => x.ResolveAll <IValidator <UpdateServiceRequest> >()).Returns(
new List <IValidator <UpdateServiceRequest> > {
firstValidatorMock.Object, secondValidatorMock.Object
});
var sut = new UpdateServiceRequest();
firstValidatorMock.Setup(x => x.Validate(sut));
secondValidatorMock.Setup(x => x.Validate(sut));
sut.Validate();
iocInstanceMock.VerifyAll();
firstValidatorMock.VerifyAll();
secondValidatorMock.VerifyAll();
IoCContainer.Instance = iocInstance;
}
public async Task <IActionResult> UpdateService(int serviceId, [FromBody] UpdateServiceRequest request)
{
var updateServiceCommand = new UpdateServiceCommand(serviceId, request);
var result = await mediator.Send(updateServiceCommand);
return(StatusCode((int)result.Code, result.Value));
}
public UpdateServiceResponse UpdateServiceSetting(UpdateServiceRequest request)
{
var response = new UpdateServiceResponse {
ResponseStatus = ResponseStatus.Success
};
var settingsProvider = new SettingsProvider();
try
{
if (request.ActionType == ActionType.Update)
{
response.isSuccessful = settingsProvider.UpdateService(request);
}
else
{
response.ResponseStatus = ResponseStatus.Failure;
response.ResponseDescription = "Not update action";
}
}
catch (Exception ex)
{
response.ResponseStatus = ResponseStatus.Failure;
response.ResponseDescription = ex.Message;
}
return(response);
}
public bool UpdateService(UpdateServiceRequest request)
{
var conn = GetConnection(ConnectionNames.CSPSqlDatabase);
var commandWrapper = GetStoredProcCommand("dbo.Update_Service", conn);
AddInParameter(commandWrapper, "@ServiceId", DbType.Int16, request.Service.ServiceId);
AddInParameter(commandWrapper, "@ServiceDescription", DbType.String, request.Service.ServiceDescription);
AddInParameter(commandWrapper, "@Price", DbType.Int16, request.Service.Price);
AddInParameter(commandWrapper, "@Type", DbType.Int16, request.Service.Type);
AddInParameter(commandWrapper, "@ERROR", DbType.String, 1000);
AddInParameter(commandWrapper, "@ERROR_CODE", DbType.String, 4);
try
{
conn.Open();
int results = commandWrapper.ExecuteNonQuery();
var isProcedureSucced = Convert.ToBoolean(results);
MakeDboLog(request.ToString(), isProcedureSucced.ToString(), "dbo.Update_Service");
var errorObject = GetParameterValue(commandWrapper, "@ERROR");
var errorCodeObject = GetParameterValue(commandWrapper, "@ERROR_CODE");
return(Convert.ToBoolean(results));
}
finally
{
commandWrapper.Dispose();
conn.Close();
}
}
/// <summary>Snippet for UpdateService</summary>
public void UpdateServiceRequestObject()
{
// Snippet: UpdateService(UpdateServiceRequest, CallSettings)
// Create client
ServicesClient servicesClient = ServicesClient.Create();
// Initialize request argument(s)
UpdateServiceRequest request = new UpdateServiceRequest
{
Name = "",
Service = new Service(),
UpdateMask = new FieldMask(),
MigrateTraffic = false,
};
// Make the request
Operation <Service, OperationMetadataV1> response = servicesClient.UpdateService(request);
// Poll until the returned long-running operation is complete
Operation <Service, OperationMetadataV1> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Service result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Service, OperationMetadataV1> retrievedResponse = servicesClient.PollOnceUpdateService(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Service retrievedResult = retrievedResponse.Result;
}
// End snippet
}
internal UpdateServiceResponse UpdateService(UpdateServiceRequest request)
{
var marshaller = new UpdateServiceRequestMarshaller();
var unmarshaller = UpdateServiceResponseUnmarshaller.Instance;
return(Invoke <UpdateServiceRequest, UpdateServiceResponse>(request, marshaller, unmarshaller));
}
private void Update(IWebClient client)
{
var request = new UpdateServiceRequest
{
Name = "My-Example-Service-Updated",
ServiceId = _serviceId
};
try
{
var response = client.GetResponse(request);
Console.WriteLine("==========================Result==========================");
Console.WriteLine("Service Name: {0}", response.Name);
Console.WriteLine("Response: \r\n{0}", response.ResponseJsonString);
Console.WriteLine("==========================Result==========================");
}
catch (ServerException ex)
{
Console.WriteLine("ServerException happened: \r\n\tErrorCode: {0}\r\n\tErrorMessage: {1}",
ex.ErrorCode,
ex.ErrorMessage);
}
catch (ClientException ex)
{
Console.WriteLine("ClientException happened: \r\n\tRequestId: {0}\r\n\tErrorCode: {1}\r\n\tErrorMessage: {2}",
ex.RequestId,
ex.ErrorCode,
ex.ErrorMessage);
}
catch (Exception ex)
{
Console.WriteLine("Unknown Exception happened: {0}\r\n{1}", ex.Message, ex.StackTrace);
}
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateService operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateService operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <UpdateServiceResponse> UpdateServiceAsync(UpdateServiceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new UpdateServiceRequestMarshaller();
var unmarshaller = UpdateServiceResponseUnmarshaller.Instance;
return(InvokeAsync <UpdateServiceRequest, UpdateServiceResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateService operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateService operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/UpdateService">REST API Reference for UpdateService Operation</seealso>
public virtual Task <UpdateServiceResponse> UpdateServiceAsync(UpdateServiceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateServiceResponseUnmarshaller.Instance;
return(InvokeAsync <UpdateServiceResponse>(request, options, cancellationToken));
}
internal virtual UpdateServiceResponse UpdateService(UpdateServiceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateServiceResponseUnmarshaller.Instance;
return(Invoke <UpdateServiceResponse>(request, options));
}
public UpdateServiceRequest GetUpdateServiceRequest(Service service)
{
var request = new UpdateServiceRequest()
{
Service = service,
ActionType = Requests.ActionType.Update
};
return(request);
}
private threadingTask.Task UpdateService()
{
var request = new UpdateServiceRequest
{
Cluster = DefaultSettings.General.ClusterName,
Service = DefaultSettings.General.ServiceName,
TaskDefinition = TaskDefenition.TaskDefinitionArn
};
return(ECSClient.UpdateServiceAsync(request));
}
public async Task <IActionResult> Update([FromBody] UpdateServiceRequest request)
{
var command = new UpdateServiceCommand(request.ServiceId, request.Name, request.AllowHalfTime);
var result = await updateServiceService.Process(command);
return(Ok(new ApiReturnItem <ServiceResult>
{
Item = result,
Success = true
}));
}
private async Task UpdateService(EcsDeployContext context, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var request = new UpdateServiceRequest
{
Cluster = context.ClusterName,
Service = context.ServiceName,
DesiredCount = 1,
};
await ecs.UpdateServiceAsync(request, cancellationToken);
}
public async Task <GetServiceResponse> UpdateServiceRequest(Guid id, UpdateServiceRequest dto)
{
var serviceRequest = await _unitOfWork.ServiceRequests.Get(id);
// validate
if (serviceRequest is null)
{
throw new KeyNotFoundException("Service does not exist.");
}
Status[] notAllowedStatuses = { Status.Completed, Status.Cancelled };
if (notAllowedStatuses.Contains(serviceRequest.Status))
{
throw new AppException("Service is in {0} status and cannot be updated.", serviceRequest.Status);
}
// update
if (serviceRequest.Status == Status.Assigned || serviceRequest.Status == Status.InProgress)
{
if (dto.PlannedExecutionDate is not null && serviceRequest.PlannedExecutionDate != dto.PlannedExecutionDate)
{
serviceRequest.PlannedExecutionDate = dto.PlannedExecutionDate;
}
}
// only planned execution date can be set in inprogress status
if (serviceRequest.Status != Status.InProgress)
{
if (dto.CustomerId is not null && serviceRequest.CustomerId != dto.CustomerId)
{
serviceRequest.CustomerId = dto.CustomerId ?? serviceRequest.CustomerId;
}
if (dto.AddressId is not null && serviceRequest.AddressId != dto.AddressId)
{
serviceRequest.AddressId = dto.AddressId ?? serviceRequest.AddressId;
}
if (!string.IsNullOrEmpty(dto.Title) && serviceRequest.Title != dto.Title)
{
serviceRequest.Title = dto.Title;
}
if (!string.IsNullOrEmpty(dto.Description) && serviceRequest.Description != dto.Description)
{
serviceRequest.Description = dto.Description;
}
}
_unitOfWork.Commit();
return(_mapper.Map <GetServiceResponse>(serviceRequest));
}
/// <summary>Snippet for UpdateService</summary>
public void UpdateService_RequestObject()
{
// Snippet: UpdateService(UpdateServiceRequest,CallSettings)
// Create client
ServiceMonitoringServiceClient serviceMonitoringServiceClient = ServiceMonitoringServiceClient.Create();
// Initialize request argument(s)
UpdateServiceRequest request = new UpdateServiceRequest
{
Service = new Service(),
};
// Make the request
Service response = serviceMonitoringServiceClient.UpdateService(request);
// End snippet
}
public ActionResult UpdateService(int userId, UpdateServiceRequest updateServiceRequest)
{
if (updateServiceRequest == null)
{
return(BadRequest(new { error = "We Need More Info About Your Service" }));
}
var updatedUser = _serviceRepository.UpdateService(
userId,
updateServiceRequest.Name,
updateServiceRequest.Description,
updateServiceRequest.Price);
return(Ok());
}
public async Task CanUpdateService()
{
await _api.LoginAsync(ScopeFlags.Core);
var request = new UpdateServiceRequest {
Enabled = true,
Settings = new AadeMyDataSettings {
SubscriptionKey = "123"
}
};
var updatedService = await _api.Subscriptions("a4ab1442-b568-4817-87c3-63fb71ddea71")
.Plan()
.Services(Guid.Parse("904971A4-DED2-4B32-A408-343ADBD7522E"))
.UpdateAsync(request);
}
/// <summary>
/// 更新服务
/// </summary>
/// <param name="req"><see cref="UpdateServiceRequest"/></param>
/// <returns><see cref="UpdateServiceResponse"/></returns>
public UpdateServiceResponse UpdateServiceSync(UpdateServiceRequest req)
{
JsonResponseModel <UpdateServiceResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "UpdateService");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <UpdateServiceResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
/// <summary>Snippet for UpdateServiceAsync</summary>
public async Task UpdateServiceAsync_RequestObject()
{
// Snippet: UpdateServiceAsync(UpdateServiceRequest,CallSettings)
// Additional: UpdateServiceAsync(UpdateServiceRequest,CancellationToken)
// Create client
ServiceMonitoringServiceClient serviceMonitoringServiceClient = await ServiceMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateServiceRequest request = new UpdateServiceRequest
{
Service = new Service(),
};
// Make the request
Service response = await serviceMonitoringServiceClient.UpdateServiceAsync(request);
// End snippet
}
public void Setup()
{
this.iocContainerMock = new Mock <IIoCContainer>(MockBehavior.Strict);
IoCContainer.Instance = this.iocContainerMock.Object;
this.validator = new UpdateServiceRequestValidator();
iocContainerMock.Setup(x => x.ResolveAll <IValidator <UpdateServiceRequest> >()).Returns(new List <IValidator <UpdateServiceRequest> >()
{
this.validator
});
this.validServiceRequest = new UpdateServiceRequest
{
ServiceId = "ASDFASDFASD4FA65D4SF6A4DS",
Code = "MEAL2",
ServiceSellKey = "1231",
SellKey = "1",
PaxId = "1",
Type = ServiceType.Baggage
};
}
public void UpdateService2()
{
Mock <ServiceMonitoringService.ServiceMonitoringServiceClient> mockGrpcClient = new Mock <ServiceMonitoringService.ServiceMonitoringServiceClient>(MockBehavior.Strict);
UpdateServiceRequest request = new UpdateServiceRequest
{
Service = new Service(),
};
Service expectedResponse = new Service
{
ServiceName = new ServiceName("[PROJECT]", "[SERVICE]"),
DisplayName = "displayName1615086568",
};
mockGrpcClient.Setup(x => x.UpdateService(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
ServiceMonitoringServiceClient client = new ServiceMonitoringServiceClientImpl(mockGrpcClient.Object, null);
Service response = client.UpdateService(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task UpdateServiceAsync2()
{
Mock <ServiceMonitoringService.ServiceMonitoringServiceClient> mockGrpcClient = new Mock <ServiceMonitoringService.ServiceMonitoringServiceClient>(MockBehavior.Strict);
UpdateServiceRequest request = new UpdateServiceRequest
{
Service = new Service(),
};
Service expectedResponse = new Service
{
ServiceName = new ServiceName("[PROJECT]", "[SERVICE]"),
DisplayName = "displayName1615086568",
};
mockGrpcClient.Setup(x => x.UpdateServiceAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Service>(Task.FromResult(expectedResponse), null, null, null, null));
ServiceMonitoringServiceClient client = new ServiceMonitoringServiceClientImpl(mockGrpcClient.Object, null);
Service response = await client.UpdateServiceAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Updates the service.
/// </summary>
/// <param name="serviceId">The service identifier.</param>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <APIResponse> UpdateService(int serviceId, UpdateServiceRequest request)
{
try
{
string filename = "";
var folderName = Path.Combine("Service");
var pathToSave = Path.Combine("D:", "HappyWedding", folderName);
if (request.Photo.Length > 0)
{
string format = System.IO.Path.GetExtension(request.Photo.FileName);
filename = request.VendorId + "_Service_" + DateTime.Now + format;
string filenme = filename.Replace(":", ".");
var filePath = Path.Combine(pathToSave, filenme);
using var fileStream = new FileStream(filePath, FileMode.Create);
request.Photo.CopyTo(fileStream);
request.PhotoPath = filePath;
request.PhotoPath = null;
}
var client = httpClientFactory.CreateClient(VendorServiceOperation.serviceName);
var param = JsonConvert.SerializeObject(request);
HttpContent contentPost = new StringContent(param, Encoding.UTF8, "application/json");
var response = await client.PutAsync(servicesConfig.Vendor +
VendorServiceOperation.UpdateService(serviceId), contentPost);
if (response.StatusCode == HttpStatusCode.NoContent)
{
}
return(JsonConvert.DeserializeObject <APIResponse>(await response.Content.ReadAsStringAsync()));
}
catch (Exception ex)
{
logger.Error(ex, "Exception in method 'UpdateService()'");
var exMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
return(new APIResponse(exMessage, HttpStatusCode.InternalServerError));
}
}
public async Task <ActionResult> Put(string id, [FromBody] UpdateServiceRequest req)
{
var serviceRequest = await _query.GetAsync(id);
if (serviceRequest != null)
{
try
{
// 1. try to rebuild aggregate
ServiceRequestAggregate serviceRequestAggregate = new ServiceRequestAggregate(
serviceRequest.Id,
serviceRequest.BuildingCode,
serviceRequest.Description,
serviceRequest.Status,
serviceRequest.CreatedBy,
serviceRequest.CreatedDate,
serviceRequest.LastModifiedBy,
serviceRequest.LastUpdatedBy
);
// 2. try to update status
// I assumed this was the main thing to update?
// if more needs to be updated the aggregate can be extended with methods to do so
serviceRequestAggregate.UpdateStatus(req.status);
// 2. persist new aggregate
await _repo.UpdateAsync(serviceRequestAggregate);
return(Ok(serviceRequestAggregate));
} catch (ServiceRequestDomainException ex)
{
return(BadRequest(ex.Message));
}
}
else
{
return(NotFound("Resource Not Found"));
}
}
public async Task CanUpdateService()
{
await _api.LoginAsync(ScopeFlags.Core);
var request = new UpdateServiceRequest {
Enabled = true,
Settings = new AadeMyDataSettings {
BaseUrl = "https://mydata-dev.azure-api.net",
UserId = "XXX",
SubscriptionKey = "XXX",
TransmissionOptions = new List <TransmissionOption> {
new TransmissionOption {
DocumentTypeId = Guid.Parse("949b1031-11e0-4641-2fa9-08d57d183663"), Type = TransmissionType.Manual
}
}
}
};
var updatedService = await _api.Subscriptions("a4ab1442-b568-4817-87c3-63fb71ddea71")
.Plan()
.Services(Guid.Parse("904971a4-ded2-4b32-a408-343adbd7522e"))
.UpdateAsync(request);
}
private async Task UnregisterServices(IEnumerable <RegisterServiceRequest> services)
{
var transactionId = Guid.NewGuid();
foreach (var service in services)
{
var updateRequest = new UpdateServiceRequest
{
Status = ServiceStatus.Disconnected,
Name = service.Name,
Security = service.Security,
Uri = service.Uri,
Version = service.Version,
TransactionId = transactionId,
UserId = service.UserId,
};
await _serviceRegistryClient.UpdateServiceAsync(service.Id, updateRequest);
_logger.LogInfo($"Updated service: {service.Name}");
}
}
/// <summary>
/// Updates the configuration of the specified service.
/// </summary>
/// <param name="request">The request object containing all of the parameters for the API call.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override async stt::Task <lro::Operation <Service, OperationMetadataV1> > UpdateServiceAsync(UpdateServiceRequest request, gaxgrpc::CallSettings callSettings = null)
{
Modify_UpdateServiceRequest(ref request, ref callSettings);
return(new lro::Operation <Service, OperationMetadataV1>(await _callUpdateService.Async(request, callSettings).ConfigureAwait(false), UpdateServiceOperationsClient));
}
/// <summary>
/// Updates the configuration of the specified service.
/// </summary>
/// <param name="request">The request object containing all of the parameters for the API call.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>The RPC response.</returns>
public override lro::Operation <Service, OperationMetadataV1> UpdateService(UpdateServiceRequest request, gaxgrpc::CallSettings callSettings = null)
{
Modify_UpdateServiceRequest(ref request, ref callSettings);
return(new lro::Operation <Service, OperationMetadataV1>(_callUpdateService.Sync(request, callSettings), UpdateServiceOperationsClient));
}
partial void Modify_UpdateServiceRequest(ref UpdateServiceRequest request, ref gaxgrpc::CallSettings settings);
