protected internal async override Task <bool> RemoveAsync(PublishedItem publishedItem)
{
var id = ParseId(publishedItem);
if (id == null)
{
return(false);
}
id = (long)id;
switch (publishedItem.Type)
{
case ExportType.MarketItem:
return(await Api.Markets.DeleteAsync(-GroupId, (long)id));
case ExportType.PhotoAlbum:
return(await Api.Photo.DeleteAlbumAsync((long)id, GroupId));
case ExportType.Post:
return(await Api.Wall.DeleteAsync(-GroupId, (long)id));
default:
throw new ArgumentException($"The type {publishedItem.Type} not supported in VKPublisher");
}
}
public void UmbracoPickerProcessesMappedContent()
{
PublishedItem result = this.support.Content.MapTo <PublishedItem>();
Assert.NotNull(result);
Assert.IsAssignableFrom <PublishedItem>(result.Child);
}
public void UmbracoPickerProcessesIPublishedContent()
{
PublishedItem result = this.support.Content.MapTo <PublishedItem>();
Assert.NotNull(result);
Assert.IsAssignableFrom <IPublishedContent>(result.PublishedInterfaceContent);
}
public void MapperReturnsImageCropDataSet()
{
PublishedItem result = this.support.Content.MapTo <PublishedItem>();
Assert.NotNull(result);
Assert.NotNull(result.Image);
Assert.Equal(this.support.Content.GetPropertyValue(nameof(PublishedItem.Image)), result.Image);
}
public ActionResult DeleteConfirmed(int id)
{
PublishedItem publishedItem = db.PublishedItems.Find(id);
db.PublishedItems.Remove(publishedItem);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private long?ParseId(PublishedItem publishedItem)
{
if (long.TryParse(publishedItem.Identifier, out long result))
{
return(result);
}
return(null);
}
public void MapperCanMapRelatedLinks()
{
MockPublishedContent content = this.support.Content;
PublishedItem result = content.MapTo <PublishedItem>();
Assert.NotNull(result.RelatedLink);
Assert.NotNull(result.RelatedLinks);
Assert.True(result.RelatedLinks.GetType().IsEnumerableOfType(typeof(RelatedLink)));
}
public FastPropertyAccessorTests()
{
this.item = new PublishedItem
{
Id = 1234,
Name = "Foo",
CreateDate = DateTime.MaxValue
};
this.accessor = new FastPropertyAccessor(typeof(PublishedItem));
}
public ActionResult Edit([Bind(Include = "Id,UserId,ItemId,Price,Discount")] PublishedItem publishedItem)
{
if (ModelState.IsValid)
{
db.Entry(publishedItem).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ItemId = new SelectList(db.Items, "Id", "ItemName", publishedItem.ItemId);
ViewBag.UserId = new SelectList(db.ServiceProviders, "Id", "Username", publishedItem.UserId);
return(View(publishedItem));
}
public void MapperCanMapBaseAlternativeProperties()
{
var created = new DateTime(2017, 1, 1);
MockPublishedContent content = this.support.Content;
content.CreateDate = created;
PublishedItem result = content.MapTo <PublishedItem>();
Assert.Equal(created, result.CreateDate);
Assert.Equal(created, result.UpdateDate);
}
// GET: PublishedItems/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PublishedItem publishedItem = db.PublishedItems.Find(id);
if (publishedItem == null)
{
return(HttpNotFound());
}
return(View(publishedItem));
}
protected override async Task <IList <PublishedItem> > PublishAsync(IEnumerable <VKExportItem> exportItems)
{
var market = GetSingleOfType(ExportType.MarketItem);
var album = GetSingleOfType(ExportType.PhotoAlbum);
var wallPost = GetSingleOfType(ExportType.Post);
PublishedItem publishedAlbum = null;
if (album != null)
{
var albumId = await CreateAlbumAsync(album.Title, album.Description);
publishedAlbum = CreatePublishedItem(album, albumId);
MarkLinksAsNotNull(publishedAlbum);
}
PublishedItem publishedMarketItem = null;
if (market != null)
{
publishedMarketItem = await AddMarketItemAsync(market);
MarkLinksAsNotNull(publishedMarketItem);
}
// Load photos in album now, because it may have been linked with market item.
if (album != null)
{
publishedAlbum = await AddAlbumAsync(album, publishedAlbum);
}
PublishedItem publishedWallPost = null;
if (wallPost != null)
{
publishedWallPost = await WallPostAsync(wallPost);
}
VKExportItem GetSingleOfType(ExportType type) => exportItems.SingleOrDefault(item => item.ExportType == type);
return(new[] { publishedWallPost, publishedMarketItem, publishedAlbum }.Where(pi => pi != null).ToArray());
void MarkLinksAsNotNull(PublishedItem published)
{
exportItems.SelectMany(ei => ei.Attachments.Where(a => a.ExportType == published.Type && a.IsNull))
.ToList()
.ForEach(i => i.PublishedItem = published);
}
}
public async Task <bool> RemoveAsync(PublishedItem publishedItem)
{
var published = (publishedItem as DbPublishedItem) ??
(await context?.PublishedItems
.Where(pi => pi.SubjectId == publishedItem.SubjectId)
.ToArrayAsync())
.SingleOrDefault(db => db.Equals(publishedItem));
if (published != null)
{
context.PublishedItems.Remove(published);
}
return(published != null);
}
public void MapperReturnsCorrectEnumFromString()
{
const PlaceOrder placeOrder = PlaceOrder.Fourth;
MockPublishedContent content = this.support.Content;
content.Properties = new List <IPublishedProperty>
{
new MockPublishedContentProperty(nameof(PublishedItem.PlaceOrder), placeOrder.ToString())
};
PublishedItem result = content.MapTo <PublishedItem>();
Assert.Equal(placeOrder, result.PlaceOrder);
}
public void MapperReturnsDefaultEnum()
{
const PlaceOrder placeOrder = PlaceOrder.Fourth;
MockPublishedContent content = this.support.Content;
content.Properties = new List <IPublishedProperty>
{
new MockPublishedContentProperty(nameof(PublishedItem.PlaceOrder), null)
};
PublishedItem result = content.MapTo <PublishedItem>();
Assert.NotEqual(placeOrder, result.PlaceOrder);
Assert.Equal(default(PlaceOrder), result.PlaceOrder);
}
// GET: PublishedItems/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PublishedItem publishedItem = db.PublishedItems.Find(id);
if (publishedItem == null)
{
return(HttpNotFound());
}
ViewBag.ItemId = new SelectList(db.Items, "Id", "ItemName", publishedItem.ItemId);
ViewBag.UserId = new SelectList(db.ServiceProviders, "Id", "Username", publishedItem.UserId);
return(View(publishedItem));
}
protected override async Task <PublishedItem> PublishAsync(InstaExportItem exportItem)
{
HandleImages(exportItem);
var carouselImages = new List <System.Drawing.Image> {
exportItem.Cover
};
carouselImages.AddRange(exportItem.Photos
.Skip(1)
.Take(CarouselPhotosCount - 1));
try
{
var album = carouselImages.Select(photo =>
{
return(new InstaImage
{
Height = 0,
Width = 0,
URI = ImageToUrlConverter.Convert(photo)
});
})
.Distinct()
.ToArray();
var result = await InstaApi.UploadPhotosAlbumAsync(album, exportItem.Description, exportItem.Location.InstaLocation);
if (!result.Succeeded)
{
throw new Exception(result.Info.Message);
}
var postUrl = CreatePostUrlByUrlSegment(result.Value.Code);
var publishedItem = new PublishedItem(exportItem.Subject.SubjectId, exportItem.ExportType, result.Value.Pk, postUrl);
OnItemPublished(publishedItem);
return(publishedItem);
}
finally
{
ImageToUrlConverter.DoAfterImagesLoaded();
}
}
public void MapperCanMapBaseProperties()
{
const int id = 999;
const string name = "Foo";
var created = new DateTime(2017, 1, 1);
MockPublishedContent content = this.support.Content;
content.Id = id;
content.Name = name;
content.CreateDate = created;
PublishedItem result = content.MapTo <PublishedItem>();
Assert.Equal(id, result.Id);
Assert.Equal(name, result.Name);
Assert.Equal(created, result.CreateDate);
}
public void MapperReturnsDefaultProperties()
{
const int id = default(int);
const string name = default(string);
var created = default(DateTime);
var updated = default(DateTime);
MockPublishedContent content = this.support.Content;
content.Id = id;
content.Name = name;
content.CreateDate = created;
PublishedItem result = content.MapTo <PublishedItem>();
Assert.Equal(id, result.Id);
Assert.Equal(name, result.Name);
Assert.Equal(created, result.CreateDate);
Assert.Equal(updated, result.UpdateDate);
}
public ActionResult Create(PublishedItem publishedItem)
{
if (ModelState.IsValid)
{
db.PublishedItems.Add(publishedItem);
try
{
db.SaveChanges();
}
catch (SqlException e)
{
throw e;
}
return(RedirectToAction("Index"));
}
ViewBag.ItemId = new SelectList(db.Items, "Id", "ItemName", publishedItem.ItemId);
ViewBag.UserId = new SelectList(db.ServiceProviders, "Id", "Username", publishedItem.UserId);
return(View(publishedItem));
}
public Attachment(ExportType exportType, AttachmentType attachmentType, PublishedItem publishedItem)
: this(exportType, attachmentType) => PublishedItem = publishedItem;
protected override Task <bool> RemoveAsync(PublishedItem publishedItem)
{
Debug.WriteLine("RemoveAsync");
return(new Task <bool>(() => false));
}
protected virtual async Task <PublishedItem> AddAlbumAsync(VKExportItem exportItem, PublishedItem publishedAlbum = null)
{
exportItem.Description += GetAttachmentsLinks(exportItem);
long?albumId = ParseId(publishedAlbum);
if (albumId == null)
{
albumId = await CreateAlbumAsync(exportItem.Title, exportItem.Description);
}
else
{
await EditAlbumAsync((ulong)albumId, exportItem.Title, exportItem.Description);
}
HandleImages(exportItem);
var uploadServer = await Api.Photo.GetUploadServerAsync((long)albumId, GroupId);
// Main album photo will be uploaded last.
var responses = await UploadImagesAsync(uploadServer.UploadUrl, exportItem.Photos.Concat(new[] { exportItem.Cover }), UploadPhotosLimit);
Photo mainPhoto = null;
exportItem.Caption += GetAttachmentsLinks(exportItem);
foreach (var response in responses)
{
var uploadedPhotos = await Api.Photo.SaveAsync(new PhotoSaveParams()
{
AlbumId = albumId,
GroupId = GroupId,
Caption = exportItem.Caption,
SaveFileResponse = response
});
if (response == responses.Last())
{
mainPhoto = uploadedPhotos.LastOrDefault();
}
}
if (mainPhoto != null)
{
await Api.Photo.MakeCoverAsync((ulong)mainPhoto.Id, -GroupId, albumId);
}
return(RiseItemPublishedEvent(exportItem, (long)albumId));
}
protected internal override async Task <bool> RemoveAsync(PublishedItem publishedItem)
{
var result = await InstaApi.DeleteMediaAsync(publishedItem.Identifier, InstaMediaType.Carousel);
return(result.Succeeded);
}
public PublishedItemInfo(PublishedItem publishedItem, PublisherInfo publisherData)
{
PublishedItem = publishedItem;
PublisherData = publisherData;
}
public void Add(PublishedItem publishedItem)
{
context.PublishedItems.Add(new DbPublishedItem(publishedItem));
}
private void Exporter_ItemPublished(object sender, PublishedItem e) => view.MarkAsPublished(new PublishedItemInfo(e, publishersInfo[e.Publisher]));
