public CultureGroupDetailsViewModel GetModules(string culture)
{
var model = new CultureGroupDetailsViewModel {
Culture = culture
};
var session = _sessionLocator.For(typeof(LocalizableStringRecord));
var paths = session.CreateSQLQuery(
string.Format(@" SELECT Localizable.Path,
COUNT(Localizable.Id) AS TotalCount,
COUNT(Translation.Id) AS TranslatedCount
FROM {0}Q42_DbTranslations_LocalizableStringRecord AS Localizable
LEFT OUTER JOIN {0}Q42_DbTranslations_TranslationRecord AS Translation
ON Localizable.Id = Translation.LocalizableStringRecord_id
AND Translation.Culture = :culture
GROUP BY Localizable.Path
ORDER BY Localizable.Path", DataTablePrefix()))
.AddScalar("Path", NHibernateUtil.String)
.AddScalar("TotalCount", NHibernateUtil.Int32)
.AddScalar("TranslatedCount", NHibernateUtil.Int32)
.SetParameter("culture", culture);
model.Groups = paths.List <object[]>()
.Select(t => new CultureGroupDetailsViewModel.TranslationGroup
{
Path = (string)t[0],
TotalCount = (int)t[1],
TranslationCount = (int)t[2],
}).ToList();
return(model);
}
private IQuery GetDeletedVersionsQuery(IEnumerable <int> contentItemIds = null)
{
var session = _sessionLocator.For(typeof(ContentItemVersionRecord));
// Select only the highest versions where both Published and Latest are false.
var select =
"select max(ContentItemVersionRecord.Id), ContentItemVersionRecord.ContentItemRecord.Id, max(ContentItemVersionRecord.Number) " +
"from Orchard.ContentManagement.Records.ContentItemVersionRecord ContentItemVersionRecord ";
var filter = contentItemIds != null ? "where ContentItemVersionRecord.ContentItemRecord.Id in (:ids) " : default(String);
var group =
"group by ContentItemVersionRecord.ContentItemRecord.Id " +
"having max(cast(Latest as Int32)) = 0 and max(cast(Published as Int32)) = 0 ";
var hql = String.Concat(select, filter, group);
var query = session.CreateQuery(hql);
if (contentItemIds != null)
{
query.SetParameterList("ids", contentItemIds.ToArray());
}
return(query);
}
public void Empty()
{
_sessionLocator.For(typeof(CombinedFileRecord)).CreateQuery("DELETE FROM " + typeof(CombinedFileRecord).FullName).ExecuteUpdate();
if (_storageProvider.FolderExists(RootPath))
{
_storageProvider.DeleteFolder(RootPath);
}
_combinatorEventHandler.CacheEmptied();
}
public CultureDetailsViewModel GetCultureDetailsViewModel(string culture)
{
var model = new CultureDetailsViewModel {
Culture = culture
};
var session = _sessionLocator.For(typeof(LocalizableStringRecord));
var query = session.CreateQuery(string.Format(@"
select s
from {0}Q42.DbTranslations.Models.LocalizableStringRecord as s fetch all properties
order by s.Path", DataTablePrefix()));
var currentPath = "";
var group = default(CultureDetailsViewModel.TranslationGroupViewModel);
foreach (LocalizableStringRecord s in query.Enumerable())
{
if (s.Path != currentPath)
{
group = new CultureDetailsViewModel.TranslationGroupViewModel {
Path = String.Format(s.Path, culture)
};
if (!group.Path.Contains(culture))
{
throw new Exception("Something went wrong: the culture is not included in the path.");
}
model.Groups.Add(group);
currentPath = s.Path;
}
if (group != null)
{
var translation = s.Translations.Where(t => t.Culture == culture).FirstOrDefault();
group.Translations.Add(new CultureDetailsViewModel.TranslationViewModel {
Context = s.Context,
Key = s.StringKey,
OriginalString = s.OriginalLanguageString,
LocalString = translation != null ? translation.Value : null
});
}
}
return(model);
}
public DefaultDataMigrationInterpreter(
ShellSettings shellSettings,
ILogger logger,
ISessionLocator sessionLocator,
ISessionFactoryHolder sessionFactoryHolder)
{
_shellSettings = shellSettings;
_commandInterpreters = new List <ICommandInterpreter>();
_session = sessionLocator.For(typeof(DefaultDataMigrationInterpreter));
_sqlStatements = new List <string>();
_sessionFactoryHolder = sessionFactoryHolder;
Logger = logger;
var configuration = _sessionFactoryHolder.GetConfiguration();
_dialect = Dialect.GetDialect(configuration.Properties);
}
private void RunPendingStatements()
{
var session = _sessionLocator.For(typeof(ContentItemRecord));
var connection = session.Connection;
foreach (var sqlStatement in _sqlStatements)
{
Logger.Debug(sqlStatement);
using (var command = connection.CreateCommand()) {
command.CommandText = sqlStatement;
command.ExecuteNonQuery();
}
_reportsCoordinator.Information("Data Migration", String.Format("Executing SQL Query: {0}", sqlStatement));
}
_sqlStatements.Clear();
}
private void RunPendingStatements()
{
var session = _sessionLocator.For(typeof(DataMigrationRecord));
try
{
foreach (var sqlStatement in _sqlStatements)
{
//Logger.Debug(sqlStatement);
using (var command = session.Connection.CreateCommand())
{
command.CommandText = sqlStatement;
session.Transaction.Enlist(command);
command.ExecuteNonQuery();
}
}
}
finally
{
_sqlStatements.Clear();
}
}
private void RunPendingStatements()
{
var session = _sessionLocator.For(typeof(IUser));
try {
foreach (var sqlStatement in _sqlStatements)
{
Logger.Debug(sqlStatement);
using (var command = session.Connection.CreateCommand())
{
command.CommandText = sqlStatement;
session.Transaction.Enlist(command);
command.ExecuteNonQuery();
}
_reportsCoordinator.Information("Data Migration", String.Format("Executing SQL Query: {0}", sqlStatement));
}
}
finally
{
_sqlStatements.Clear();
}
}
public void Process(int commentsPartId)
{
var commentsPart = _contentManager.Get <CommentsPart>(commentsPartId);
if (commentsPart == null)
{
return;
}
var common = commentsPart.As <CommonPart>();
if (common == null)
{
return;
}
var container = common.Container;
if (container == null)
{
return;
}
var containerComments = container.As <ContainerCommentsCountPart>();
if (containerComments == null)
{
return;
}
var session = _sessionLocator.For(typeof(object));
var q = session.CreateQuery(
"select SUM(comments.CommentsCount) " +
"from Orchard.ContentManagement.Records.ContentItemVersionRecord civ " +
"join civ.ContentItemRecord ci " +
"join ci.CommonPartRecord common " +
"join ci.CommentsPartRecord comments " +
"where common.Container = :containerid"
);
q.SetParameter("containerid", container.Id);
var list = q.List();
var count = (long)list[0];
containerComments.Count = Convert.ToInt32(count);
var pendingQuery = session.CreateQuery(@"select count(comment.Id)
from Orchard.ContentManagement.Records.ContentItemVersionRecord civ
join civ.ContentItemRecord ci
join ci.CommentPartRecord comment
join comment.CommentsPartRecord comments
join comments.ContentItemRecord cicomment
join cicomment.CommonPartRecord common
where comment.Status = 'Pending' and common.Container = :containerid"
);
pendingQuery.SetParameter("containerid", container.Id);
var pendingList = pendingQuery.List();
var pendingCount = (long)pendingList[0];
containerComments.PendingCount = Convert.ToInt32(pendingCount);
}
// ReSharper disable CoVariantArrayConversion
private object[] ExecuteSelectQuery(
RequestSelect select,
string[] storages,
IDictionary <string, object[]> results)
{
if (select.From == null)
{
throw new InvalidExpressionException(Localization.SelectFromCantBeNull);
}
if (select.From.EqualsIgnoreCase(RequestSelectFromTables.EventMetadata))
{
var queryable = GenericQueryFactory.CreateQuery(_eventMetadataRepository.Table, select, results);
var records = queryable
.Where(r => !r.IsDeleted && r.Status == (byte)EventStatus.Public)
.OrderBy(select)
.Take(DefaultEventsLimit)
.ToArray();
var dataContracts = records
.Select(rec => DataContractsFactory.CreateDataContract(rec, select.Fields, storages,
_storageProvider, select.PictureSize, _imageProfileManager))
.ToArray();
return(dataContracts);
}
if (select.From.EqualsIgnoreCase(RequestSelectFromTables.GroupedEventMetadata))
{
var session = _sessionLocator.For(typeof(EventMetadataRecord));
var sqlQuery = GroupedEventsQueryFactory.CreateQuery(
session,
select.AppendDefaultWhere(),
results);
var records = sqlQuery.List <EventMetadataRecord>();
var dataContracts = records
.Select(rec => DataContractsFactory.CreateDataContract(rec, select.Fields, storages,
_storageProvider, select.PictureSize, _imageProfileManager))
.ToArray();
return(dataContracts);
}
if (select.From.EqualsIgnoreCase(RequestSelectFromTables.Entity))
{
var queryable = GenericQueryFactory.CreateQuery(_entityRepository.Table, select, results);
var records = queryable
.Where(r => !r.IsDeleted)
.OrderBy(select)
.Take(DefaultEntitiesLimit)
.ToArray();
var dataContracts = records
.Select(rec => DataContractsFactory.CreateDataContract(rec, select.Fields,
_storageProvider, select.PictureSize, _imageProfileManager))
.ToArray();
return(dataContracts);
}
if (select.From.EqualsIgnoreCase(RequestSelectFromTables.EventVenueDetail))
{
var queryable = GenericQueryFactory.CreateQuery(_eventEntityDetailRepository.Table, select, results);
var records = queryable
.Where(r => !r.IsDeleted)
.OrderBy(select)
.Take(DefaultEntitiesLimit)
.ToArray();
var dataContracts = records
.Select(rec => DataContractsFactory.CreateDataContract(rec, select.Fields, storages))
.ToArray();
return(dataContracts);
}
if (select.From.EqualsIgnoreCase(RequestSelectFromTables.Show))
{
var queryable = GenericQueryFactory.CreateQuery(_showRepository.Table, select, results);
var records = queryable
.Where(r => !r.IsDeleted)
.OrderBy(select)
.Take(DefaultShowsLimit)
.ToArray();
var dataContracts = records
.Select(rec => DataContractsFactory.CreateDataContract(rec, select.Fields, storages,
_storageProvider, select.PictureSize, _imageProfileManager))
.ToArray();
return(dataContracts);
}
throw new InvalidExpressionException(string.Format(Localization.CantFindTable, select.From));
}
private ActionResult IndexImplementation(string q, string resultType, int page)
{
if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to list queries")))
{
return(new HttpUnauthorizedResult());
}
dynamic pagerShape = null;
long countResult = -1;
IEnumerable <IContent> contentResults = null;
IEnumerable <object[]> recordResults = null;
try {
var pager = new Pager(_siteService.GetSiteSettings(), new PagerParameters {
Page = page
});
if (!String.IsNullOrWhiteSpace(q))
{
var query = _sessionLocator.For(typeof(object))
.CreateQuery(q);
var queryResults = _sessionLocator.For(typeof(object))
.CreateQuery(q)
.SetFirstResult((pager.Page - 1) * pager.PageSize)
.SetMaxResults(pager.PageSize)
.List();
if (queryResults.Any())
{
switch (resultType)
{
case "scalar":
countResult = (long)queryResults[0];
break;
case "records":
recordResults = queryResults.Cast <object[]>();
break;
default:
var ids = queryResults[0] is int
?queryResults.Cast <int>()
: queryResults.Cast <object[]>().Select(r => (int)r[0]);
contentResults = _contentManager
.GetMany <IContent>(ids, VersionOptions.Published, QueryHints.Empty);
break;
}
}
pagerShape = Shape.Pager(pager).TotalItemCount(query.List().Count);
}
}
catch (QueryException qex) {
NotifyOfException(qex);
}
catch (GenericADOException adoex) {
NotifyOfException(adoex);
}
var viewModel = Shape.HqlPlayGroundIndexViewModel(
Query: q,
ResultType: String.IsNullOrWhiteSpace(resultType) ? "content" : resultType,
Pager: pagerShape,
CountResult: countResult,
ContentResults: contentResults,
RecordResults: recordResults
);
return(View("Index", viewModel));
}
void IBackgroundTask.Sweep()
{
if (Monitor.TryEnter(_sweepLock))
{
try {
Logger.Debug("Beginning sweep.");
if (!_orchardServices.WorkContext.CurrentSite.As <CloudMediaSettingsPart>().IsValid())
{
Logger.Debug("Settings are invalid; going back to sleep.");
return;
}
var pendingAssetsQuery =
from asset in _assetManager.LoadPendingAssets()
where _fileManager.FileExists(asset.LocalTempFileName)
select asset;
var pendingAssets = pendingAssetsQuery.ToArray();
if (!pendingAssets.Any())
{
Logger.Debug("No pending assets with temp files on local machine were found; going back to sleep.");
return;
}
Logger.Information("Beginning processing of {0} pending assets.", pendingAssets.Length);
var uploadTasks = new List <Task>();
var progressInfoQueue = new BlockingCollection <WamsUploadProgressInfo>();
var assetProgressMonikers = new Dictionary <Guid, Asset>();
var assetCancellationTokenSources = new Dictionary <Guid, CancellationTokenSource>();
foreach (var pendingAsset in pendingAssets)
{
Logger.Information("Uploading asset of type {0} with name '{1}'...", pendingAsset.Record.Type, pendingAsset.Name);
var cloudVideoPart = _contentManager.Get <CloudVideoPart>(pendingAsset.Record.VideoContentItemId, VersionOptions.Latest);
pendingAsset.UploadState.Status = AssetUploadStatus.Uploading;
pendingAsset.UploadState.StartedUtc = _clock.UtcNow;
pendingAsset.UploadState.BytesComplete = 0;
pendingAsset.UploadState.CompletedUtc = null;
_transactionManager.RequireNew();
var assetProgressMoniker = Guid.NewGuid();
var assetCancellationTokenSource = new CancellationTokenSource();
assetProgressMonikers.Add(assetProgressMoniker, pendingAsset);
assetCancellationTokenSources.Add(assetProgressMoniker, assetCancellationTokenSource);
var localPendingAsset = pendingAsset;
var uploadTask =
_wamsClient.UploadAssetAsync(_fileManager.GetPhysicalFilePath(pendingAsset.LocalTempFileName), progressInfoQueue.Add, assetProgressMoniker, assetCancellationTokenSource.Token)
.ContinueWith((previousTask) => {
if (!previousTask.IsCanceled)
{
try {
var wamsAsset = previousTask.Result; // Throws if previous task was faulted.
var wamsLocators = _wamsClient.CreateLocatorsAsync(wamsAsset, WamsLocatorCategory.Private).Result;
localPendingAsset.WamsPrivateLocatorId = wamsLocators.SasLocator.Id;
localPendingAsset.WamsPrivateLocatorUrl = wamsLocators.SasLocator.Url;
localPendingAsset.WamsAssetId = wamsAsset.Id;
localPendingAsset.UploadState.Status = AssetUploadStatus.Uploaded;
localPendingAsset.UploadState.BytesComplete = localPendingAsset.LocalTempFileSize;
localPendingAsset.UploadState.CompletedUtc = _clock.UtcNow;
}
catch (Exception ex) {
Logger.Error(ex, "Error while uploading asset of type {0} with name '{1}'. Resetting asset upload status to {2}.", localPendingAsset.Record.Type, localPendingAsset.Name, AssetUploadStatus.Pending);
// Reset asset to pending status so it will be retried later.
localPendingAsset.UploadState.CompletedUtc = null;
localPendingAsset.UploadState.BytesComplete = 0;
localPendingAsset.UploadState.StartedUtc = null;
localPendingAsset.UploadState.Status = AssetUploadStatus.Pending;
return;
}
}
_fileManager.DeleteFile(localPendingAsset.LocalTempFileName);
localPendingAsset.LocalTempFileName = null;
localPendingAsset.LocalTempFileSize = null;
Logger.Information("Deleted temp file '{0}' for asset of type {1} with name '{2}'.", localPendingAsset.LocalTempFileName, localPendingAsset.Record.Type, localPendingAsset.Name);
if (previousTask.IsCanceled)
{
Logger.Information("Upload of asset of type {0} with name '{1}' was canceled.", localPendingAsset.Record.Type, localPendingAsset.Name);
}
else
{
try {
if (cloudVideoPart.PublishOnUpload)
{
var remainingPendingAssetsQuery =
from asset in cloudVideoPart.Assets
where asset.UploadState.Status.IsAny(AssetUploadStatus.Pending, AssetUploadStatus.Uploading)
select asset;
if (!remainingPendingAssetsQuery.Any())
{
Logger.Information("No more remaining assets on cloud video item with ID {0}; publishing the item.", cloudVideoPart.Id);
_contentManager.Publish(cloudVideoPart.ContentItem);
cloudVideoPart.PublishOnUpload = false;
Logger.Information("Published cloud video item with ID {0}.", cloudVideoPart.Id);
}
}
else if (cloudVideoPart.ContentItem.IsPublished())
{
// Publish the asset.
_assetManager.PublishAssetsFor(cloudVideoPart);
}
}
catch (Exception ex) {
Logger.Warning(ex, "Upload of asset of type {0} with name '{1}' was completed but an error occurred while publishing the cloud video item with ID {2} after upload.", localPendingAsset.Record.Type, localPendingAsset.Name, cloudVideoPart.Id);
}
Logger.Information("Upload of asset of type {0} with name '{1}' was successfully completed.", localPendingAsset.Record.Type, localPendingAsset.Name);
}
}, assetCancellationTokenSource.Token);
uploadTask.ConfigureAwait(continueOnCapturedContext: false);
uploadTasks.Add(uploadTask);
}
Task.WhenAll(uploadTasks).ContinueWith((previousTask) => progressInfoQueue.CompleteAdding());
var lastUpdateUtc = _clock.UtcNow;
foreach (var progressInfo in progressInfoQueue.GetConsumingEnumerable())
{
var progressAsset = assetProgressMonikers[progressInfo.AssetMoniker];
var cancellationTokenSource = assetCancellationTokenSources[progressInfo.AssetMoniker];
// Check for cancellation (asset upload status was set to Canceled).
if (!cancellationTokenSource.IsCancellationRequested)
{
var session = _sessionLocator.For(typeof(AssetRecord));
session.Refresh(progressAsset.Record, LockMode.None);
if (progressAsset.UploadState.Status == AssetUploadStatus.Canceled)
{
Logger.Information("Cancellation request was detected for asset of type {0} with name '{1}'; cancelling upload...", progressAsset.Record.Type, progressAsset.Name);
cancellationTokenSource.Cancel();
}
}
// Don't flood the database with progress updates; limit it to every 5 seconds.
if ((_clock.UtcNow - lastUpdateUtc).Seconds >= 5)
{
progressAsset.UploadState.BytesComplete = progressInfo.Data.BytesTransferred;
_transactionManager.RequireNew();
lastUpdateUtc = _clock.UtcNow;
}
Logger.Debug("Uploading asset of type {0} with name '{1}'; {2}/{3} KB uploaded ({4}%) at {5} KB/sec.", progressAsset.Record.Type, progressAsset.Name, Convert.ToInt64(progressInfo.Data.BytesTransferred / 1024), Convert.ToInt64(progressInfo.Data.TotalBytesToTransfer / 1024), progressInfo.Data.ProgressPercentage, Convert.ToInt32(progressInfo.Data.TransferRateBytesPerSecond / 1024));
}
}
finally {
Logger.Debug("Ending sweep.");
Monitor.Exit(_sweepLock);
}
}
}