public void UpdateClient(Guid clientId, string propertyName, object value, Action <ResponseBase> callback) { Task.Factory.StartNew(() => { Guid messageId = Guid.NewGuid(); try { UpdateClientRequest request = new UpdateClientRequest { MessageId = messageId, LoginName = LoginName, ClientId = clientId, PropertyName = propertyName, Value = value, Timestamp = DateTime.Now }; request.SignIt(Password); using (var service = CreateService()) { ResponseBase response = service.UpdateClient(request); callback?.Invoke(response); } } catch (CommunicationException e) { Global.DebugLine(e.Message, ConsoleColor.Red); callback?.Invoke(ResponseBase.ClientError(messageId, e.Message)); } catch (Exception e) { Global.Logger.Error(e.Message, e); callback?.Invoke(ResponseBase.ClientError(messageId, e.Message)); } }); }
public async Task UpdateClient(Boolean mediatorResult) { Random random = new Random(); Guid id = random.NextGuid(); var request = new UpdateClientRequest { }; var mediatorMock = new Mock <IMediator>(MockBehavior.Strict); mediatorMock.Setup(x => x.Send(It.Is <UpdateClientCommand>(y => y.Request == request && y.Request.SystemId == id), It.IsAny <CancellationToken>())).ReturnsAsync(mediatorResult).Verifiable(); var controller = new ClientController( mediatorMock.Object, Mock.Of <IClientRepository>(MockBehavior.Strict), Mock.Of <ILogger <ClientController> >() ); var actionResult = await controller.UpdateClient(id, request); if (mediatorResult == true) { actionResult.EnsureNoContentResult(); } else { actionResult.EnsureBadRequestObjectResult("unable to complete service operation"); } mediatorMock.Verify(); }
private async Task SaveClick() { if (ToSave.ClientId == 0) { var toCreate = new CreateClientRequest() { FullName = ToSave.FullName, EmailAddress = ToSave.EmailAddress, Salutation = ToSave.Salutation, PreferredDoctorId = ToSave.PreferredDoctorId, PreferredName = ToSave.PreferredName, }; await ClientService.CreateAsync(toCreate); } else { var toUpdate = new UpdateClientRequest() { ClientId = ToSave.ClientId, FullName = ToSave.FullName, EmailAddress = ToSave.EmailAddress, Salutation = ToSave.Salutation, PreferredDoctorId = ToSave.PreferredDoctorId, PreferredName = ToSave.PreferredName, }; await ClientService.EditAsync(toUpdate); } CancelClick(); await ReloadData(); }
public ActionResult <int> Put( [FromRoute] int id, [FromBody] UpdateClientRequest clientRequest) { if (!ModelState.IsValid || id != clientRequest.Id) { return(BadRequest()); } var client = mockClients.GetById(id); if (client == null) { return(NotFound()); } client.Name = clientRequest.Name; client.Email = clientRequest.Email; client.Gender = clientRequest.Gender; client.Phone = clientRequest.Phone; mockClients.Update(client); return(Ok(new { client.Id })); }
static void ExecuteJson() { var client = new JsonServiceClient("http://*****:*****@email.com" }; ClientResponse response = client.Post <ClientResponse>(createRequest); var updateRequest = new UpdateClientRequest { Email = "*****@*****.**", Id = response.Id }; response = client.Put <ClientResponse>(updateRequest); var getClientRequest = new GetClientRequest { Id = response.Id }; response = client.Get <ClientResponse>(getClientRequest); var deleteRequest = new DeleteClientRequest { Id = response.Id }; client.Delete(deleteRequest); }
static void ExecuteSoap() { var client = new SoapServiceClient("NeliburSoapService"); var createRequest = new CreateClientRequest { Email = "*****@*****.**" }; ClientResponse response = client.Post <ClientResponse>(createRequest); var updateRequest = new UpdateClientRequest { Email = "*****@*****.**", Id = response.Id }; response = client.Put <ClientResponse>(updateRequest); var getClientRequest = new GetClientRequest { Id = response.Id }; response = client.Get <ClientResponse>(getClientRequest); var deleteRequest = new DeleteClientRequest { Id = response.Id }; client.Delete(deleteRequest); }
public void Update(Client client) { var request = new UpdateClientRequest(); request.Client = client; var response = HttpPost <UpdateClientRequest>("api/client/update", request, MediaType.Json); }
public ResponseBase UpdateClient(UpdateClientRequest request) { if (request == null) { return(LoadClientResponse.InvalidInput(Guid.Empty, "参数错误")); } try { if (string.IsNullOrEmpty(request.LoginName)) { return(ResponseBase.InvalidInput(request.MessageId, "登录名不能为空")); } if (!HostRoot.Current.UserSet.TryGetKey(request.LoginName, out IUser key)) { return(ResponseBase.Forbidden(request.MessageId)); } if (!request.Timestamp.IsInTime()) { return(ResponseBase.Expired(request.MessageId)); } if (request.Sign != request.GetSign(key.Password)) { return(ResponseBase.Forbidden(request.MessageId, "签名验证未通过")); } HostRoot.Current.ClientSet.UpdateClient(request.ClientId, request.PropertyName, request.Value); return(ResponseBase.Ok(request.MessageId)); } catch (Exception e) { Global.Logger.ErrorDebugLine(e.Message, e); return(ResponseBase.ServerError(request.MessageId, e.Message)); } }
public BaseResponse UpdateClient(UpdateClientRequest request) { return(ServiceProcessor.ProcessRequest(request, //inbound.do validate or do something here () => { }, req => { var response = new BaseResponse(); using (var repo = new NhRepository <Client>()) { var entity = repo.GetById(req.Id); if (entity == null) { throw new EeException(ErrorCodes.NotFound, "Object is not found."); } entity.Name = req.Name; //TODO: repo.Update(entity); } return response; } )); }
public IActionResult Update(int id, UpdateClientRequest updateClientRequest) { _authenticationService.IsAuthorized(Request, "EMPLOYEE"); validateModel(); _clientsService.Update(id, updateClientRequest); return(NoContent()); }
public async Task <int> UpdateClient(UpdateClientRequest request) { Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = _db.Database.BeginTransaction(); ClientEntity client = await _db.Client.FindAsync(request.Id); if (client == null) { throw new ClientNotFoundException(request.Id); } await _db.Client.Where(a => a.Id == request.Id).UpdateAsync(c => new ClientEntity { FirstName = request.FirstName, LastName = request.LastName, SexId = (byte)request.Sex, PersonalNumber = request.PersonalNumber, BirthDate = request.BirthDate, BirthCity = request.City, PhotoUrl = request.PhotoAddress, }); if (request.PhoneNumbers.Any()) { await _db.ClientPhoneNumber.Where(c => c.ClientId == client.Id && !request.PhoneNumbers.Select(p => (byte)p.Type).Contains(c.TypeId)).DeleteAsync(); } await _db.BulkMergeAsync(request.PhoneNumbers.Select(x => new ClientPhoneNumberEntity { ClientId = request.Id, TypeId = (byte)x.Type, Phone = x.Phone }), o => o.ColumnPrimaryKeyExpression = c => new { c.ClientId, c.TypeId }); await transaction.CommitAsync(); return(client.Id); }
public void UpdateClientAsync(string objectId, string propertyName, object value, Action<ResponseBase, Exception> callback) { UpdateClientRequest request = new UpdateClientRequest { ObjectId = objectId, PropertyName = propertyName, Value = value }; JsonRpcRoot.SignPostAsync(RpcRoot.OfficialServerHost, RpcRoot.OfficialServerPort, _controllerName, nameof(IClientDataController.UpdateClient), data: request, callback); }
public int EnableAccess(UpdateClientRequest request) { return(Repository.Prowatch.ExecuteNonQuery("LNF.dbo.ClientUpdate", new Dictionary <string, object> { ["Action"] = "EnableAccess", ["ClientID"] = request.ClientID, ["ExpireOn"] = Utility.DBNullIf(request.ExpireOn) }, CommandType.StoredProcedure)); }
public object Put(UpdateClientRequest request) { Client client = _clients.Single(x => x.Id == request.Id); client.Email = request.Email; return(new ClientResponse { Id = client.Id, Email = client.Email }); }
public async Task <RegisteredClient> Handle(UpdateClientRequest request, CancellationToken cancellationToken) { var client = request.ToEntity(); this._dbContext.Clients.Attach(client).State = EntityState.Modified; await this._dbContext.SaveChangesAsync(); return(client.ToDTO()); }
public void UpdateClientAsync(string objectId, string propertyName, object value, Action <ResponseBase, Exception> callback) { UpdateClientRequest request = new UpdateClientRequest { ObjectId = objectId, PropertyName = propertyName, Value = value }; RpcRoot.PostAsync(NTMinerRegistry.GetControlCenterHost(), NTKeyword.ControlCenterPort, _controllerName, nameof(IClientController.UpdateClient), request, request, callback); }
public void UpdateClientAsync(string objectId, string propertyName, object value, Action <ResponseBase, Exception> callback) { UpdateClientRequest request = new UpdateClientRequest { ObjectId = objectId, PropertyName = propertyName, Value = value }; PostAsync(SControllerName, nameof(IControlCenterController.UpdateClient), request.ToQuery(SingleUser.LoginName, SingleUser.PasswordSha1), request, callback); }
public object Put(UpdateClientRequest request) { Console.WriteLine("Put Request: {0}", request); Client client = _clients.Single(x => x.Id == request.Id); client.Email = request.Email; return(new ClientResponse { Id = client.Id, Email = client.Email }); }
public async Task <IHttpActionResult> UpdateClient([FromUri] int update, [FromBody] UpdateClientRequest updateRequest) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _clientService.UpdateClientAsync(update, updateRequest); return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent))); }
public HttpResponseMessage UpdateClient(UpdateClientRequest model) { if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } SuccessResponse response = new SuccessResponse(); ClientsService.UpdateClient(model); return(Request.CreateResponse(response)); }
private static void Main() { AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler; // PerformanceTest(); var client = new JsonServiceClient(Settings.Default.ServiceAddress); var createRequest = new CreateClientRequest { Email = "*****@*****.**" }; var response = client.Post <ClientResponse>(createRequest); Console.WriteLine("POST Response: {0}\n", response); var updateRequest = new UpdateClientRequest { Email = "*****@*****.**", Id = response.Id }; response = client.Put <ClientResponse>(updateRequest); Console.WriteLine("PUT Response: {0}\n", response); var getClientRequest = new GetClientRequest { Id = response.Id, Date = DateTime.Now.Date }; response = client.Get <ClientResponse>(getClientRequest); Console.WriteLine("GET Response: {0}\n", response); var deleteRequest = new DeleteClientRequest { Id = response.Id }; client.Delete(deleteRequest); var certificate = new MemoryStream(File.ReadAllBytes("Certificate.cer")); var uploadRequest = new UploadRequest { FileContents = certificate.ToArray(), OriginalFileName = "MyFileName.cert", UploaderId = Guid.NewGuid().ToString() }; client.Post(uploadRequest); Console.ReadKey(); }
public async Task <IHttpActionResult> AddClient([FromBody] UpdateClientRequest createRequest) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var client = await _clientService.CreateClientAsync(createRequest); var location = string.Format("/api/clients/{0}", client.OrderId); return(Created <Client>(location, client)); }
public static Client ToEntity(this UpdateClientRequest request) { return(new Client { Id = request.Id, Address = request.Address, DNI = request.DNI, Email = request.Email, LastNames = request.LastNames, Names = request.Names, Phone = request.Phone }); }
/// <summary> /// Clients / Update Client /// </summary> /// <param name="clientId">Client ID</param> public async Task <UpdateClientResponse> UpdateClientAsync(UpdateClientRequest request) { if (request == null) { throw new ArgumentNullException("Value cannot be null.", nameof(request)); } if (string.IsNullOrEmpty(request.Name)) { throw new ArgumentException("Value cannot be null or empty.", nameof(request.Name)); } return(await ExecuteAsync <UpdateClientResponse>(UpdateRequest <UpdateClientRequest>(CLIENTS_PATH, request.Id, request)).ConfigureAwait(false)); }
public async Task <bool> UpdateAsync(string clientId, UpdateClientRequest request, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(clientId)) { throw new ArgumentNullException(nameof(clientId)); } cancellationToken.ThrowIfCancellationRequested(); await _client.SetAuthHeaderAsync(cancellationToken); var content = JsonSerializer.Serialize(request, _client.Options); var results = await _client.HttpClient.PatchAsync($"api/v2/clients/{clientId}", new StringContent(content, Encoding.UTF8, "application/json"), cancellationToken); return(results.IsSuccessStatusCode); }
public UpdateClientRequest GetUpdateUserDateRequest(ClientProfile client, Role role, int teamId, int userId, ClientProfile oldClientProfile) { var request = new UpdateClientRequest { Client = client, Role = role, TeamId = teamId, UserId = userId, OldClientProfile = oldClientProfile, ActionType = DataBaseCommunication.Mappers.Requests.ActionType.Update }; return(request); }
private async void UpdateClient() { UpdateClientRequest updateClientRequest = new UpdateClientRequest { FirstName = tbIme.Text, LastName = tbPrezime.Text, Email = tbEmail.Text, Address = tbAdresa.Text, PhoneNumber = tbTelefon.Text, Password = tbPassword.Text, Status = fromString(cbStatus.Text) }; await _apiService.Update <Client>(_clientForEdit.Id, updateClientRequest); }
public async Task<ActionResult> Put([FromBody] UpdateClientRequest updateClientRequest) { if (updateClientRequest == null) { return BuildError(ErrorCodes.InvalidRequestCode, "no parameter in body request", HttpStatusCode.BadRequest); } if (!await _clientActions.UpdateClient(updateClientRequest.ToParameter())) { return new StatusCodeResult(StatusCodes.Status500InternalServerError); } await _representationManager.AddOrUpdateRepresentationAsync(this, GetClientStoreName + updateClientRequest.ClientId, false); await _representationManager.AddOrUpdateRepresentationAsync(this, GetClientsStoreName, false); return new NoContentResult(); }
public async Task <BaseResponse> ExecuteAsync(Uri clientsUri, UpdateClientRequest client, string authorizationHeaderValue = null) { if (clientsUri == null) { throw new ArgumentNullException(nameof(clientsUri)); } if (client == null) { throw new ArgumentNullException(nameof(client)); } var httpClient = _httpClientFactory.GetHttpClient(); var serializedJson = JsonConvert.SerializeObject(client).ToString(); var body = new StringContent(serializedJson, Encoding.UTF8, "application/json"); var request = new HttpRequestMessage { Method = HttpMethod.Put, RequestUri = clientsUri, Content = body }; if (!string.IsNullOrWhiteSpace(authorizationHeaderValue)) { request.Headers.Add("Authorization", "Bearer " + authorizationHeaderValue); } var httpResult = await httpClient.SendAsync(request); var content = await httpResult.Content.ReadAsStringAsync().ConfigureAwait(false); try { httpResult.EnsureSuccessStatusCode(); } catch (Exception) { return(new BaseResponse { ContainsError = true, Error = JsonConvert.DeserializeObject <ErrorResponse>(content), HttpStatus = httpResult.StatusCode }); } return(new BaseResponse()); }
public async Task <ActionResult> Put([FromBody] UpdateClientRequest updateClientRequest) { if (updateClientRequest == null) { throw new ArgumentNullException(nameof(updateClientRequest)); } if (!await _clientActions.UpdateClient(updateClientRequest.ToParameter())) { return(new StatusCodeResult(StatusCodes.Status500InternalServerError)); } await _representationManager.AddOrUpdateRepresentationAsync(this, GetClientStoreName + updateClientRequest.ClientId, false); await _representationManager.AddOrUpdateRepresentationAsync(this, GetClientsStoreName, false); return(new NoContentResult()); }
public void Put(UpdateClientRequest request) { Repository.Update(request.Entity); }