private void ProcessPages(string exhibitId, CancellationToken token, ITransactionDataAccess dataAccess,
Dictionary <MediaDto, string> mediaToFilePath)
{
var fetchedMedia = mediaDataFetcher.CombineMediasAndFiles(dataAccess, mediaToFilePath);
if (token.IsCancellationRequested)
{
return;
}
var exhibit = dataAccess.Exhibits().GetExhibit(exhibitId);
foreach (var pageDto in pageItems)
{
var dbPage = PageConverter.Convert(pageDto);
AddContentToPage(dbPage, pageDto, fetchedMedia);
// Add Page with content to the exhibit
exhibit.Pages.Add(dbPage);
}
// Rearrange additional information pages
var pagesToBeRemoved = new List <Page>();
foreach (var pageDto in pageItems)
{
if (pageDto.AdditionalInformationPages.Count > 0)
{
foreach (var existingPageWithInfo in exhibit.Pages)
{
if (pageDto.Id == existingPageWithInfo.IdForRestApi)
{
foreach (var pageId in pageDto.AdditionalInformationPages)
{
foreach (var pageToBeAdded in exhibit.Pages)
{
if (pageToBeAdded.IdForRestApi == pageId)
{
existingPageWithInfo.AdditionalInformationPages.Add(pageToBeAdded);
pagesToBeRemoved.Add(pageToBeAdded);
break;
}
}
}
}
}
}
}
foreach (var pageToBeRemoved in pagesToBeRemoved)
{
exhibit.Pages.Remove(pageToBeRemoved);
}
exhibit.DetailsDataLoaded = true;
}
private void ProcessRoute(CancellationToken token, ITransactionDataAccess dataAccess, Dictionary <MediaDto, string> mediaToFilePath)
{
var fetchedMedia = mediaDataFetcher.CombineMediasAndFiles(dataAccess, mediaToFilePath);
if (token.IsCancellationRequested)
{
return;
}
AddAudioToRoute(route, routeDto.Audio, fetchedMedia);
}
private void ProcessNewRoutes(IProgressListener listener, ITransactionDataAccess dataAccess)
{
foreach (var routeDto in newRoutes)
{
var dbRoute = RouteConverter.Convert(routeDto);
AddImageToRoute(dbRoute, routeDto.Image, fetchedMedia);
AddTagsToRoute(dbRoute, routeDto, fetchedMedia);
AddExhibitsToRoute(dbRoute, routeDto, dataAccess);
dataAccess.Routes().AddRoute(dbRoute);
listener.ProgressOneStep();
}
}
private void ProcessUpdatedRoutes(IProgressListener listener, ITransactionDataAccess dataAccess)
{
var routes = dataAccess.Routes().GetRoutes().ToList();
foreach (var routeDto in updatedRoutes)
{
var dbRoute = routes.First(x => x.IdForRestApi == routeDto.Id);
RouteConverter.Convert(routeDto, dbRoute);
AddImageToRoute(dbRoute, routeDto.Image, fetchedMedia);
AddTagsToRoute(dbRoute, routeDto, fetchedMedia);
AddExhibitsToRoute(dbRoute, routeDto, dataAccess);
if (dbRoute.DetailsDataLoaded)
{
IoCManager.Resolve <INewDataCenter>().AddRouteToBeUpdated(dbRoute);
}
listener.ProgressOneStep();
}
}
public FetchedMediaData CombineMediasAndFiles(ITransactionDataAccess dataAccess, Dictionary <MediaDto, string> mediaToFilePath)
{
var fetchedData = new FetchedMediaData
{
Audios = new List <Audio>(),
Images = new List <Image>()
};
if (fetchedMedias == null)
{
return(fetchedData);
}
foreach (var mediaDto in fetchedMedias)
{
var isAudio =
mediaDto.Type == MediaTypeDto.Audio ? true :
mediaDto.Type == MediaTypeDto.Image ? false :
throw new ArgumentOutOfRangeException("Unsupported media type");
var dbMedia = isAudio
? audioConverter.ConvertReplacingExisting(mediaDto, mediaDto.Id.ToString(), dataAccess)
: imageConverter.ConvertReplacingExisting(mediaDto, mediaDto.Id.ToString(), dataAccess) as Media;
dbMedia.DataPath = mediaToFilePath.TryGetValueOrDefault(mediaDto) ??
throw new NullReferenceException($"No file path for image {mediaDto.Id}");
if (isAudio)
{
fetchedData.Audios.Add((Audio)dbMedia);
}
else
{
fetchedData.Images.Add((Image)dbMedia);
}
}
return(fetchedData);
}
private void AddExhibitsToRoute(Route dbRoute, RouteDto routeDto, ITransactionDataAccess dataAccess)
{
var exhibits = dataAccess.Exhibits().GetExhibits().ToList();
if (routeDto.Exhibits.Count > 0)
{
foreach (var exhibitId in routeDto.Exhibits)
{
var dbExhibit = exhibits.SingleOrDefault(x => x.IdForRestApi == exhibitId);
if (dbExhibit != null)
{
var waypoint = new Waypoint
{
Exhibit = dbExhibit,
Location = dbExhibit.Location
};
dbRoute.Waypoints.Add(waypoint);
}
}
var removedWaypoints = dbRoute.Waypoints.Where(x => !routeDto.Exhibits.Contains(x.Exhibit.IdForRestApi));
foreach (var waypoint in removedWaypoints)
{
dbRoute.Waypoints.Remove(waypoint);
}
dbRoute.DetailsDataLoaded = false;
}
else
{
// Hide downloadbutton since there is nothing to download
dbRoute.DetailsDataLoaded = true;
}
}
private void ProcessNewExhibits(IProgressListener listener, FetchedMediaData fetchedMedia, ITransactionDataAccess dataAccess)
{
foreach (var exhibitDto in newExhibits)
{
var dbExhibit = ExhibitConverter.Convert(exhibitDto);
AddImageToExhibit(dbExhibit, exhibitDto.Image, fetchedMedia);
dataAccess.Exhibits().AddExhibit(dbExhibit);
listener.ProgressOneStep();
}
}
private void ProcessUpdatedExhibits(IProgressListener listener, FetchedMediaData fetchedMedia, ITransactionDataAccess dataAccess)
{
var exhibits = dataAccess.Exhibits().GetExhibits().ToDictionary(x => x.IdForRestApi);
foreach (var exhibitDto in updatedExhibits)
{
var dbExhibit = exhibits[exhibitDto.Id];
ExhibitConverter.Convert(exhibitDto, dbExhibit);
AddImageToExhibit(dbExhibit, exhibitDto.Image, fetchedMedia);
//TODO: Check if exhibit was already downloaded
//if(dbExhibit.DetailsDataLoaded)
//{
// IoCManager.Resolve<INewDataCenter>().AddExhibitToBeUpdated(dbExhibit);
//}
var removedPages = dbExhibit.Pages.Where(x => !exhibitDto.Pages.Contains(x.IdForRestApi));
foreach (var page in removedPages)
{
dbExhibit.Pages.Remove(page);
}
listener.ProgressOneStep();
}
}
public void CleanupRemovedData(ITransactionDataAccess dataAccess)
{
//Backup data fake id
allMedias.Add(-1);
var routes = dataAccess.Routes().GetRoutes().ToList();
var exhibits = dataAccess.Exhibits().GetExhibits().ToList();
var deletedExhibits = exhibits.Where(x => !allExhibits.Contains(x.IdForRestApi)).ToList();
var deletedRoutes = routes.Where(x => !allRoutes.Contains(x.IdForRestApi));
var deletedWaypoints = new List <Waypoint>();
var deletedTags = new List <RouteTag>();
var deletedImages = new List <Image>();
var deletedAudios = new List <Audio>();
var deletedPages = new List <Page>();
foreach (var route in routes)
{
RemoveWaypoints(route, deletedWaypoints, deletedExhibits);
RemoveRouteTags(route, deletedTags, deletedImages);
if (route.Image != null && !allMedias.Contains(route.Image.IdForRestApi))
{
deletedImages.Add(route.Image);
route.Image = null;
}
if (route.Audio != null && !allMedias.Contains(route.Audio.IdForRestApi))
{
deletedAudios.Add(route.Audio);
route.Audio = null;
}
}
foreach (var exhibit in exhibits)
{
RemovePages(exhibit, deletedPages, deletedImages, deletedAudios);
if (exhibit.Image != null && !allMedias.Contains(exhibit.Image.IdForRestApi))
{
deletedImages.Add(exhibit.Image);
exhibit.Image = null;
}
}
foreach (var exhibit in deletedExhibits)
{
dataAccess.DeleteItem(exhibit);
}
foreach (var route in deletedRoutes)
{
dataAccess.DeleteItem(route);
}
foreach (var waypoint in deletedWaypoints)
{
dataAccess.DeleteItem(waypoint);
}
foreach (var tag in deletedTags)
{
dataAccess.DeleteItem(tag);
}
var fileManager = IoCManager.Resolve <IMediaFileManager>();
foreach (var image in deletedImages)
{
dataAccess.DeleteItem(image);
fileManager.DeleteFile(image.DataPath);
}
foreach (var audio in deletedAudios)
{
dataAccess.DeleteItem(audio);
fileManager.DeleteFile(audio.DataPath);
}
foreach (var page in deletedPages)
{
dataAccess.DeleteItem(page);
}
}
public TransactionServices(ITransactionDataAccess transactionDataAccess, ILog logger)
{
_transactionDataAccess = transactionDataAccess;
_logger = logger;
}
public TransactionCore(ITransactionDataAccess transactionDataAccess)
{
this.transactionDataAccess = transactionDataAccess;
}
public TransactionController(ITransactionDataAccess transactionDataAccess)
{
this._transactionDataAccess = transactionDataAccess;
}
public ReadWriteExtensions(ITransactionDataAccess dataAccess) : base(dataAccess)
{
this.dataAccess = dataAccess;
}
public TransactionsController()
{
c = new SqlConnection(connectionString);
db = c.As <ITransactionDataAccess>();
}
public static ReadWriteExtensions Routes(this ITransactionDataAccess dataAccess) => new ReadWriteExtensions(dataAccess);
/// <summary>
/// Converts AchievementDto instances to local models using the
/// <see cref="RouteFinishedAchievementConverter"/> and <see cref="ExhibitsVisitedAchievementConverter"/>.
/// </summary>
/// <returns>Converted items</returns>
/// <exception cref="ArgumentException">For unsupported achievement types.</exception>
public static IList <AchievementBase> Convert(IEnumerable <AchievementDto> dtos, ITransactionDataAccess dataAccess)
{
return(dtos.Select <AchievementDto, AchievementBase>(dto =>
{
switch (dto)
{
case RouteFinishedAchievementDto r:
return RouteFinishedAchievementConverter.ConvertReplacingExisting(r, r.Id.ToString(), dataAccess);
case ExhibitsVisitedAchievementDto e:
return ExhibitsVisitedAchievementConverter.ConvertReplacingExisting(e, e.Id.ToString(), dataAccess);
default:
throw new ArgumentException("Unsupported achievement type!");
}
}).ToList());
}
public ReadWriteExtensions(ITransactionDataAccess dataAccess) : base(dataAccess)
{
this.dataAccess = dataAccess ?? throw new ArgumentNullException(nameof(dataAccess));
}
/// <summary>
/// Converts the given <paramref name="dto"/> to a new model object, deleting the entity first if it already exists.
/// </summary>
public TModelObject ConvertReplacingExisting(TDtoObject dto, [NotNull] string id, ITransactionDataAccess dataAccess)
{
var modelObject = dataAccess.GetItem <TModelObject>(id) ?? CreateModelInstance(dto);
modelObject.Id = id ?? throw new ArgumentNullException(nameof(id));
Convert(dto, modelObject);
return(modelObject);
}
