public async Task <IActionResult> TableAsync([FromBody] DataTablePart part)
{
ContentItem contentItem = await _contentManager.NewAsync("DatatableWidget");
// EXPLICIT syntax
DataTablePart testPart = contentItem.As <DataTablePart>();
testPart.JsonData = part.JsonData;
contentItem.Apply(testPart);
try
{
await _contentManager.CreateAsync(contentItem);
//do create here
//send contentitemid
ContentResult result = new ContentResult
{
ContentType = "application/json"
};
//result.Content = System.Text.Json.JsonSerializer.Serialize(new { result = contentItem.ContentItemId });
//result.StatusCode = 200;
//return result;
return(Ok(contentItem.ContentItemId));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.GetBaseException().Message));
}
}
public override async Task <IDisplayResult> UpdateAsync(ContentItem model, UpdateEditorContext context)
{
var viewModel = new LayerMetadataEditViewModel();
await context.Updater.TryUpdateModelAsync(viewModel, Prefix);
if (viewModel.LayerMetadata == null)
{
return(null);
}
if (String.IsNullOrEmpty(viewModel.LayerMetadata.Zone))
{
context.Updater.ModelState.AddModelError("LayerMetadata.Zone", S["Zone is missing"]);
}
if (context.Updater.ModelState.IsValid)
{
model.Apply(viewModel.LayerMetadata);
}
model.DisplayText = viewModel.Title;
return(await EditAsync(model, context));
}
public async Task <ContentItem> AssignGroupAsync(ContentItem profile, string groupContentItemId)
{
if (profile == null)
{
return(null);
}
using (var scope = await _shellHost.GetScopeAsync(_shellSettings))
{
var contentManager = scope.ServiceProvider.GetRequiredService <IContentManager>();
profile.Alter <ProfileGroupedPart>(x => x.GroupContentItemId = groupContentItemId);
profile.Apply(nameof(ProfileGroupedPart), profile.As <ProfileGroupedPart>());
ContentExtensions.Apply(profile, profile);
await contentManager.UpdateAsync(profile);
await contentManager.PublishAsync(profile);
await _session.CommitAsync();
return(profile);
}
}
public dynamic TakeSnapshot(ContentItem contentItem)
{
// var part = contentItem.As<TicketPart>();
//var part = contentItem.As<WorkBookPart>();
if (contentItem == null)
{
return(null);
}
ContentItem oldData = new ContentItem();
oldData.ContentType = contentItem.ContentType;
oldData.Author = contentItem.Author;
var testPart = contentItem.As <ContentPart>();
oldData.Apply(testPart);
// TicketPartRecord oldData = new TicketPartRecord();
// oldData.StatusRecord = part.Record.StatusRecord;
// oldData.TicketType = part.Record.TicketType;
// oldData.Title = part.Record.Title;
// oldData.Description = part.Record.Description;
// oldData.DueDate = part.Record.DueDate;
// oldData.PriorityRecord = part.Record.PriorityRecord;
// oldData.Service = part.Record.Service;
// WorkBookPart oldData = new WorkBookPart();
// oldData.prop = part.prop;
return(oldData);
}
public async Task UpdateUserIdentifier(ContentItem contentItem, IUser user)
{
var profilePart = contentItem.Get <ProfilePart>("ProfilePart");
profilePart.UserIdentifier = await _userManager.GetUserIdAsync(user);
contentItem.Apply("ProfilePart", profilePart);
ContentExtensions.Apply(contentItem, contentItem);
await _contentManager.UpdateAsync(contentItem);
}
public override async Task <IDisplayResult> UpdateAsync(ContentItem model, UpdateEditorContext context)
{
var layerMetadata = new LayerMetadata();
if (!await context.Updater.TryUpdateModelAsync(layerMetadata, "LayerMetadata", m => m.Zone, m => m.Position, m => m.RenderTitle, m => m.Title, m => m.Layer) ||
String.IsNullOrEmpty(layerMetadata.Zone))
{
return(null);
}
model.Apply(layerMetadata);
return(await EditAsync(model, context));
}
public static void SetLeverPostingPart(this ContentItem contentItem, Posting posting)
{
var part = contentItem.As <LeverPostingPart>();
if (part == null)
{
return;
}
part.LeverId = posting.Id;
part.Data = JsonConvert.SerializeObject(posting);
part.Apply();
contentItem.Apply(nameof(LeverPostingPart), part);
}
private async Task RegisterUserVote(ClaimsPrincipal user, ContentItem contentItem, int rating)
{
var currentVote = await GetUserVote(user, contentItem);
//also update in content item part so part driver does not require extra queiry
var voteUpDownPart = contentItem.As <VotingPart>();
if (currentVote != null && (currentVote.Value + rating == 0))
{
voteUpDownPart.UserVote = rating;
await _votingStore.DeleteAsync(currentVote);
// _votingService.RemoveVote(currentVote);
}
else
{
if (currentVote != null)
{
voteUpDownPart.UserVote = rating;
await _votingStore.ChangeVoteAsync(currentVote, rating);
}
else
{
//add new vote
var vote = new VoteItem()
{
User = User.Identity.Name,
CorrelationId = contentItem?.ContentItemId,
Value = rating,
Dimension = Constants.DimensionRating,
CreatedUtc = _clock.UtcNow,
Hostname = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress.ToString()
};
await _votingStore.SaveAsync(vote);
voteUpDownPart.UserVote = rating;
}
}
contentItem.Apply(voteUpDownPart);
_session.Save(contentItem);
}
public void GetReflectsChangesMadeByApply()
{
// arrange
var value = "changed value";
var contentItem = new ContentItem();
contentItem.Weld <CustomPart>();
var part = new CustomPart {
Value = value
};
// act
contentItem.Apply(nameof(CustomPart), part);
// assert
var actual = contentItem.Get <CustomPart>(nameof(CustomPart));
Assert.Equal(actual.Value, value);
}
public async Task <IActionResult> FormTableAsync(string jsonData)
{
ContentItem contentItem = await _contentManager.NewAsync("DatatableWidget");
// EXPLICIT syntax
DataTablePart testPart = contentItem.As <DataTablePart>();
testPart.JsonData = jsonData;
contentItem.Apply(testPart);
await _contentManager.CreateAsync(contentItem);
//do create here
//send contentitemid
return(RedirectToAction("Display",
"Home",
new
{
area = "DynamicViewModule",
contentItemId = contentItem.ContentItemId
}));
}
public override async Task <IDisplayResult> UpdateAsync(ContentItem contentItem, IUpdateModel updater)
{
var testContentPart = contentItem.As <TestContentPartA>();
if (testContentPart == null)
{
return(null);
}
if (await updater.TryUpdateModelAsync(testContentPart, ""))
{
if (testContentPart.Line.EndsWith(" "))
{
updater.ModelState.AddModelError(nameof(testContentPart.Line), "Value cannot end with a space");
}
else
{
contentItem.Apply(testContentPart);
}
}
return(Copy("TestContentPartA_Edit", testContentPart).Location("Content"));
}
private async Task <bool> ImportRowAsync(ImportRedirectRow row)
{
if (!ValidateRow(row))
{
return(false);
}
var existing = await _session.Query <ContentItem>()
.With <RedirectPartIndex>(x => x.Url == row.FromUrl)
.ListAsync();
ContentItem redirectItem = null;
var newItem = false;
if (existing.Any())
{
redirectItem = existing.FirstOrDefault(x => x.Published);
}
if (redirectItem == null)
{
redirectItem = await _contentManager.NewAsync(Constants.RedirectContentType);
redirectItem.Owner = _httpContextAccessor.HttpContext.User.Identity.Name;
redirectItem.CreatedUtc = DateTime.UtcNow;
newItem = true;
}
if (redirectItem == null)
{
return(false);
}
var redirectPart = redirectItem.Get <RedirectPart>(nameof(RedirectPart));
if (redirectPart == null)
{
return(false);
}
redirectItem.Author = _httpContextAccessor.HttpContext.User.Identity.Name;
redirectItem.DisplayText = row.Title;
redirectPart.FromUrl = row.FromUrl?.Trim();
redirectPart.ToUrl = row.ToUrl?.Trim();
redirectPart.IsPermanent = true;
redirectPart.Apply();
redirectItem.Apply(nameof(RedirectPart), redirectPart);
ContentExtensions.Apply(redirectItem, redirectItem);
if (newItem)
{
await _contentManager.CreateAsync(redirectItem);
}
else
{
await _contentManager.UpdateAsync(redirectItem);
}
await _contentManager.PublishAsync(redirectItem);
return(true);
}
