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;
}
