public static ChangeTrackingResponse ChangeTracking(ChangeTrackingRequest request) { ChangeTrackingResponse retVal = new ChangeTrackingResponse(); List<EntityObjectProperty> toRemove = new List<EntityObjectProperty>(); foreach (EntityObjectProperty property in request.Target.Properties) { if(property.Name != CalendarEventResourceEntity.FieldEventId) { toRemove.Add(property); } } foreach (EntityObjectProperty property in toRemove) { request.Target.Properties.Remove(property); } request.Target.Properties.Add(CalendarEventResourceEntity.FieldStatus, (int)request.Status); UpdateRequest updateRequest = new UpdateRequest(request.Target); BusinessManager.Execute(updateRequest); if(request.SendNotify) { //TODO: Send notify impl } return retVal; }
public void CommitModifiedObject() { int callCount = 0; int exptectedCallCount = 1; var organisationService = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService(); organisationService.ExecuteOrganizationRequest = (request) => { callCount++; var results = new OrganizationResponse(); return results; }; var crmUnitOfWork = new CrmUnitOfWork(organisationService); var contactRepository = new Xrm.Infrastructure.DataAccess.Crm.Fakes.StubContactRepository(organisationService, crmUnitOfWork); contactRepository.PersistUpdatedEntityBase = (contact) => { var sdkContact = new Contact(); sdkContact.ContactId = contact.Id; sdkContact.FirstName = "test"; var updateRequest = new UpdateRequest() { Target = sdkContact }; crmUnitOfWork.Requests.Add(updateRequest); }; contactRepository.Update(new Xrm.Domain.Contact.Contact()); crmUnitOfWork.Commit(); Assert.AreEqual(exptectedCallCount, callCount); }
public ServerQueryLogic() { // fake a completed request this.currentRequest = new UpdateRequest(0, false); this.currentRequest.PendingTasks = new CountdownEvent(1); this.currentRequest.PendingTasks.Signal(); }
public ServerQueryLogic(GameExtensionPool gameExtensions) { this.gameExtensions = gameExtensions; // fake a completed request this.currentRequest = new UpdateRequest(0, 0, 500, gameExtensions.Get(0)); this.currentRequest.PendingTasks = new CountdownEvent(1); this.currentRequest.PendingTasks.Signal(); }
private static void CreateDoc(ISolrServerHandler server, string docId) { var doc = new SolrInputDocument(); doc.Fields.Add("id", new SolrInputField("id", docId)); doc.Fields.Add("name", new SolrInputField("name", "Test Document with ID " + docId)); var updateRequest = new UpdateRequest(server.GetUriBuilder()).Add(doc).Commit(true); server.Request<UpdateResponse>(updateRequest); Console.WriteLine("doc " + docId + " added"); }
public void CreateComplaint(UpdateRequest<ComplaintDTO> req) { using (var db = new PizzaUnitOfWork()) { db.inTransaction(uow => { db.Complaints.Insert(complaintAssembler.ToComplaint(req.Data)); }); } }
protected override UpdateRequest ConvertRequest(UpdateRequest request) { UpdateRequest returnValue = new UpdateRequest(); returnValue.ClientContext = CompressionUtility.Decompress(request.ClientContext); returnValue.GlobalContext = CompressionUtility.Decompress(request.GlobalContext); returnValue.ObjectData = CompressionUtility.Decompress(request.ObjectData); returnValue.Principal = CompressionUtility.Decompress(request.Principal); returnValue.ClientCulture = request.ClientCulture; returnValue.ClientUICulture = request.ClientUICulture; return returnValue; }
private static void AddObject(ISolrServerHandler server, SimpleBook book, IDataMappingHandler mapper) { var doc = mapper.GetDocument(book); var updateRequest = new UpdateRequest(server.GetUriBuilder()).Add(doc).Commit(true); //if (updateRequest.Content != null) //{ // using (var requestStream = File.OpenWrite("update.json")) // { // server.SerializerFactory.DefaultSerializer.Serialize(updateRequest.Content, requestStream); // } //} server.Request<UpdateResponse>(updateRequest); }
public UpdateRequestTests() { var project = new ElasticsearchProject { Id = 1 }; var request = new UpdateRequest<ElasticsearchProject, object>(project) { Doc = new { Name = "NEST" }, DocAsUpsert = true }; var response = this._client.Update(request); _status = response.ConnectionStatus; }
internal void UpdateVersion(List<Solution> lstExportSolution, string version) { foreach (var item in lstExportSolution) { UpdateRequest req = new UpdateRequest(); req.Target = new Entity() { Id=item.Id, LogicalName="solution" }; req.Target.Attributes.Add("version", version); CrmService.Execute(req); } }
public static void informServerOfMissingFile(String fileHash, String transferId) { // Tell the server to cancel bounce BackgroundWorker updateWorker = new BackgroundWorker(); updateWorker.DoWork += Downloads.updateWorker_DoWork; updateWorker.RunWorkerCompleted += Downloads.updateWorker_RunWorkerCompleted; // Set update parameters and kick off update UpdateRequest ur = new UpdateRequest(); ur.transferID = long.Parse(transferId); ur.status = "missing"; ur.uploader = Utils.getMACAddress(); ur.newHash = fileHash; updateWorker.RunWorkerAsync(ur); }
protected override void Page_Load(object sender, EventArgs e) { updateRequest = ObjectFromQueryString<UpdateRequest>(XpoHelper.GetNewSession()); if (updateRequest == null) { StatusMessage.ShowMessageWithHeader("Something went wrong!", "", Views.Controls.MessageControlType.Negative); } else { ImportTaskOverview.updateRequest = updateRequest; } base.Page_Load(sender, e); }
// Externally callabled methods /// <summary> /// Associate an email activity with a GovDelivery email by writing the email ID into a field on the entity /// </summary> /// <returns></returns> public void AssociateGovdeliveryEmail(string id, string govdId) { RetrieveRequest emailRequest = new RetrieveRequest() { ColumnSet = new ColumnSet("govd_id"), Target = new EntityReference("email", new Guid(id)) }; var email = retrieveEntity(emailRequest); email["govd_id"] = govdId; UpdateRequest updateEmail = new UpdateRequest() { Target = email }; this.getService().Execute(updateEmail); }
internal void UpdatePlugin(PluginInfo info,bool isRelease) { Entity pluginEntity = new Entity("pluginassembly"); pluginEntity.Id = info.Id; if (isRelease) { pluginEntity["content"] = Convert.ToBase64String(File.ReadAllBytes(info.ReleasePath)); } else { pluginEntity["content"] = Convert.ToBase64String(File.ReadAllBytes(info.Path)); } UpdateRequest req = new UpdateRequest(); req.Target = pluginEntity; _service.Execute(req); }
public async Task <bool> Update(string domain, string token) { var reg = RegistrationForDomain(domain); if (reg == null) { _log.Error("No registration found for domain {domain}", domain); return(false); } if (reg.Fulldomain == null) { _log.Error("Registration for domain {domain} appears invalid", domain); return(false); } if (!await VerifyCname(domain, reg.Fulldomain, 0)) { _log.Warning("Registration for domain {domain} appears invalid", domain); } using var client = Client(); client.DefaultRequestHeaders.Add("X-Api-User", reg.UserName); client.DefaultRequestHeaders.Add("X-Api-Key", reg.Password); var request = new UpdateRequest() { Subdomain = reg.Subdomain, Token = token }; try { _log.Debug("Sending update request to acme-dns server at {baseUri} for domain {domain}", _baseUri, domain); await client.PostAsync( $"update", new StringContent( JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json")); return(true); } catch (Exception ex) { _log.Error(ex, "Error sending update request to acme-dns server at {baseUri} for domain {domain}", _baseUri, domain); return(false); } }
internal void ModifyRequest(UpdateRequest request, Bucket bucket) { if (IfMetagenerationMatch != null && IfMetagenerationNotMatch != null) { throw new ArgumentException($"Cannot specify {nameof(IfMetagenerationMatch)} and {nameof(IfMetagenerationNotMatch)} in the same options", "options"); } if (ForceNoPreconditions == true && AnyExplicitPreconditions) { throw new ArgumentException($"Cannot specify {nameof(ForceNoPreconditions)} and any explicit precondition in the same options", "options"); } if (ForceNoPreconditions != true && !AnyExplicitPreconditions) { request.IfMetagenerationMatch = bucket.Metageneration; } else { if (IfMetagenerationMatch != null) { request.IfMetagenerationMatch = IfMetagenerationMatch; } if (IfMetagenerationNotMatch != null) { request.IfMetagenerationNotMatch = IfMetagenerationNotMatch; } } if (Projection != null) { request.Projection = GaxPreconditions.CheckEnumValue((ProjectionEnum)Projection, nameof(Projection)); } if (PredefinedAcl != null) { request.PredefinedAcl = GaxPreconditions.CheckEnumValue((PredefinedAclEnum)PredefinedAcl, nameof(PredefinedAcl)); } if (PredefinedDefaultObjectAcl != null) { request.PredefinedDefaultObjectAcl = GaxPreconditions.CheckEnumValue((PredefinedDefaultObjectAclEnum)PredefinedDefaultObjectAcl, nameof(PredefinedDefaultObjectAcl)); } if (UserProject != null) { request.UserProject = UserProject; } }
public override async Task <BaseReply> Update(UpdateRequest request, ServerCallContext context) { try { var rows = request.Rows .Select(x => new List <object>(x.Items .Select(i => { var res = new object(); try { res = JsonSerializer.Deserialize <object>(i); } catch { res = JsonSerializer.Deserialize <object>($"\"{i}\""); } return(res); }))).ToList(); await _tableDal.UpdateData(request.TableName, request.DbName, rows); var response = new BaseReply() { Code = 200 }; Console.WriteLine(); Console.WriteLine(); Console.WriteLine("***************************************************************************************************************"); Console.WriteLine("Rows updated: " + request.TableName + ", " + request.Rows.Count); Console.WriteLine("***************************************************************************************************************"); return(response); } catch (Exception ex) { return(new BaseReply() { Code = 400, Message = ex.Message, StackTrace = ex.StackTrace }); } }
/// <summary> /// /// </summary> /// <typeparam name="TEntity"></typeparam> /// <param name="connection"></param> /// <param name="tableName"></param> /// <param name="where"></param> /// <param name="fields"></param> /// <param name="hints"></param> /// <param name="transaction"></param> /// <param name="statementBuilder"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public static async Task <UpdateExecutionContext <TEntity> > CreateAsync <TEntity>(IDbConnection connection, string tableName, QueryGroup where, IEnumerable <Field> fields, string hints = null, IDbTransaction transaction = null, IStatementBuilder statementBuilder = null, CancellationToken cancellationToken = default) where TEntity : class { var key = GetKey <TEntity>(tableName, fields, hints, where); // Get from cache var context = UpdateExecutionContextCache.Get <TEntity>(key); if (context != null) { return(context); } // Create var dbFields = await DbFieldCache.GetAsync(connection, tableName, transaction, cancellationToken); var request = new UpdateRequest(tableName, connection, transaction, where, fields, hints, statementBuilder); var commandText = await CommandTextCache.GetUpdateTextAsync(request, cancellationToken); // Call context = CreateInternal <TEntity>(connection, tableName, dbFields, fields, commandText); // Add to cache UpdateExecutionContextCache.Add <TEntity>(key, context); // Return return(context); }
public void Can_set_request() { var request = new UpdateRequest { Target = new Entity() }; var context = new XrmFakedPluginExecutionContext { InputParameters = new ParameterCollection() }; context.SetRequest(request); Assert.Same(request.Target, context.InputParameters["Target"]); Assert.Equal("Update", context.MessageName); Assert.True(context.InputParameters.ContainsKey("ConcurrencyBehavior")); }
public async Task <IActionResult> Update(UpdateRequest request) { if (!ModelState.IsValid) { return(View()); } var result = await _userApiClient.UpdateUser(request.Id, request); if (result.IsSuccessed) { TempData["result"] = "Cập nhật người dùng thành công"; return(RedirectToAction("Index")); } ModelState.AddModelError("", result.Message); return(View(request)); }
/// <summary> /// /// </summary> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns></returns> internal static async Task <string> GetUpdateTextAsync(UpdateRequest request, CancellationToken cancellationToken = default) { var commandText = (string)null; if (cache.TryGetValue(request, out commandText) == false) { var fields = await GetActualFieldsAsync(request.Connection, request.Name, request.Fields, request.Transaction, cancellationToken); commandText = GetUpdateTextInternal(request, fields); cache.TryAdd(request, commandText); } return(commandText); }
/// <summary> /// Gets a command text from the cache for the <see cref="DbConnectionExtension.Update{TEntity}(IDbConnection, TEntity, QueryGroup, int?, IDbTransaction, ITrace, IStatementBuilder)"/> operation. /// </summary> /// <typeparam name="TEntity">The type of the target entity.</typeparam> /// <param name="request">The request object.</param> /// <returns>The cached command text.</returns> public static string GetUpdateText <TEntity>(UpdateRequest request) where TEntity : class { var commandText = (string)null; if (m_cache.TryGetValue(request, out commandText) == false) { var statementBuilder = EnsureStatementBuilder(request.Connection, request.StatementBuilder); commandText = statementBuilder.CreateUpdate(queryBuilder: new QueryBuilder <TEntity>(), where : request.Where); m_cache.TryAdd(request, commandText); } else { request.Where?.AppendParametersPrefix(); } return(commandText); }
public override async Task <UpdateResponse> Update(UpdateRequest request, ServerCallContext context) { //TODO: //var dto = new UpdateNotificationModel //{ // TourId = request.TourId, // TourName = request.TourName, // BookingId = request.BookingId, // BookingName = request.BookingName, // BookingNotes = request.BookingNotes, // ExpireDate = request.ExpireDate.ToDateTime(), // UserIds = request.AssignedUserIds //}; //await _notificationService.UpdateNotification(dto); return(new UpdateResponse() { }); }
public void ModifyRequest_DefaultOptions() { var obj = new Object { Generation = 10L, Metageneration = 20L }; var request = new UpdateRequest(null, obj, "bucket", "object"); var options = new UpdateObjectOptions(); options.ModifyRequest(request, obj); Assert.Null(request.Generation); Assert.Equal(10L, request.IfGenerationMatch); Assert.Null(request.IfGenerationNotMatch); Assert.Equal(20L, request.IfMetagenerationMatch); Assert.Null(request.IfMetagenerationNotMatch); Assert.Null(request.PredefinedAcl); Assert.Null(request.Projection); Assert.Null(request.UserProject); }
/// <summary> /// 部分更新 /// </summary> /// <typeparam name="TEntity"></typeparam> /// <typeparam name="TPartialEntity"></typeparam> /// <param name="elasticClient"></param> /// <param name="request"></param> /// <returns></returns> public static UpdateResponse <TEntity> UpdateDocumentPartial <TEntity>(this IElasticClient elasticClient , TEntity entity , object partialEntity , string indexName = null ) where TEntity : class { string idValue = ElasticsearchKit.GetIdPropertyValue(entity).ToStrAndTrim(); IUpdateRequest <TEntity, object> request = new UpdateRequest <TEntity, object>(indexName, idValue) { Doc = partialEntity }; //[ 部分字段/局部更新 (TPartialEntity中的字段) ] UpdateResponse <TEntity> response = elasticClient.Update(request); return(response); }
public RegisteredRequest AssignRequest(UpdateRequest updateRequest) { using (HelpDeskDataContext helpDeskDataContext = new HelpDeskDataContext()) { using (var transaction = helpDeskDataContext.Database.BeginTransaction()) { var request = updateRequest.ToEntity(); helpDeskDataContext.Requests.Attach(request); helpDeskDataContext.Entry(request).Property(x => x.AttentionUserId).IsModified = true; helpDeskDataContext.Entry(request).Property(x => x.State).IsModified = true; helpDeskDataContext.Entry(request).Property(x => x.GoalDate).IsModified = true; helpDeskDataContext.Entry(request).Property(x => x.LastUpdateUserId).IsModified = true; helpDeskDataContext.SaveChanges(); transaction.Commit(); return(request.ToDTO()); } } }
public void Test_LatestUpdaterIsNotCompatible_BreakingChanges() { ToolkitDataUnitOfWork unit = new ToolkitDataUnitOfWork(this.Context, this.telemetryContext, versionReader: new AssemblyStreamVersionReader()); UpdatersController controller = new UpdatersController(work: unit, fileSaver: new Mock <IFileSaver>().Object , fileRetriever: new Mock <IFileRetriever>().Object); var request = new UpdateRequest(telemetryKey: this.TestProgramTelemetryKey, programVersion: new VersionData("0.0", ""), userId: this.User1Guid, acceptBeta: false, updaterVersion: "1.0" , toolkitVersion: "0.2.0"); UpdateResponse result = controller.UpdateCheck(request).GetAwaiter().GetResult(); Assert.AreEqual(expected: 0, actual: result.UpdatePackages.Count); request = new UpdateRequest(telemetryKey: this.TestProgramTelemetryKey, programVersion: new VersionData("0.0", ""), userId: this.User1Guid, acceptBeta: false, updaterVersion: "1.1.0" , toolkitVersion: "0.9.0"); result = controller.UpdateCheck(request).GetAwaiter().GetResult(); Assert.AreEqual(expected: "1.5.0", actual: result.UpdatePackages.Single().Version); }
public void Test_UpdaterChange() { ToolkitDataUnitOfWork unit = new ToolkitDataUnitOfWork(this.Context, this.telemetryContext, this.assemblyStreamVersionReader); UpdatersController controller = new UpdatersController(unit, new Mock <IFileSaver>().Object, new Mock <IFileRetriever>().Object); var request = new UpdateRequest(telemetryKey: this.ProgramWhichChangesUpdaterTelemetryKey, programVersion: new VersionData("0.0", ""), userId: this.User1Guid, acceptBeta: false , updaterVersion: "1.0", toolkitVersion: "1.3.0"); UpdateResponse result = controller.UpdateCheck(request).GetAwaiter().GetResult(); Assert.AreEqual("1.6.0", result.UpdatePackages.Single().Version); this.programWhichChangesUpdater.Updater = unit.UpdaterRepository.GetUpdater("UltraNewest").GetAwaiter().GetResult(); unit.CompleteAsync().GetAwaiter().GetResult(); request = new UpdateRequest(telemetryKey: this.ProgramWhichChangesUpdaterTelemetryKey, programVersion: new VersionData("0.0", ""), userId: this.User1Guid, acceptBeta: false , updaterVersion: "1.0", toolkitVersion: "1.3.0"); result = controller.UpdateCheck(request).GetAwaiter().GetResult(); Assert.AreEqual("9.8.5", result.UpdatePackages.Single().Version); }
public override async Task <UpdateReply> Update(UpdateRequest request, ServerCallContext context) { try { Comment c = await commentsService.UpdateAsync(new Comment { Id = request.Id, Subject = request.Subject, Body = request.Body }); return(new UpdateReply() { Id = c.Id, PhotoId = c.PhotoId, Subject = c.Subject, UserName = c.UserName, Body = c.Body, SubmittedOn = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(c.SubmittedOn.ToUniversalTime()) }); } catch (UnauthorizedEditAttemptException <Comment> ) { //found on https://docs.microsoft.com/en-us/dotnet/architecture/grpc-for-wcf-developers/error-handling var user = context.GetHttpContext().User; var metadata = new Metadata { { "User", user.Identity.Name } }; throw new RpcException(new Status(StatusCode.PermissionDenied, "Permission denied"), metadata); } }
public async Task <ActionResult> UpdateLibraryUser(int libraryId, int id, UpdateRequest model, CancellationToken cancellationToken) { if (!Account.IsSuperAdmin && !_userHelper.IsLibraryAdmin(libraryId) && id != Account.Id) { return(Unauthorized(new { message = "Unauthorized" })); } var command = new UpdateUserCommand { Email = model.Email, LibraryId = libraryId, Name = model.Name, Role = model.Role, }; await _commandProcessor.SendAsync(command, cancellationToken : cancellationToken); return(Ok(model)); }
private Guid UpdateExternalLogin(string userInitials, string abta, Guid bcId, string branchcode, string employeeId, string name, Entity extLogin) { extLogin[Attributes.ExternalLogin.Initials] = userInitials; extLogin[Attributes.ExternalLogin.AbtaNumber] = abta; extLogin[Attributes.ExternalLogin.BudgetCentreId] = new EntityReference(EntityName.Store, bcId); extLogin[Attributes.ExternalLogin.BranchCode] = branchcode; extLogin[Attributes.ExternalLogin.EmployeeId] = employeeId; extLogin[Attributes.ExternalLogin.Name] = name; var updateReq = new UpdateRequest() { Target = extLogin }; _crmService.ExecuteCrmOrganizationRequest(updateReq); return(extLogin.Id); }
public async Task <ActionResult <UserResponse> > Update(int id, [FromBody] UpdateRequest model) { // Users can update their own data and admins can update any user's data if (id != User.Id && User.Role != Role.Admin) { return(Unauthorized(new { message = "Unauthorized" })); } // Only admins can update role if (User.Role != Role.Admin) { model.Role = null; } var userToReturn = await _userService.Update(id, model); return(Ok(userToReturn)); }
/// <inheritdoc /> public async Task Rebuild(UpdateRequest request) { var rebuildRoutingTask = Task.CompletedTask; if (request.Routing) { rebuildRoutingTask = RebuildRouting(); } if (request.Highways) { await RebuildHighways(); } if (request.PointsOfInterest) { await RebuildPointsOfInterest(); } await rebuildRoutingTask; }
public void Execute(IJobExecutionContext context) { Console.WriteLine("CheckUpdateJob..."); UpdateRequest updateRequest = CheckUpdateHelper.GetUploadRequest(); if (updateRequest != null) { CheckUpdateHelper.ExecuteUpdate(updateRequest); } //测试 //UpdateRequest updateRequest = new UpdateRequest(); //updateRequest.Guid = Guid.NewGuid().ToString(); //updateRequest.Product = "JSOCT2016"; //updateRequest.RootPath = @"D:\Program Files (x86)\Jielink"; //updateRequest.PackagePath = @"D:\迅雷下载\JSOCT2016 V2.6.2 Jielink+智能终端操作平台安装包\obj\JSOCT2016-V2.6.2.zip"; //ExecuteUpdate(updateRequest); }
public ActionResult <AccountResponse> Update(string id, UpdateRequest model) { // users can update their own account and admins can update any account if (id != Account.Id.ToString() && Account.Role != Role.Admin) { return(Unauthorized(new { message = "Unauthorized" })); } // only admins can update role if (Account.Role != Role.Admin) { model.Role = null; } var account = _accountService.Update(id, model); return(Ok(new ApiOkResponse(account))); }
private async void CheckForUpdatesAsync(object state) { var bundleVersion = NSBundle.MainBundle.ObjectForInfoDictionary("CFBundleShortVersionString").ToString(); var request = new UpdateRequest() .WithNameAndVersionFromEntryAssembly() .WithVersion(bundleVersion) .AsAnonymousClient() .OnChannel("stable") .OnPlatform(new OperatingSystemIdentifier().WithSuffix("(Mac)")); var client = new WebSoupClient(); var updates = await client.CheckForUpdatesAsync(request); AvailableUpdate = updates.FirstOrDefault(); _updateTimer.Change((int)TimeSpan.FromHours(2).TotalMilliseconds, Timeout.Infinite); }
public async Task <IHttpActionResult> UpdateAccount([FromBody] UpdateRequest request) { try { var response = await _accountService.UpdateAccount(CurrentIdentity.UserId, request.Name, request.Email); if (response.Succeeded) { return(Ok(response.ResponseBody)); } return(BadRequest(response.ErrorMessage)); } catch (Exception e) { return(InternalServerError(e)); } }
public void MemberQueryApiVersionShouldHaveCorrectValue() { // Arrange var apiVersion = "1.0"; var route = new UpdateFromRoute(); var query = new UpdateFromQuery() { ApiVersion = apiVersion }; var header = new UpdateFromHeader(); var body = new UpdateFromBody(); // Act var obj = new UpdateRequest(route, query, header, body); // Assert obj.QueryApiVersion.Should().Be(apiVersion); }
public async Task <ActionResult <AccountResponse> > Update(int id, UpdateRequest model) { // users can update their own account and admins can update any account if (id != Account.Id && Account.Role != Role.Admin) { return(Unauthorized(new { message = "Unauthorized" })); } // only admins can update role if (Account.Role != Role.Admin) { model.Role = null; } var account = await _accountService.Update(id, model, Request.Headers["origin"]); return(Ok(account)); }
public void MemberRouteIdShouldHaveCorrectValue() { // Arrange var routeId = Guid.NewGuid().ToString(); var route = new UpdateFromRoute() { Id = routeId }; var query = new UpdateFromQuery(); var header = new UpdateFromHeader(); var body = new UpdateFromBody(); // Act var obj = new UpdateRequest(route, query, header, body); // Assert obj.RouteId.Should().Be(routeId); }
public void MemberBodyPatchShouldHaveCorrectValue() { // Arrange var patch = "json"; var route = new UpdateFromRoute(); var query = new UpdateFromQuery(); var header = new UpdateFromHeader(); var body = new UpdateFromBody() { Patch = patch }; // Act var obj = new UpdateRequest(route, query, header, body); // Assert obj.BodyPatch.Should().Be(patch); }
public async Task <IActionResult> UpdatePost(UpdateRequest request) { try { var game = await gameService.Update(request); logger.LogInformation($"Game {game.ID} created"); return(RedirectToAction("Home", new { gameID = game.ID })); } catch (Exception exception) { return(GetExceptionResult(exception, request)); } }
/// <summary> /// Preforms an Optimistic Update. If the entity's RowVersion doesn't match, the exception will be caught, and a reconciliation will be attempted before re-updating, indefinitely. /// Return null from reconcileEntity to skip cancel update /// Returns the entity whose Update Succeeded or null if the reconcileEntity function returned a null. /// </summary> /// <typeparam name="T">The entity type</typeparam> /// <param name="service">The service.</param> /// <param name="entity">The entity.</param> /// <param name="reconcileEntity">Function that accepts the latest version of the entity from the server as a property, and returns what the updated version should now be.</param> /// <param name="retrieveEntity">Function used to get the entity if the RowVersion doesn't match. Defaults to getting the entity with all columns returned.</param> /// <exception cref="Exception">No row version is set! Unable to preform OptimisticUpdate</exception> public static T OptimisticUpdate <T>(this IOrganizationService service, T entity, Func <T, T> reconcileEntity, Func <IOrganizationService, T> retrieveEntity = null) where T : Entity { if (string.IsNullOrWhiteSpace(entity.RowVersion)) { throw new Exception("No row version is set! Unable to preform OptimisticUpdate"); } var request = new UpdateRequest { ConcurrencyBehavior = ConcurrencyBehavior.IfRowVersionMatches, Target = entity }; entity = null; while (true) { try { service.Execute(request); return(entity); } catch (FaultException <OrganizationServiceFault> ex) { if (ex.Detail == null || ex.Detail.ErrorCode != CrmSdk.ErrorCodes.ConcurrencyVersionMismatch) { throw; } entity = retrieveEntity == null?service.GetEntity <T>(request.Target.Id) : retrieveEntity(service); request.Target = reconcileEntity(entity); if (request.Target == null) { // Reconciling code must have given up on reconciling return(null); } request.Target.RowVersion = entity.RowVersion; if (string.IsNullOrWhiteSpace(entity.RowVersion)) { throw new Exception("No row version is set! Unable to preform OptimisticUpdate"); } } } }
private void Repair(object parameter) { if (string.IsNullOrEmpty(this.SetUpPackagePath) || string.IsNullOrEmpty(this.InstallPath)) { MessageBoxHelper.MessageBoxShowWarning("请选择正确的路径!"); return; } DirectoryInfo packageDir = new DirectoryInfo(this.SetUpPackagePath); if (packageDir.Name.Equals("sys") || packageDir.Name.Equals("obj")) { packageDir = packageDir.Parent; } var zipPath = Directory.GetFiles(Path.Combine(packageDir.FullName, "obj"), "*.zip").FirstOrDefault(); if (string.IsNullOrEmpty(zipPath) || !zipPath.Contains("JSOCT"))//加上这个判断,防止选成盒子的包 { MessageBoxHelper.MessageBoxShowWarning("升级包不存在!"); return; } DirectoryInfo installDir = new DirectoryInfo(this.InstallPath); if (installDir.Name.Equals("SmartCenter", StringComparison.OrdinalIgnoreCase)) { installDir = installDir.Parent; } string rootPath = installDir.FullName; //检测是否是一个有效的中心按照目录 if (!File.Exists(Path.Combine(rootPath, "NewG3Uninstall.exe"))) { MessageBoxHelper.MessageBoxShowWarning("请选择正确的中心安装目录!"); return; } UpdateRequest updateRequest = new UpdateRequest(); updateRequest.Guid = Guid.NewGuid().ToString(); updateRequest.Product = "JSOCT2016"; updateRequest.RootPath = rootPath; updateRequest.PackagePath = zipPath; ExecuteUpdate(updateRequest); }
public Task<long> Index() { // var conn = Request.HttpContext.Connection; // var requestSource = conn.IsLocal // ? conn.LocalIpAddress.ToString() + ":" + conn.LocalPort.ToString() // : conn.RemoteIpAddress.ToString() + ":" + conn.RemotePort.ToString(); var updRequest = new UpdateRequest { StartTime = DateTime.UtcNow, Completion = new TaskCompletionSource<long>(), Request = Request, Source = "123" }; if (_updates.TryAdd(updRequest.Source, updRequest)) log.Info($"Update request from '{updRequest.Source}' added."); else Exceptions.ServerError("Update request from same remote addr/port already exists."); return updRequest.Completion.Task; }
private static void AddGeneratedValues(CampaignEmployeeUpdateRequestItem item, UpdateRequest updateRequest) { item.Status = GenerateStatusForUpdateRequest(updateRequest); if (updateRequest.CompletedDate.HasBeenSet()) { //item.ExtraClassForGoToStepButton = "disabled"; item.StepButtonBackgroundColor = "grey"; item.StepIcon = "checkmark"; item.StepIconColor = "green"; } else { item.StepButtonBackgroundColor = "primary"; item.StepIcon = "warning sign"; item.StepIconColor = "yellow"; } if (item.Step > updateRequest.ImportTask.NextRequiredStepForEmployee(updateRequest.Employee)) { item.ExtraClassForGoToStepButton = "disabled"; } }
public SingleItemResponse<UserDTO> RegisterUser(UpdateRequest<UserDTO> req) { if (req == null || req.Data == null) throw PizzaServiceFault.Create(Messages.NO_DATA); var user = req.Data; if (user.Password.Length == 0) { throw PizzaServiceFault.Create(PizzaServiceFault.PASSWORD_EMPTY); } if (!IsEmailValid(user.Email)) { throw PizzaServiceFault.Create(PizzaServiceFault.EMAIL_EMPTY); } if (user.Address.Length == 0) { throw PizzaServiceFault.Create(PizzaServiceFault.ADDRESS_EMPTY); } using (var db = new PizzaUnitOfWork()) { return db.inTransaction(uow => { if (uow.Db.Users.Find(user.Email) != null) throw PizzaServiceFault.Create(String.Format(PizzaServiceFault.EMAIL_ALREADY_REGISTERED_FORMAT, user.Email)); var ins = userAssembler.ToUser(user); ins.UserID = -1; uow.Db.Users.Insert(ins); uow.Db.Commit(); var res = SingleItemResponse.Create(userAssembler.ToSimpleDto(uow.Db.Users.Find(ins.Email))); res.Data.Password = req.Password; return res; }); } }
public override void Update(IRpcController controller, UpdateRequest request, Action<NoData> done) { ProtoOutputBuffer.Write(request.GetType(), request.ToString()); }
protected virtual UpdateRequest ConvertRequest(UpdateRequest request) { return request; }
private UpdateRequest GetRequest(ISerializationFormatter formatter, object obj, DataPortalContext context) { UpdateRequest request = new UpdateRequest(); request.ClientContext = formatter.Serialize(Csla.ApplicationContext.ClientContext); request.ClientCulture = System.Threading.Thread.CurrentThread.CurrentCulture.Name; request.ClientUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture.Name; request.GlobalContext = formatter.Serialize(Csla.ApplicationContext.GlobalContext); request.Principal = formatter.Serialize(Csla.ApplicationContext.User); request.ObjectData = formatter.Serialize(obj); request = ConvertRequest(request); return request; }
private void UpdateWebResource(OrganizationService orgService, WebResource choosenWebresource, string selectedFile) { choosenWebresource.Content = GetEncodedFileContents(selectedFile); var updateRequest = new UpdateRequest { Target = choosenWebresource }; orgService.Execute(updateRequest); }
protected void GenerateUpdateRequestsForAllSteps() { var session = importTask.Session; foreach (Employee employee in importTask.FilteredEmployeesToTarget(session)) { for (int step = 1; step <= importTask.ImportTaskConfiguration.Steps(); step++) { UpdateRequest newRequest = new UpdateRequest(session) { ImportTask = importTask, Step = step, Employee = employee }; newRequest.Save(); } } }
public SingleItemResponse<UserDTO> UpdateUser(UpdateRequest<UserDTO> request) { if (request.Data == null) throw PizzaServiceFault.Create(Messages.NO_DATA); using (var db = new PizzaUnitOfWork()) { return db.inTransaction(uow => { User user = uow.Db.Users.Find(request.Login); if (user == null) throw PizzaServiceFault.Create(String.Format(Messages.USER_NOT_EXISTS_FORMAT, request.Login)); if (user.UserID != request.Data.UserID || !PerformValidation(user, request)) throw PizzaServiceFault.Create(Messages.NO_PERMISSIONS); userAssembler.UpdateEntityUserLevel(user, request.Data); uow.Db.Commit(); var res = SingleItemResponse.Create(userAssembler.ToSimpleDto(uow.Db.Users.Get(request.Data.UserID))); res.Data.Password = request.Data.Password; return res; }); } }
public ListResponse<StockIngredientDTO> UpdateIngredient(UpdateRequest<List<StockIngredientDTO>> request) { if (request.Data == null) throw PizzaServiceFault.Create(Messages.NO_DATA); using (var db = new PizzaUnitOfWork()) { return db.inTransaction(uof => { if (!HasRights(GetUser(request).Data, 2)) throw PizzaServiceFault.Create(Messages.NO_PERMISSIONS); foreach (var stockItem in request.Data) { Ingredient ing = uof.Db.Ingredients.Get(stockItem.IngredientID); if (ing != null) ingAssembler.UpdateIngredient(ing, stockItem); else uof.Db.Ingredients.Insert(ingAssembler.ToEntityWithEmptyRecipies(stockItem)); } uof.Db.Commit(); return ListResponse.Create(uof.Db.Ingredients.FindAll().ToList() .Select(ingAssembler.ToSimpleDto) .ToList()); }); } }
public SingleItemResponse<OrderDTO> SetOrderState(UpdateRequest<OrderDTO> request) { using (var db = new PizzaUnitOfWork()) { return db.inTransaction(uof => { if (!HasRights(GetUser(request).Data, 2)) throw PizzaServiceFault.Create(Messages.NO_PERMISSIONS); Order o = uof.Db.Orders.Get(request.Data.OrderID); State st = uof.Db.States.Find(request.Data.State.StateValue); if (request.Data.State.StateValue == State.IN_REALISATION) { foreach (var orderDet in request.Data.OrderDetailsDTO) { foreach (var ingr in orderDet.Ingredients) { Ingredient ing = uof.Db.Ingredients.Get(ingr.IngredientID); if (ing == null) //this should never happen (when removing ingredient it is removed from all orders) throw PizzaServiceFault.Create(Messages.SERVER_INTERNAL_ERROR); if (ing.StockQuantity - ingr.Quantity < 0) { throw PizzaServiceFault.Create(Messages.NOT_ENOUGH_INGS_MSG); } ing.StockQuantity -= ingr.Quantity; } } } o.State = st; uof.Db.Commit(); return SingleItemResponse.Create(orderAssembler.ToSimpleDto(uof.Db.Orders.Get(o.OrderID))); }); } }
private void UpdateAndPublishSingle(CrmConnection connection, ProjectItem projectItem, Guid reportId) { try { _dte.StatusBar.Text = "Deploying report..."; _dte.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationDeploy); using (OrganizationService orgService = new OrganizationService(connection)) { Entity report = new Entity("report") { Id = reportId }; if (!File.Exists(projectItem.FileNames[1])) return; report["bodytext"] = File.ReadAllText(projectItem.FileNames[1]); UpdateRequest request = new UpdateRequest { Target = report }; orgService.Execute(request); _logger.WriteToOutputWindow("Deployed Report", Logger.MessageType.Info); } } catch (FaultException<OrganizationServiceFault> crmEx) { _logger.WriteToOutputWindow("Error Deploying Report To CRM: " + crmEx.Message + Environment.NewLine + crmEx.StackTrace, Logger.MessageType.Error); } catch (Exception ex) { _logger.WriteToOutputWindow("Error Deploying Report To CRM: " + ex.Message + Environment.NewLine + ex.StackTrace, Logger.MessageType.Error); } _dte.StatusBar.Clear(); _dte.StatusBar.Animate(false, vsStatusAnimation.vsStatusAnimationDeploy); }
public ListResponse<OrderSuppliesDTO> OrderSupplies(UpdateRequest<List<OrderSuppliesDTO>> request) { using (var db = new PizzaUnitOfWork()) { return db.inTransaction(uow => { if (!HasRights(GetUser(request).Data, 2)) throw PizzaServiceFault.Create(Messages.NO_PERMISSIONS); foreach (var os in request.Data) { Ingredient ing = uow.Db.Ingredients.Get(os.IngredientID); if (ing == null) throw PizzaServiceFault.Create(Messages.INGS_LIST_OUT_OF_DATE); ing.StockQuantity += os.OrderValue; } uow.Db.Commit(); return ListResponse.Create(uow.Db.Ingredients.FindAll().ToList().Select(ingAssembler.ToOrderSuppliesDTO).ToList()); }); } }
public void MakeOrder(UpdateRequest<OrderDTO> req) { using (var db = new PizzaUnitOfWork()) { db.inTransaction(uow => { UserDTO userDto = GetUser(req).Data; if (!HasRights(userDto, 1)) throw PizzaServiceFault.Create(Messages.NO_PERMISSIONS); User user = uow.Db.Users.Get(userDto.UserID); OrderDTO o = req.Data; State st = uow.Db.States.Find(State.NEW); List<OrderDetail> od = new List<OrderDetail>(); foreach (var ordDto in o.OrderDetailsDTO) { List<OrderIngredient> oIngs = new List<OrderIngredient>(); foreach (var oIng in ordDto.Ingredients) { oIngs.Add(new OrderIngredient { Ingredient = uow.Db.Ingredients.Get(oIng.IngredientID), Quantity = oIng.Quantity }); } od.Add(new OrderDetail { Size = uow.Db.Sizes.Get(ordDto.Size.SizeID), Ingredients = oIngs }); } Order order = new Order { Address = o.Address, CustomerPhone = o.CustomerPhone, Date = o.Date, User = user, State = st, UserID = user.UserID, OrderDetails = od }; uow.Db.Orders.Insert(order); uow.Db.Commit(); }); } }
//private List<OrderDetail> mergeIngredients(List<OrderDetailDTO> det, IEnumerable<OrderIngredientDTO> ing) //{ // foreach (var d in det) // foreach (var i in d.Ingredients) // { // Ingredient s = ing.FirstOrDefault((e) => { return e.IngredientID == i.Ingredient.IngredientID; }); // if (s == null) throw new Exception("Inconsistien data"); // i.Ingredient = s; // } // return det; //} //private List<OrderDetail> mergeSizes(List<OrderDetailDTO> det, IEnumerable<SizeDTO> sizes) //{ // foreach (var d in det) // { // d.Size = sizes.FirstOrDefault((e) => { return e.SizeValue == d.Size.SizeValue; }); // if (d.Size == null) throw new Exception("Inconsistien data"); // } // return det; //} public void InsertRecipe(UpdateRequest<RecipeDTO> req) { using (var db = new PizzaUnitOfWork()) { db.inTransaction(uow => { if (!HasRights(GetUser(req).Data, 2)) throw PizzaServiceFault.Create(Messages.NO_PERMISSIONS); Recipe r = new Recipe { Name = req.Data.Name }; List<Ingredient> ings = new List<Ingredient>(); foreach (var ingDto in req.Data.Ingredients) { ings.Add(db.Ingredients.Get(ingDto.IngredientID)); } r.Ingredients = ings; db.Recipies.Insert(r); uow.Db.Commit(); }); } }
PushResults ProcessQtyFiles() { var result = new PushResults(); var readyFiles = _readyDirectory.GetReadyFiles(FileTypes.Qty); if (!readyFiles.Any()) { _logger.Information("Found no {FileType} files to process.", FileTypes.Qty); } foreach (var readyfile in readyFiles) { var vendors = _fileHelpersCache.Get<VendorQtyEntry>() .ReadString(readyfile.ReadToEnd()) .GroupBy(x => x.VendorJdeId); //convert rows into a request to update //batch based foreach (var v in vendors) { var timeOfDay = _systemClock.Now(); var header = new UpdateQuantityHeader { EffectiveDate = timeOfDay, //TODO: Convert to supplier address number VendorJdeId = v.Key, //TODO: populate DocumentNumber = timeOfDay.Millisecond, //TODO: populate RecordSequence = timeOfDay.DayOfYear, //"164635" TimeOfDay = JdeDate.ToJdeTime(timeOfDay), }; var request = new UpdateRequest<UpdateQuantityHeader, VendorQtyEntry> { Header = header, Details = v.ToList() }; var r = _inventoryUpdater.Value.Update(request); result.AddMessages(r.Messages); } _archiveDirectory.ArchiveFile(readyfile); } return result; }