/// <summary>
/// Checks the status.
///
/// </summary>
/// <exception cref="T:System.Exception"><c>Exception</c>.
/// </exception>
public void CheckStatus()
{
Handle handle = Handle.Parse(this.JobHandle);
if (!handle.IsLocal)
{
SheerResponse.Timer("CheckStatus", Settings.Publishing.PublishDialogPollingInterval);
}
else
{
PublishStatus status = PublishManager.GetStatus(handle);
if (status == null)
{
throw new Exception("The publishing process was unexpectedly interrupted.");
}
if (status.Failed)
{
this.Active = "Retry";
this.NextButton.Disabled = true;
this.BackButton.Disabled = false;
this.CancelButton.Disabled = false;
this.ErrorText.Value = StringUtil.StringCollectionToString(status.Messages);
}
else
{
string publishingTargetHtml;
if (status.State == JobState.Running)
{
publishingTargetHtml = string.Format("{0} {1}<br/><br/>{2} {3}<br/><br/>{4} {5}",
Translate.Text("Database:"),
StringUtil.Capitalize(status.CurrentTarget.NullOr(db => db.Name)),
Translate.Text("Language:"),
status.CurrentLanguage.NullOr(lang => lang.CultureInfo.DisplayName),
Translate.Text("Processed:"),
status.Processed);
}
else
{
publishingTargetHtml = status.State != JobState.Initializing ? Translate.Text("Queued.") : Translate.Text("Initializing.");
}
if (status.IsDone)
{
this.Status.Text = Translate.Text("Items processed: {0}.", new object[] { status.Processed.ToString(CultureInfo.InvariantCulture) });
this.Active = "LastPage";
this.BackButton.Disabled = true;
string result = StringUtil.StringCollectionToString(status.Messages, "\n");
if (string.IsNullOrEmpty(result))
{
return;
}
this.ResultText.Value = result;
}
else
{
SheerResponse.SetInnerHtml("PublishingTarget", publishingTargetHtml);
SheerResponse.Timer("CheckStatus", Settings.Publishing.PublishDialogPollingInterval);
}
}
}
}
public override void ProcessPublish(Item item, ItemProcessingEventArgs args)
{
var parentFolderItems = new List <Item>();
var parentItem = item?.Parent;
while (
parentItem != null &&
parentItem.TemplateID == IArticle_Date_FolderConstants.TemplateId)
{
if (!((CheckboxField)parentItem.Fields[I___PublishStatusConstants.___Item_PublishedFieldName]).Checked)
{
parentFolderItems.Insert(0, parentItem);
}
parentItem = parentItem.Parent;
}
if (!parentFolderItems.Any())
{
return;
}
parentFolderItems.Add(item);
parentFolderItems.ForEach(pfi => PublishManager.PublishItem(
pfi,
new Database[] { args.Context.PublishOptions.TargetDatabase },
new Sitecore.Globalization.Language[] { args.Context.PublishOptions.Language },
false,
false,
false));
}
public ActionResult PublishItem(string itemId)
{
Database source = Factory.GetDatabase("master");
Item item = source.GetItem(itemId);
if (item == null)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
Database target = Factory.GetDatabase("web");
try
{
PublishManager.PublishItem(item.Parent, new[] { target }, item.Languages, true, false);
return(Json(true, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
Sitecore.Diagnostics.Log.Error("Exception publishing items from custom pipeline! : " + ex, this);
}
return(Json(false, JsonRequestBehavior.AllowGet));
}
public StatusViewModel(PublishManager manager)
{
_manager = manager;
_ipfsDaemon = _manager.IpfsDaemon;
IpfsStatus = "Idle";
_ipfsDaemon.OnStateChanged += _ipfsDaemon_OnStateChanged;
}
public Publisher PublishApp(string projectFilePath, Action <ClickTwicePackSettings> configure = null)
{
configure?.Invoke(Settings);
var host = new ConsoleScriptHost();
BasePublishManager mgr;
if (Settings.UseDirectPublish)
{
mgr = new DirectPublisher(projectFilePath, ToSource(Settings));
}
else
{
mgr = new PublishManager(projectFilePath, ToSource(Settings));
}
mgr.Configuration = Settings.Configuration;
mgr.Platform = Settings.Platform;
mgr.CleanOutputOnCompletion = Settings.OutputClean;
mgr.InputHandlers = Settings.InputHandlers;
mgr.OutputHandlers = Settings.OutputHandlers;
mgr.Loggers = Settings.Loggers;
mgr.Loggers.RemoveAll(l => l.GetType() == typeof(ConsoleLogger));
mgr.Loggers.Add(new ConsoleLogger(Settings.LogBuildMessages));
if (!string.IsNullOrWhiteSpace(Settings.PublishVersion))
{
mgr.AdditionalProperties.Add("ApplicationVersion", Settings.PublishVersion);
}
return(new Publisher(mgr)
{
Host = host
});
}
private void PublishDatabase([NotNull] Database database, int mode, [NotNull] List <Language> languageList, [NotNull] List <Database> targetList)
{
Debug.ArgumentNotNull(database, nameof(database));
Debug.ArgumentNotNull(languageList, nameof(languageList));
Debug.ArgumentNotNull(targetList, nameof(targetList));
switch (mode)
{
case 0:
PublishManager.PublishIncremental(database, targetList.ToArray(), languageList.ToArray());
break;
case 1:
PublishManager.PublishSmart(database, targetList.ToArray(), languageList.ToArray());
break;
case 2:
PublishManager.Republish(database, targetList.ToArray(), languageList.ToArray());
break;
case 3:
PublishManager.RebuildDatabase(database, targetList.ToArray());
break;
}
}
protected override void ProcessItem(Item item)
{
if (item.Database.Name.IsNot("master"))
{
WriteError(typeof(PSInvalidOperationException), $"Item '{item.Name}' cannot be published. Only items from the 'master' database can be published!",
ErrorIds.InvalidOperation, ErrorCategory.InvalidOperation, null);
return;
}
var source = Factory.GetDatabase("master");
if (Target != null)
{
var targets = Target.Distinct(StringComparer.CurrentCultureIgnoreCase).ToList();
foreach (var target in targets.Select(Factory.GetDatabase))
{
PublishToTarget(item, source, target);
}
}
else
{
foreach (var publishingTarget in PublishManager.GetPublishingTargets(source))
{
var target = Factory.GetDatabase(publishingTarget[Sitecore.FieldIDs.PublishingTargetDatabase]);
PublishToTarget(item, source, target);
}
}
}
public void RunPostDeployAction(XDocument deployedItems, IPostDeployActionHost host, string parameter)
{
host.LogMessage("Smart publishing master to web");
PublishManager.PublishSmart(Sitecore.Data.Database.GetDatabase("master"),
new [] { Sitecore.Data.Database.GetDatabase("web") },
new [] { LanguageManager.GetLanguage("en") });
}
public string Execute([NotNull] string databaseName, int mode)
{
Assert.ArgumentNotNull(databaseName, nameof(databaseName));
var database = Factory.GetDatabase(databaseName);
var publishingTargets = PublishManager.GetPublishingTargets(database);
var targetDatabases = publishingTargets.Select(target => Factory.GetDatabase(target["Target database"])).ToArray();
var languages = LanguageManager.GetLanguages(database).ToArray();
switch (mode)
{
case 0:
PublishManager.Republish(database, targetDatabases, languages);
break;
case 1:
PublishManager.PublishIncremental(database, targetDatabases, languages);
break;
case 2:
PublishManager.PublishSmart(database, targetDatabases, languages);
break;
case 3:
PublishManager.RebuildDatabase(database, targetDatabases);
break;
}
return(string.Empty);
}
public void InitializeBis(string username, string password, uint controlSytemAuthentication, uint port, uint ssl, string certificateFileName,
string privateKeyFileName, uint enableWebSocketServer, uint webSocketServerPort)
{
if (username != "//" || password != "//")
{
MqttSettings.Instance.Username = username;
MqttSettings.Instance.Password = password;
}
MqttSettings.Instance.ControlSytemAuthentication = controlSytemAuthentication == 1 ? true : false;
MqttSettings.Instance.Port = Convert.ToInt32(port);
MqttSettings.Instance.SSLCertificateProvided = ssl == 0 ? false : true;
MqttSettings.Instance.CertificateFileName = certificateFileName;
MqttSettings.Instance.PrivateKeyFileName = privateKeyFileName;
CrestronLogger.WriteToLog("INITIALIZE DEL BROKER BIS: " + port + " " + ssl + " " + certificateFileName + " " + privateKeyFileName +
"\n Web Socket Server " + enableWebSocketServer + " Web Socket Port " + webSocketServerPort, 1);
subscriptionManager = new SubscriptionManager();
sessionManager = new SessionManager(subscriptionManager);
publishManager = new PublishManager(subscriptionManager);
clients = new List <MqttClient>();
rand = new Random();
packetIdentifiers = new List <ushort>();
TCPServer tcpServer = new TCPServer(clients, sessionManager, packetIdentifiers, rand, Convert.ToInt32(port), 60);
WSServer webSocketServer = new WSServer(clients, sessionManager, packetIdentifiers, rand, Convert.ToInt32(webSocketServerPort), 60);
PacketManager pm = new PacketManager(rand, sessionManager, publishManager, subscriptionManager, clients, packetIdentifiers, tcpServer, webSocketServer);
}
/// <summary>
/// Запуск публикации веб-ресурсов.
/// Определяет ид веб-ресурсов
/// 1. в файле привязок
/// 2. по имени веб-ресурса
/// 3. ручное связывание
/// </summary>
private async Task UpdateContentAndPublishEqualByText(List <SelectedFile> selectedFiles, ConnectionData connectionData)
{
if (connectionData == null)
{
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.NoCurrentCRMConnection);
return;
}
var compareResult = await CompareController.GetWebResourcesWithType(this._iWriteToOutput, selectedFiles, OpenFilesType.EqualByText, connectionData);
var filesToPublish = compareResult.Item2.Where(f => f.Item2 != null);
if (!filesToPublish.Any())
{
this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.NothingToPublish);
return;
}
// Менеджер для публикации в CRM.
PublishManager publishHelper = new PublishManager(this._iWriteToOutput, compareResult.Item1);
foreach (var item in filesToPublish)
{
publishHelper.Add(new ElementForPublish(item.Item1, item.Item2));
}
publishHelper.UpdateContentAndPublish();
}
private void PublishSmart()
{
var targetDatabases = new[] { Factory.GetDatabase("web") };
var languages = _db.Languages;
PublishManager.PublishSmart(_db, targetDatabases, languages);
}
public string Execute([NotNull] string databaseName, [NotNull] string itemsList, bool deep, bool compareRevisions)
{
Assert.ArgumentNotNull(databaseName, nameof(databaseName));
Assert.ArgumentNotNull(itemsList, nameof(itemsList));
var database = Factory.GetDatabase(databaseName);
var publishingTargets = PublishManager.GetPublishingTargets(database);
var targetDatabases = publishingTargets.Select(target => Factory.GetDatabase(target["Target database"])).ToArray();
var languages = LanguageManager.GetLanguages(database).ToArray();
var published = new List <string>();
foreach (var id in itemsList.Split(','))
{
var item = database.GetItem(id);
if (item == null)
{
continue;
}
Publish(published, item, targetDatabases, languages, deep, compareRevisions);
}
return(string.Empty);
}
public static void Register(CommandLineApplication cmdApp, ReportsFactory reportsFactory, IApplicationEnvironment applicationEnvironment, IServiceProvider serviceProvider)
{
cmdApp.Command("publish", c =>
{
c.Description = "Publish application for deployment";
var argProject = c.Argument("[project]", "Path to project, default is current directory");
var optionOut = c.Option("-o|--out <PATH>", "Where does it go", CommandOptionType.SingleValue);
var optionConfiguration = c.Option("--configuration <CONFIGURATION>", "The configuration to use for deployment (Debug|Release|{Custom})",
CommandOptionType.SingleValue);
var optionNoSource = c.Option("--no-source", "Compiles the source files into NuGet packages",
CommandOptionType.NoValue);
var optionRuntime = c.Option("--runtime <RUNTIME>", "Name or full path of the runtime folder to include, or \"active\" for current runtime on PATH",
CommandOptionType.MultipleValue);
var optionNative = c.Option("--native", "Build and include native images. User must provide targeted CoreCLR runtime versions along with this option.",
CommandOptionType.NoValue);
var optionIncludeSymbols = c.Option("--include-symbols", "Include symbols in output bundle",
CommandOptionType.NoValue);
var optionWwwRoot = c.Option("--wwwroot <NAME>", "Name of public folder in the project directory",
CommandOptionType.SingleValue);
var optionWwwRootOut = c.Option("--wwwroot-out <NAME>",
"Name of public folder in the output, can be used only when the '--wwwroot' option or 'webroot' in project.json is specified",
CommandOptionType.SingleValue);
var optionQuiet = c.Option("--quiet", "Do not show output such as source/destination of published files",
CommandOptionType.NoValue);
c.HelpOption("-?|-h|--help");
c.OnExecute(() =>
{
c.ShowRootCommandFullNameAndVersion();
var options = new PublishOptions
{
OutputDir = optionOut.Value(),
ProjectDir = argProject.Value ?? System.IO.Directory.GetCurrentDirectory(),
Configuration = optionConfiguration.Value() ?? "Debug",
RuntimeTargetFramework = applicationEnvironment.RuntimeFramework,
WwwRoot = optionWwwRoot.Value(),
WwwRootOut = optionWwwRootOut.Value() ?? optionWwwRoot.Value(),
NoSource = optionNoSource.HasValue(),
Runtimes = optionRuntime.HasValue() ?
string.Join(";", optionRuntime.Values).
Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) :
new string[0],
Native = optionNative.HasValue(),
IncludeSymbols = optionIncludeSymbols.HasValue(),
Reports = reportsFactory.CreateReports(optionQuiet.HasValue())
};
var manager = new PublishManager(serviceProvider, options);
if (!manager.Publish())
{
return(-1);
}
return(0);
});
});
}
public PublishResult PublishSync(PublishOptions options)
{
var publishContext = PublishManager.CreatePublishContext(options);
publishContext.Languages = new[] { options.Language };
return(PublishPipeline.Run(publishContext));
}
public void AutoPublish(WorkflowPipelineArgs args)
{
Item dataItem = args.DataItem;
Item innerItem = args.ProcessorItem.InnerItem;
Database[] targets = this.GetTargets(dataItem);
PublishManager.PublishItem(dataItem, targets, new Language[] { dataItem.Language }, this.GetDeep(innerItem), false);
}
public async void IdentifyTagAsync(Guid tagId, Guid personId)
{
var indexName = Sitecore.Context.Database.Name == "master" ? "face_master_index" : "face_web_index";
var index = ContentSearchManager.GetIndex(indexName);
var personItem = GetPersonById(personId);
if (personItem == null)
{
return;
}
Log.Info("Identify Tag - Person found " + personItem.Name, this);
using (var context = index.CreateSearchContext())
{
var searchQuery = context.GetQueryable <FaceSearchResultItem>()
.Where(x => x.FaceTags.Contains(tagId));
var resultItem = searchQuery.FirstOrDefault();
if (resultItem != null)
{
Log.Info("Identify Tag - Tag found - " + resultItem.ItemId + " " + resultItem.Faces, this);
var imageItem = Database.GetDatabase("master").GetItem(resultItem.ItemId);
if (imageItem == null)
{
return;
}
Log.Info("Identify Tag - Image item " + imageItem.Name, this);
var faces =
JsonConvert.DeserializeObject(resultItem.Faces, typeof(List <FaceMetadata>)) as
List <FaceMetadata>;
var face = faces?.FirstOrDefault(i => i.UniqueId == tagId);
await UpdateFaceDefinition(imageItem, face, personItem);
SetIdentifiedPersonInfo(tagId, imageItem, personItem);
imageItem = Database.GetDatabase("master").GetItem(imageItem.ID);
PublishManager.PublishItem(imageItem, new[] { Database.GetDatabase("web"), }, new[] { imageItem.Language }, false, false);
index.Refresh(new SitecoreIndexableItem(imageItem), IndexingOptions.Default);
}
else
{
Log.Info("Identify Tag - Tag doesnt exissts " + tagId, this);
}
}
}
protected void CheckStatus()
{
Handle handle = Handle.Parse(this.JobHandle);
if (!handle.IsLocal)
{
SheerResponse.Timer("CheckStatus", Settings.Publishing.PublishDialogPollingInterval);
}
else
{
PublishStatus status = PublishManager.GetStatus(handle);
if (status == null)
{
throw new Exception("The flushing process was unexpectedly interrupted.");
}
if (status.Failed)
{
this.Status.Text = Translate.Text("Could not process. Please Try again", new object[] { status.Processed.ToString() });
base.Active = "LastPage";
base.BackButton.Disabled = true;
string str2 = StringUtil.StringCollectionToString(status.Messages, "\n");
if (!string.IsNullOrEmpty(str2))
{
this.ResultText.Value = str2;
}
}
string str;
if (status.State == JobState.Running)
{
object[] objArray = new object[] { Translate.Text("Database:"), " ", StringUtil.Capitalize(status.CurrentTarget.NullOr <Database, string>(db => db.Name)), "<br/><br/>", Translate.Text("Language:"), " ", status.CurrentLanguage.NullOr <Language, string>(lang => lang.CultureInfo.DisplayName), "<br/><br/>", Translate.Text("Processed:"), " ", status.Processed };
str = string.Concat(objArray);
}
else if (status.State == JobState.Initializing)
{
str = Translate.Text("Initializing.");
}
else
{
str = Translate.Text("Queued.");
}
if (status.IsDone)
{
this.Status.Text = Translate.Text("Items processed: {0}.", new object[] { status.Processed.ToString() });
base.Active = "LastPage";
base.BackButton.Disabled = true;
string str2 = StringUtil.StringCollectionToString(status.Messages, "\n");
if (!string.IsNullOrEmpty(str2))
{
this.ResultText.Value = string.Format("{0}{1}{2}", str2, Environment.NewLine, Translate.Text("Job ended: Initialize Sites Refresh."));
}
}
else
{
SheerResponse.SetInnerHtml("PublishingTarget", str);
SheerResponse.Timer("CheckStatus", Settings.Publishing.PublishDialogPollingInterval);
}
}
}
/// <summary>
/// Publishes an item in all languages to all publishing targets.
/// </summary>
/// <param name="item">The item to publish</param>
/// <param name="deep">If deep is set to true, all publishable descendants will be published as well</param>
/// <param name="compareRevisions">If compareRevisions is set to true, the Revision field in the versions of the item in source and target database are compared. If the Revision fields are the same, the item will not be published (also known as Smart Publish)</param>
public void PublishAll(Item item, bool deep, bool compareRevisions)
{
var targets = this.GetPublishingTargets(item);
if (targets.Count > 0)
{
PublishManager.PublishItem(item, targets.ToArray(), item.Languages, deep, compareRevisions);
}
}
public void PublishAsyncDataToBrokerWhenProxyIsNull()
{
var localPublishManager = new PublishManager <Topic>(null, null, new Queue <Message <Topic> >());
localPublishManager.PublishAsync(testMessage);
Assert.AreEqual(localPublishManager.GetAsyncQueueCount(), 1);
Assert.Catch <Exception>(() => localPublishManager.AsyncSendDataProcess());
}
/// <summary>
/// Handles item publish.
/// </summary>
/// <param name="publishSchedule">A <see cref="ScheduledPublish.Models.PublishSchedule"/> schedule to publish.</param>
/// <returns>A <see cref="T:Sitecore.Handle"/> publish handle.</returns>
private static Handle PublishItem(PublishSchedule publishSchedule)
{
if (publishSchedule.ItemToPublish == null)
{
Log.Error("Scheduled Publish: Scheduled Publish Task didn't execute because PublishSchedule.ItemToPublish is null", new object());
return(null);
}
Handle handle = null;
try
{
if (publishSchedule.Unpublish)
{
using (new SecurityDisabler())
{
publishSchedule.ItemToPublish.Editing.BeginEdit();
publishSchedule.ItemToPublish.Publishing.NeverPublish = true;
publishSchedule.ItemToPublish.Editing.AcceptChanges();
publishSchedule.ItemToPublish.Editing.EndEdit();
}
}
handle = PublishManager.PublishItem(
publishSchedule.ItemToPublish,
publishSchedule.TargetDatabases.ToArray(),
publishSchedule.TargetLanguages != null ?
publishSchedule.TargetLanguages.ToArray() :
publishSchedule.ItemToPublish.Languages.ToArray(),
publishSchedule.PublishChildren,
publishSchedule.PublishMode == PublishMode.Smart);
WaitPublish(handle);
if (publishSchedule.Unpublish)
{
using (new SecurityDisabler())
{
publishSchedule.ItemToPublish.Editing.BeginEdit();
publishSchedule.ItemToPublish.Publishing.NeverPublish = false;
publishSchedule.ItemToPublish.Editing.AcceptChanges();
publishSchedule.ItemToPublish.Editing.EndEdit();
}
}
}
catch (Exception ex)
{
Log.Error(
string.Format("Scheduled Publish: Scheduled Publish Task failed for {0} {1} {2}",
publishSchedule.ItemToPublish.Name,
publishSchedule.ItemToPublish.ID,
ex), new object());
}
return(handle);
}
private static PublishItemContext CreateItemContext(PublishingCandidate entry, PublishContext context)
{
Assert.ArgumentNotNull(entry, "entry");
var context2 = PublishManager.CreatePublishItemContext(entry.ItemId, entry.PublishOptions);
context2.Job = context.Job;
context2.User = context.User;
context2.PublishContext = context;
return(context2);
}
/// <summary>
/// Gets a report on the handle.
/// </summary>
/// <param name="handle">Handle.</param>
/// <returns>A <see cref="T:ScheduledPublish.Models.ScheduledPublishReport"/> report on the handle result.</returns>
public static ScheduledPublishReport GetScheduledPublishReport(Handle handle)
{
bool isSuccessful = false;
StringBuilder sbMessage = new StringBuilder();
if (handle == null)
{
sbMessage.Append("Final Status: Fail.<br/>");
sbMessage.Append("Please, check log files for more information.<br/>");
}
else
{
PublishStatus status = PublishManager.GetStatus(handle);
if (status == null)
{
sbMessage.Append("The scheduled publishing process was unexpectedly interrupted.<br/>");
sbMessage.Append("Please, check log files for more information.<br/>");
}
else
{
if (status.Failed)
{
sbMessage.Append("Final Status: Fail.<br/>");
sbMessage.Append("Please, check log files for more information.<br/>");
}
else if (status.IsDone)
{
sbMessage.Append("Final Status: Success.<br/>");
isSuccessful = true;
}
sbMessage.AppendFormat("Items processed: {0}.<br/><br/>", status.Processed);
if (status.Messages != null)
{
sbMessage.Append("Detailed Information:<br/>");
foreach (var message in status.Messages)
{
sbMessage.Append(message);
sbMessage.Append("<br/>");
}
}
}
}
ScheduledPublishReport report = new ScheduledPublishReport
{
IsSuccessful = isSuccessful,
Message = sbMessage.ToString()
};
return(report);
}
/// <summary>
/// Handles website publish.
/// </summary>
/// <param name="publishSchedule">A <see cref="ScheduledPublish.Models.PublishSchedule"/> schedule to publish.</param>
/// <returns>A <see cref="T:Sitecore.Handle"/> publish handle.</returns>
private static Handle PublishWebsite(PublishSchedule publishSchedule)
{
Handle handle = null;
try
{
switch (publishSchedule.PublishMode)
{
case PublishMode.Smart:
{
handle = PublishManager.PublishSmart(
publishSchedule.SourceDatabase,
publishSchedule.TargetDatabases.ToArray(),
publishSchedule.TargetLanguages.ToArray());
break;
}
case PublishMode.Full:
{
handle = PublishManager.Republish(
publishSchedule.SourceDatabase,
publishSchedule.TargetDatabases.ToArray(),
publishSchedule.TargetLanguages.ToArray());
break;
}
case PublishMode.Incremental:
{
handle = PublishManager.PublishIncremental(
publishSchedule.SourceDatabase,
publishSchedule.TargetDatabases.ToArray(),
publishSchedule.TargetLanguages.ToArray());
break;
}
default:
{
Log.Error("Scheduled Publish: Scheduled Publish Task didn't execute because invalid PublishMode", new object());
break;
}
}
WaitPublish(handle);
}
catch (Exception ex)
{
Log.Error(
string.Format("Scheduled Publish: Scheduled Publish Task failed for Website Publish in {0} Mode {1}",
publishSchedule.PublishMode,
ex), new object());
}
return(handle);
}
public static void PublishStudiesCleared()
{
try
{
PublishManager <IWorkItemActivityCallback> .Publish(StudiesCleared);
}
catch (Exception e)
{
Platform.Log(LogLevel.Warn, e, "Unexpected error attempting to publish StudiesCleared notification.");
}
}
public static void PublishWorkItemsChanged(WorkItemsChangedEventType eventType, List <WorkItemData> workItems)
{
try
{
PublishManager <IWorkItemActivityCallback> .Publish(WorkItemsChanged, eventType, workItems);
}
catch (Exception e)
{
Platform.Log(LogLevel.Warn, e, "Unexpected error attempting to publish WorkItemsChanged notification.");
}
}
/// <summary>
/// Waits publish to finish to we know the final status
/// </summary>
/// <param name="handle"></param>
private static void WaitPublish(Handle handle)
{
if (handle == null)
{
return;
}
while (!PublishManager.GetStatus(handle).IsDone)
{
Thread.Sleep(200);
}
}
public void RunPostDeployAction(XDocument deployedItems, IPostDeployActionHost host, string parameter)
{
var databases = this.GetDatabases(parameter);
foreach (string targetDatabase in databases)
{
host.LogMessage("Smart publishing master to " + targetDatabase);
PublishManager.PublishSmart(Sitecore.Data.Database.GetDatabase("master"),
new[] { Sitecore.Data.Database.GetDatabase(targetDatabase.Trim()) },
new[] { LanguageManager.GetLanguage("en") });
}
}
public static bool PublishQueuedItems(Item triggerItem, Database[] targets)
{
if (ManuallyAddedCandidates.Count == 0)
{
return(false);
}
// the trigger item simply has to exist so the publish occurs - our queue will then be injected
PublishManager.PublishItem(triggerItem, targets, new[] { triggerItem.Language }, true, false);
return(true);
}
private async void RunProcess(DetectFacesArgs args)
{
if (args.MediaItem == null)
{
return;
}
try
{
Log.Info("Image recognition starting...", this);
IFaceDetection faceDetection = new AzureFaceDetection();
var mediaStream = args.Stream ?? args.MediaItem.GetMediaStream();
if (mediaStream == null)
{
Log.Info("Weird.... media item media stream is empty...", this);
return;
}
var memoryStream = new MemoryStream();
await mediaStream.CopyToAsync(memoryStream);
var result = await faceDetection.DetectFacesAsync(memoryStream);
using (new SecurityDisabler())
{
args.MediaItem.InnerItem.Editing.BeginEdit();
args.MediaItem.InnerItem["FaceMetadata"] = JsonConvert.SerializeObject(result);
args.MediaItem.InnerItem.Editing.EndEdit(true, false);
}
PublishManager.PublishItem(args.MediaItem, new[] { Database.GetDatabase("web"), },
new[] { Language.Current }, false, false);
var index = ContentSearchManager.GetIndex("face_master_index");
index.Refresh(new SitecoreIndexableItem(args.MediaItem), IndexingOptions.Default);
index = ContentSearchManager.GetIndex("face_web_index");
index.Refresh(new SitecoreIndexableItem(args.MediaItem), IndexingOptions.Default);
Log.Info("Image recognition completed...", this);
}
catch (Exception e)
{
Log.Info("Something went wrong..." + e, this);
}
}