private void ContentService_Published(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.ContentPublishedEventArgs e)
{
try
{
using (var context = _umbracoContextFactory.EnsureUmbracoContext())
{
var defaultUrl = new Uri("/", UriKind.Relative);
var entries = e.PublishedEntities.Select(pe =>
{
var pc = context.UmbracoContext.Content.GetById(pe.Id);
var baseUrl = defaultUrl;
if (pc != null)
{
var absUrl = pc.Url(mode: UrlMode.Absolute).ToString();
var relUrl = pc.Url(mode: UrlMode.Relative).ToString();
baseUrl = new Uri(absUrl.Substring(0, absUrl.Length - relUrl.Length));
}
return(_searchIndexEntryHelper.GetIndexEntry(baseUrl, pe));
}).Where(ie => ie != null).ToList();
_searchApplianceService.UpdateSearchAppliance(entries);
}
}
catch (Exception ex)
{
_logger.Error <SearchComponent>(ex, "Could not update index entries");
}
}
public void ContentService_Saved(Umbraco.Core.Services.IContentService sender, SaveEventArgs <IContent> e)
{
List <EventType> eventTypes = _dataTypeProvider.GetEventTypes();
foreach (IContent entity in e.SavedEntities)
{
if (entity.ContentType.Alias == "event")
{
IPublishedContent eventPageContent = entity.ToPublishedContent();
var eventPage = new Event(eventPageContent);
var eventType = eventTypes.SingleOrDefault(et => et.Name == eventPage.EventType);
if (eventType == null)
{
//Log and move on
_logger.Warn(typeof(ContentEventHandler), $"No event type found for name '{eventPage.EventType}', event slots will not be created/updated.");
continue;
}
var eventDates = GetEventDates(eventPage, true);
List <EventSlot> existingEventSlots = _eventSlotRepository.GetAll(true, eventTypes, null, null).ToList();
existingEventSlots = existingEventSlots.Where(es => es.EventTypeId == eventType.Id && es.EventPageId == eventPage.Id).ToList();
var response = CreateUpdateEventSlots(existingEventSlots, eventType.Id, eventPage);
_logger.Info(typeof(ContentEventHandler),
$"Updated event slots for event type '{eventPage.EventType}'. Created {response.SlotsCreated}, updated {response.SlotsUpdated} and deleted {response.SlotsDeleted} slots.");
}
}
}
private void ContentService_Published(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.ContentPublishedEventArgs e)
{
var autoPublishSites = _sitesRepository.GetAutoPublishSites();
var sitesToDeploy = new List <ExtendedGeneratedSite>();
foreach (var publishedItem in e.PublishedEntities)
{
foreach (var site in autoPublishSites)
{
if (sitesToDeploy.Contains(site))
{
continue;
}
if (publishedItem.Path.Contains($",{site.RootNode},") || publishedItem.Path.EndsWith($",{site.RootNode}"))
{
sitesToDeploy.Add(site);
}
}
}
//var context = _umbracoContext.EnsureUmbracoContext();
var process = new RebuildProcess(_umbracoContextFactory, _exportTypeSettings);
var deployProcess = new DeployProcess(_storer, _deployerFactory, _sitesRepository);
foreach (var site in sitesToDeploy)
{
//process.RebuildSite(site.Id);
Task.Run(async() => {
await process.RebuildSite(site.Id);
await deployProcess.DeployStaticSite(site.Id);
});
}
}
private void ContentService_Publishing(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.ContentPublishingEventArgs e)
{
e.Cancel = true; //--------- Would make it impossible to publish content
foreach (var PublishedItem in e.PublishedEntities)
{
_logger.Info <LogWhenPublishedComponent>(PublishedItem.Name + " Is about to be published.");
}
}
private void ContentService_Deleted(Umbraco.Core.Services.IContentService sender,
Umbraco.Core.Events.DeleteEventArgs <Umbraco.Core.Models.IContent> e)
{
if (AllowProcessing)
{
Sync(e.DeletedEntities.Select(x => x.Key), null);
}
}
private void ContentService_Moved(Umbraco.Core.Services.IContentService sender,
Umbraco.Core.Events.MoveEventArgs <Umbraco.Core.Models.IContent> e)
{
if (AllowProcessing)
{
Sync(e.MoveInfoCollection.Select(x => x.Entity.Key), e.MoveInfoCollection.Where(x => x.Entity.Published).Select(x => x.Entity));
}
}
public void ContentService_Deleted(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.DeleteEventArgs <Umbraco.Core.Models.IContent> e)
{
foreach (var item in e.DeletedEntities)
{
var properties = new PropertiesDictionary(item);
AsyncUtil.RunSync(() => _messagingService.SendMessageAsync("contentService", "deleted", properties));
}
}
private void ContentService_Published(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.ContentPublishedEventArgs e)
{
//Code that will be executed whenever content is published.
foreach (var PublishedItem in e.PublishedEntities)
{
_logger.Info <LogWhenPublishedComponent>(PublishedItem.Name + " was published.");
}
}
public void ContentService_Moved(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.MoveEventArgs <Umbraco.Core.Models.IContent> e)
{
foreach (var item in e.MoveInfoCollection.Select(mi => mi.Entity))
{
var properties = new PropertiesDictionary(item);
AsyncUtil.RunSync(() => _messagingService.SendMessageAsync("contentService", "moved", properties));
}
}
private void ContentService_Published(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.ContentPublishedEventArgs e)
{
foreach (var publishedItem in e.PublishedEntities)
{
if (publishedItem.ContentType.Alias == "website")
{
ExamineComponent.AttemptAddIndexForContent(publishedItem);
}
}
}
private void ContentService_Saving(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.ContentSavingEventArgs e)
{
foreach (var mediaItem in e.SavedEntities.OfType <Umbraco.Core.Models.IMedia>())
{
if (mediaItem.ContentType.Alias == "Image" && mediaItem.VersionId <= 1)
{
//perhaps send to Azure for AI analysis of image contents or something...
AdageMediaService service = new AdageMediaService();
service.HandleImageUpload(mediaItem);
}
}
}
public void ContentService_Published(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.ContentPublishedEventArgs e)
{
foreach (var item in e.PublishedEntities)
{
var properties = new PropertiesDictionary(item);
var publisher = Current.Services.UserService.GetUserById(item.PublisherId.GetValueOrDefault());
if (publisher != null)
{
properties.Add("publisher", publisher.Name);
}
AsyncUtil.RunSync(() => _messagingService.SendMessageAsync("contentService", "published", properties, publisher));
}
}
private void ContentService_Published(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.ContentPublishedEventArgs e)
{
var Content = e.PublishedEntities.First();
if (Content.ContentType.Alias == "categoria")
{
var excel = Content.Properties["importarExcel"].GetValue();
if (excel != null)
{
var Excel = Path.Combine("http://localhost:65295" + excel.ToString());
var client = new WebClient();
var fullPath = Path.GetTempFileName();
client.DownloadFile(Excel, fullPath);
ObtenerEstudiantesMeritorios(fullPath, Content, e);
}
}
}
private void ContentService_Published(Umbraco.Core.Services.IContentService sender, ContentPublishedEventArgs contentPublishedEventArgs)
{
foreach (var node in contentPublishedEventArgs.PublishedEntities)
{
if (node.ContentType.Alias != Theme.ModelTypeAlias)
{
continue;
}
var result = _sassService.BuildSass(node.Id);
contentPublishedEventArgs.Messages.Add(result == string.Empty
? new EventMessage("Sass File Built", result,
EventMessageType.Info)
: new EventMessage("Sass Build Error", result,
EventMessageType.Error));
}
}
public void ContentService_Saving(Umbraco.Core.Services.IContentService sender, SaveEventArgs <IContent> e)
{
List <EventType> eventTypes = _dataTypeProvider.GetEventTypes();
foreach (IContent entity in e.SavedEntities)
{
if (entity.ContentType.Alias == "event")
{
IPublishedContent eventPageContent = entity.ToPublishedContent();
var eventPage = new Event(eventPageContent);
if (eventPage.Id == 0)
{
//No need to check this as must be creating a new event page
continue;
}
var eventType = eventTypes.SingleOrDefault(et => et.Name == eventPage.EventType);
if (eventType == null)
{
//Log and move on
_logger.Warn(typeof(ContentEventHandler), $"No event type found for name '{eventPage.EventType}'.");
continue;
}
var eventDates = GetEventDates(eventPage, true);
List <EventSlot> existingEventSlots = _eventSlotRepository.GetAll(true, eventTypes, null, null).ToList();
existingEventSlots = existingEventSlots.Where(es => es.EventTypeId == eventType.Id && es.EventPageId == eventPage.Id).ToList();
if (existingEventSlots.Any(es => eventDates.Contains(es.Date) == false && es.EventParticipants.Count > 0))
{
string message = $"Unable to save changes - existing bookings for event slots of type {eventType.Name}, please cancel the bookings through the Event Booking Admin page first.";
_logger.Warn(typeof(ContentEventHandler), message);
//If any slots are no longer needed and have participants then cancel saving with message
e.Messages.Add(new EventMessage("Error", message, EventMessageType.Error));
e.Cancel = true;
return;
}
}
}
}
private void ContentService_Trashing(Umbraco.Core.Services.IContentService sender, MoveEventArgs <Umbraco.Core.Models.IContent> e)
{
var allowDeleteAlias = "AllowDelete";
foreach (var content in e.MoveInfoCollection)
{
// hasn't got the allow delete property
if (!content.Entity.HasProperty(allowDeleteAlias))
{
continue;
}
var allowDelete = content.Entity.GetValue <bool>(allowDeleteAlias);
if (allowDelete)
{
continue;
}
_logger.Error(GetType(), $"Deletion of ({content.Entity.Name}) has been blocked.");
e.Cancel = true;
e.Messages.Add(new EventMessage("Deletion of this item has been blocked", "This item is important to the successful operation of this website.<br>If you would still like to delete this item, please uncheck the 'Disable Delete' field on the 'Delete' tab.", EventMessageType.Warning));
}
}
public void ContentService_Deleting(Umbraco.Core.Services.IContentService sender, DeleteEventArgs <Umbraco.Core.Models.IContent> e)
{
List <EventType> eventTypes = _dataTypeProvider.GetEventTypes();
/*
* - Check if any slots should be removed
* - If slots have participants then cancel deleting with message
* - If slots are empty then remove the slots
*/
foreach (IContent entity in e.DeletedEntities)
{
if (entity.ContentType.Alias == "event")
{
IPublishedContent eventPageContent = entity.ToPublishedContent();
var eventPage = new Event(eventPageContent);
List <EventSlot> existingEventSlots = _eventSlotRepository.GetAll(true, eventTypes, null, null).Where(es => es.EventPageId == eventPage.Id).ToList();
if (existingEventSlots.Any(es => es.EventParticipants.Count > 0))
{
string message = $"Unable to delete event page - existing bookings for event slots of type {eventPage.EventType}, please cancel the bookings through the Event Booking Admin page first.";
_logger.Warn(typeof(ContentEventHandler), message);
//If any future slots have participants then cancel deleting with message
e.Messages.Add(new EventMessage("Error", message, EventMessageType.Error));
e.Cancel = true;
return;
}
//Remove future event slots
foreach (var slot in existingEventSlots)
{
_eventSlotRepository.Delete(slot.Id);
}
_logger.Info(typeof(ContentEventHandler),
$"Deleted {existingEventSlots.Count} event slots for page {eventPage.Name}, event type '{eventPage.EventType}'.");
}
}
}
private void ContentService_Saving(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.SaveEventArgs <Umbraco.Core.Models.IContent> e)
{
if (UmbracoContext.Current?.IsFrontEndUmbracoRequest ?? true)
{
return;
}
foreach (var entity in e.SavedEntities)
{
if (entity.HasProperty(Alias.BodyText))
{
// replace markdown image by figure tag, using data-src for lazy loading
const string img = "<figure><img alt='$1' data-src='$2' src='data:image/gif;base64,R0lGODdhAQABAPAAAMPDwwAAACwAAAAAAQABAAACAkQBADs='><figcaption>$1</figcaption></figure>";
const string pattern = @"!\[(.*)\]\((.*)\)"; // 
var body = entity.GetValue <string>(Alias.BodyText);
if (string.IsNullOrWhiteSpace(body) == false && Regex.IsMatch(body, pattern))
{
var replacement = Regex.Replace(body, pattern, img, RegexOptions.Multiline);
entity.SetValue(Alias.BodyText, replacement);
}
}
}
}
private void ContentService_Unpublished(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.PublishEventArgs <IContent> e) => RemoveIndexEntries(e.PublishedEntities);
private void ContentService_Deleted(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.DeleteEventArgs <IContent> e) => RemoveIndexEntries(e.DeletedEntities);
public void ContentService_SentToPublish(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.SendToPublishEventArgs <Umbraco.Core.Models.IContent> e)
{
var properties = new PropertiesDictionary(e.Entity);
AsyncUtil.RunSync(() => _messagingService.SendMessageAsync("contentService", "sentToPublish", properties));
}
public void ContentService_RolledBack(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.RollbackEventArgs <Umbraco.Core.Models.IContent> e)
{
var properties = new PropertiesDictionary(e.Entity);
AsyncUtil.RunSync(() => _messagingService.SendMessageAsync("contentService", "rolledBack", properties));
}
public async Task <HttpResponseMessage> SaveData()
{
Umbraco.Core.Services.IContentService _contentService = ApplicationContext.Current.Services.ContentService;
UmbracoHelper umbracoHelper = new UmbracoHelper(UmbracoContext.Current);
var httpCurrentUser = HttpContext.Current.Request.Form.AllKeys.Count() > 0 ?
HttpContext.Current.Request.Form["CurrentUserId"] : "0";
var httpCurrentUserName = HttpContext.Current.Request.Form.AllKeys.Count() > 0 ?
HttpContext.Current.Request.Form["CurrentUserName"] : "******";
var httpPostedFile = HttpContext.Current.Request.Files["UploadedFile"];
if (httpPostedFile != null)
{
int lastPos = httpPostedFile.FileName.LastIndexOf('\\');
string[] fileName = httpPostedFile.FileName.Substring(++lastPos).Split(new char[] { '.' });
string name = fileName[0];
string extension = fileName[1];
if (extension != "xls" && extension != "xlsx")
{
log.Info(string.Format("The Provided File is not an xls file."));
return(Request.CreateResponse(HttpStatusCode.BadRequest,
"The Provided File is not an xls file.",
"application/json"));
}
// Get the complete file path
var fileSavePath = Path.Combine(HttpContext.Current.Server.MapPath("~/App_Data/UploadedFiles"), httpPostedFile.FileName);
// Save the uploaded file to "UploadedFiles" folder
if (!System.IO.File.Exists(fileSavePath))
{
httpPostedFile.SaveAs(fileSavePath);
}
FileStream stream = File.Open(fileSavePath, FileMode.Open, FileAccess.Read);
IExcelDataReader excelReader = ExcelReaderFactory.CreateBinaryReader(stream);
DataSet result = excelReader.AsDataSet();
excelReader.Close();
int row_no = 1;
//delete all old Company records
var deletedRecords = dbService.DeleteOldCompanyInvetoryItems();
if (deletedRecords == -1)
{
log.Info(string.Format("There is a problem deleting the records"));
}
else
{
log.Info(string.Format("The number of deleted records is {0}", deletedRecords));
}
var saveAuditImportReport = dbService.SaveCompanyInvetoryAuditItem(new CompanyInvetoryAudit
{
ImportedDate = DateTime.Now.ToString(),
UserId = int.Parse(httpCurrentUser),
UserName = httpCurrentUserName
});
var recordsCount = 0;
var allRecordsCount = 0;
if (saveAuditImportReport != -1)
{
while (row_no < result.Tables[0].Rows.Count)
{
#region date convertion
var _dateOfIncorporation = string.Empty;
if (!string.IsNullOrEmpty(result.Tables[0].Rows[row_no][6].ToString()))
{
double DateOfIncorporation;
if (double.TryParse(result.Tables[0].Rows[row_no][6].ToString(), out DateOfIncorporation))
{
_dateOfIncorporation = string.Format("{0}/{1}/{2}", DateTime.FromOADate(DateOfIncorporation).Day, DateTime.FromOADate(DateOfIncorporation).Month, DateTime.FromOADate(DateOfIncorporation).Year);
}
}
var _month = string.Empty;
if (!string.IsNullOrEmpty(result.Tables[0].Rows[row_no][7].ToString()))
{
double Month;
if (double.TryParse(result.Tables[0].Rows[row_no][7].ToString(), out Month))
{
_month = string.Format("{0}/{1}/{2}", DateTime.FromOADate(Month).Day, DateTime.FromOADate(Month).Month, DateTime.FromOADate(Month).Year);
}
}
var _potentialStrikeOffDate = string.Empty;
if (!string.IsNullOrEmpty(result.Tables[0].Rows[row_no][9].ToString()))
{
double PotentialStrikeOffDate;
if (double.TryParse(result.Tables[0].Rows[row_no][9].ToString(), out PotentialStrikeOffDate))
{
_potentialStrikeOffDate = string.Format("{0}/{1}/{2}", DateTime.FromOADate(PotentialStrikeOffDate).Day, DateTime.FromOADate(PotentialStrikeOffDate).Month, DateTime.FromOADate(PotentialStrikeOffDate).Year);
}
}
var _reservedDate = string.Empty;
if (!string.IsNullOrEmpty(result.Tables[0].Rows[row_no][10].ToString()))
{
double ReservedDate;
if (double.TryParse(result.Tables[0].Rows[row_no][10].ToString(), out ReservedDate))
{
_reservedDate = string.Format("{0}/{1}/{2}", DateTime.FromOADate(ReservedDate).Day, DateTime.FromOADate(ReservedDate).Month, DateTime.FromOADate(ReservedDate).Year);
}
}
var _soldDate = string.Empty;
if (!string.IsNullOrEmpty(result.Tables[0].Rows[row_no][12].ToString()))
{
double SoldDate;
if (double.TryParse(result.Tables[0].Rows[row_no][12].ToString(), out SoldDate))
{
_soldDate = string.Format("{0}/{1}/{2}", DateTime.FromOADate(SoldDate).Day, DateTime.FromOADate(SoldDate).Month, DateTime.FromOADate(SoldDate).Year);
}
}
var _companyStruckOffDate = string.Empty;
if (!string.IsNullOrEmpty(result.Tables[0].Rows[row_no][14].ToString()))
{
double CompanyStruckOffDate;
if (double.TryParse(result.Tables[0].Rows[row_no][14].ToString(), out CompanyStruckOffDate))
{
_companyStruckOffDate = string.Format("{0}/{1}/{2}", DateTime.FromOADate(CompanyStruckOffDate).Day, DateTime.FromOADate(CompanyStruckOffDate).Month, DateTime.FromOADate(CompanyStruckOffDate).Year);
}
}
#endregion date convertion
var inventoryItem = new CompanyInventory();
inventoryItem.CompanyClient = result.Tables[0].Rows[row_no][0].ToString();
inventoryItem.CompanyName = result.Tables[0].Rows[row_no][1].ToString();
inventoryItem.IsOn = result.Tables[0].Rows[row_no][2].ToString();
inventoryItem.BC = result.Tables[0].Rows[row_no][3].ToString();
inventoryItem.Availability = result.Tables[0].Rows[row_no][4].ToString();
inventoryItem.CorporationStatus = result.Tables[0].Rows[row_no][5].ToString();
inventoryItem.DateOfIncorporation = _dateOfIncorporation;
inventoryItem.Month = _month;
inventoryItem.FirstOrSecondHalf = !string.IsNullOrEmpty(result.Tables[0].Rows[row_no][8].ToString()) ? int.Parse(result.Tables[0].Rows[row_no][8].ToString()) : 1;
inventoryItem.PotentialStrikeOffDate = _potentialStrikeOffDate;
inventoryItem.ReservedDate = _reservedDate;
inventoryItem.ReservedBy = result.Tables[0].Rows[row_no][11].ToString();
inventoryItem.SoldDate = _soldDate;
inventoryItem.SoldBy = result.Tables[0].Rows[row_no][13].ToString();
inventoryItem.CompanyStruckOffDate = _companyStruckOffDate;
inventoryItem.Note = result.Tables[0].Rows[row_no][15].ToString();
inventoryItem.AuditId = saveAuditImportReport;
var saveShelfCompany = -1;
try
{
saveShelfCompany = dbService.SaveInventoryItem(inventoryItem);
}
catch (Exception ex)
{
log.Info(ex.Message);
}
recordsCount++;
allRecordsCount++;
if (saveShelfCompany == -1)
{
log.Info(string.Format("The Company {0} was not added to the DB", inventoryItem.CompanyName));
recordsCount--;
}
row_no++;
}
var updateAuditWithRecordsCount = dbService.UpdateCompanyInvetoryAuditItem(saveAuditImportReport, recordsCount);
if (!updateAuditWithRecordsCount)
{
log.Info(string.Format("The Audit with Id={0} was not updated with the Company records count.", saveAuditImportReport));
}
}
else
{
log.Info(string.Format("The Audit table was not updated with the information with the upload"));
}
log.Info(string.Format("Company Record imported {1}, Total Company Records {0}", allRecordsCount, recordsCount));
//close the file after all is read
stream.Close();
return(Request.CreateResponse(HttpStatusCode.OK,
string.Format("Successfully uploaded {0} records from {1} rows!", recordsCount, allRecordsCount),
"application/json"));
}
else
{
log.Info(string.Format("No File was posted!"));
return(Request.CreateResponse(HttpStatusCode.NotFound,
"There is no file posted!",
"application/json"));
}
}
