public override SyncAttempt <IMediaType> DeserializeSecondPass(IMediaType item, XElement node, SerializerFlags flags)
{
DeserializeCompositions(item, node);
DeserializeStructure(item, node);
if (!flags.HasFlag(SerializerFlags.DoNotSave) && item.IsDirty())
{
mediaTypeService.Save(item);
}
return(SyncAttempt <IMediaType> .Succeed(item.Name, item, ChangeType.Import));
}
public override SyncAttempt <IMediaType> DeserializeSecondPass(IMediaType item, XElement node, SyncSerializerOptions options)
{
var details = new List <uSyncChange>();
details.AddRange(DeserializeCompositions(item, node));
details.AddRange(DeserializeStructure(item, node));
if (!options.Flags.HasFlag(SerializerFlags.DoNotSave) && item.IsDirty())
{
mediaTypeService.Save(item);
}
return(SyncAttempt <IMediaType> .Succeed(item.Name, item, ChangeType.Import, details));
}
public async Task GetUrlsByIds_MediaWithIntegerIds_ReturnsValidMap()
{
IMediaTypeService mediaTypeService = Services.GetRequiredService <IMediaTypeService>();
IMediaService mediaService = Services.GetRequiredService <IMediaService>();
var mediaItems = new List <Media>();
using (ScopeProvider.CreateScope(autoComplete: true))
{
IMediaType mediaType = mediaTypeService.Get("image");
mediaTypeService.Save(mediaType);
mediaItems.Add(MediaBuilder.CreateMediaImage(mediaType, -1));
mediaItems.Add(MediaBuilder.CreateMediaImage(mediaType, -1));
foreach (Media media in mediaItems)
{
mediaService.Save(media);
}
}
var queryParameters = new Dictionary <string, object>
{
["type"] = Constants.UdiEntityType.Media
};
var url = LinkGenerator.GetUmbracoControllerUrl("GetUrlsByIds", typeof(EntityController), queryParameters);
var payload = new
{
ids = new[]
{
mediaItems[0].Id,
mediaItems[1].Id,
}
};
HttpResponseMessage response = await HttpClientJsonExtensions.PostAsJsonAsync(Client, url, payload);
// skip pointless un-parseable cruft.
(await response.Content.ReadAsStreamAsync()).Seek(AngularJsonMediaTypeFormatter.XsrfPrefix.Length, SeekOrigin.Begin);
IDictionary <int, string> results = await response.Content.ReadFromJsonAsync <IDictionary <int, string> >();
Assert.Multiple(() =>
{
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsTrue(results ![payload.ids[0]].StartsWith("/media"));
Assert.IsTrue(results ![payload.ids[1]].StartsWith("/media"));
public ActionResult <MediaTypeDisplay> PostSave(MediaTypeSave contentTypeSave)
{
var savedCt = PerformPostSave <MediaTypeDisplay, MediaTypeSave, PropertyTypeBasic>(
contentTypeSave,
i => _mediaTypeService.Get(i),
type => _mediaTypeService.Save(type));
if (!(savedCt.Result is null))
{
return(savedCt.Result);
}
var display = _umbracoMapper.Map <MediaTypeDisplay>(savedCt.Value);
display.AddSuccessNotification(
_localizedTextService.Localize("speechBubbles", "mediaTypeSavedHeader"),
string.Empty);
return(display);
}
public override SyncAttempt <IMediaType> DeserializeSecondPass(IMediaType item, XElement node, SyncSerializerOptions options)
{
var details = new List <uSyncChange>();
details.AddRange(DeserializeCompositions(item, node));
details.AddRange(DeserializeStructure(item, node));
SetSafeAliasValue(item, node, false);
CleanTabAliases(item);
CleanTabs(item, node, options);
bool saveInSerializer = !options.Flags.HasFlag(SerializerFlags.DoNotSave);
if (saveInSerializer && item.IsDirty())
{
mediaTypeService.Save(item);
}
return(SyncAttempt <IMediaType> .Succeed(item.Name, item, ChangeType.Import, "", saveInSerializer, details));
}
public void Get_Paged_Mixed_Entities_By_Ids()
{
// Create content
IContentService contentService = GetRequiredService <IContentService>();
IContentTypeService contentTypeService = GetRequiredService <IContentTypeService>();
var createdContent = new List <IContent>();
ContentType contentType = ContentTypeBuilder.CreateBasicContentType("blah");
contentTypeService.Save(contentType);
for (int i = 0; i < 10; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
contentService.Save(c1);
createdContent.Add(c1);
}
// Create media
IMediaService mediaService = GetRequiredService <IMediaService>();
IMediaTypeService mediaTypeService = GetRequiredService <IMediaTypeService>();
var createdMedia = new List <IMedia>();
MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage");
mediaTypeService.Save(imageType);
for (int i = 0; i < 10; i++)
{
Media c1 = MediaBuilder.CreateMediaImage(imageType, -1);
mediaService.Save(c1);
createdMedia.Add(c1);
}
// Create members
IMemberService memberService = GetRequiredService <IMemberService>();
IMemberTypeService memberTypeService = GetRequiredService <IMemberTypeService>();
MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("simple");
memberTypeService.Save(memberType);
var createdMembers = MemberBuilder.CreateMultipleSimpleMembers(memberType, 10).ToList();
memberService.Save(createdMembers);
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
EntityRepository repo = CreateRepository((IScopeAccessor)provider);
IEnumerable <int> ids = createdContent.Select(x => x.Id).Concat(createdMedia.Select(x => x.Id)).Concat(createdMembers.Select(x => x.Id));
System.Guid[] objectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member };
IQuery <IUmbracoEntity> query = provider.CreateQuery <IUmbracoEntity>()
.WhereIn(e => e.Id, ids);
var entities = repo.GetPagedResultsByQuery(query, objectTypes, 0, 20, out long totalRecords, null, null).ToList();
Assert.AreEqual(20, entities.Count);
Assert.AreEqual(30, totalRecords);
// add the next page
entities.AddRange(repo.GetPagedResultsByQuery(query, objectTypes, 1, 20, out totalRecords, null, null));
Assert.AreEqual(30, entities.Count);
Assert.AreEqual(30, totalRecords);
var contentEntities = entities.OfType <IDocumentEntitySlim>().ToList();
var mediaEntities = entities.OfType <IMediaEntitySlim>().ToList();
var memberEntities = entities.OfType <IMemberEntitySlim>().ToList();
Assert.AreEqual(10, contentEntities.Count);
Assert.AreEqual(10, mediaEntities.Count);
Assert.AreEqual(10, memberEntities.Count);
}
}
