public ActionResult Create(ContentViewModel contentViewModel)
{
if (ModelState.IsValid)
{
_contentService.CreateContent(contentViewModel);
}
return(View());
}
/// <summary>
/// Updates or adds the content item. If content item already exists, it updates it.
/// If content item doesn't exists, it creates new content item (in that case contentItem.Id will be set to newly created id).
/// NOTE: Set the ParentId property of this item.
/// </summary>
/// <param name="contentItem">Content item to update/add</param>
/// <param name="userId">User used for add or updating the content</param>
/// <param name="publish">If set to <c>true</c> it contentItem will be published as well.</param>
public static void Save(DocumentTypeBase contentItem, int userId, bool publish)
{
if (contentItem.ParentId < 1)
{
throw new ArgumentException("Parent property cannot be null");
}
if (String.IsNullOrEmpty(contentItem.Name))
{
throw new Exception("Name property of this content item is not set");
}
IContentType contentType = DocumentTypeManager.GetDocumentType(contentItem.GetType());
IContent content;
if (contentItem.Id == 0) // content item is new so create Document
{
content = ContentService.CreateContent(contentItem.Name, contentItem.ParentId, contentType.Alias);
}
else // content item already exists, so load it
{
content = ContentService.GetById(contentItem.Id);
}
var documentTypeProperties = contentItem.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
SaveProperties(contentItem, contentType, content, documentTypeProperties);
if (publish)
{
ContentService.SaveAndPublish(content, userId);
contentItem.Id = content.Id;
}
}
public ActionResult Create(string Groups, int Type, string Name, string Description, IEnumerable <HttpPostedFileBase> Files, DateTime BeginDate, DateTime EndDate, bool IsBroadcast = false, HttpPostedFileBase imageFile = null)
{
try
{
var IdsGroup = GetIdsFromString(Groups);
var FilesDTO = GetFiles(Files);
HttpFileStream imageFileStream = null;
if (imageFile != null)
{
imageFileStream = new HttpFileStream()
{
InputStream = imageFile.InputStream,
Name = imageFile.FileName
};
}
ContentService.CreateContent(IdsGroup, null, Type, Name, Description, FilesDTO, BeginDate, EndDate, IsBroadcast, imageFileStream);
InternalNotification.Success("Material Created");
}
catch (Exception ex)
{
InternalNotification.Error(ex);
}
return(RedirectToAction("index"));
}
private int CreateContent(string template, XElement webNode, int parentId)
{
string title = webNode.Element("Label").Value;
string esdId = webNode.Element("Identifier").Value;
var node = _contentService.CreateContent(title, parentId, template);
if (node != null)
{
if (node.HasProperty("title"))
{
node.SetValue("title", title);
}
if (node.HasProperty("esdServiceId"))
{
node.SetValue("esdServiceId", esdId);
}
if (node.HasProperty("sectionName"))
{
node.SetValue("sectionName", title);
}
_contentService.SaveAndPublishWithStatus(node, 0, false);
_nodeCount++;
return(node.Id);
}
_lastError = "Error Creating Content";
return(-1);
}
public HttpResponseMessage Post([FromBody] SeasonPass Data)
{
JsonResponse Response = new JsonResponse(true, new SecureContext());
Response.Create();
if (Response.IsAuthentic == true)
{
IContentService Service = Services.ContentService;
var Pass = Service.CreateContent(EncDecService.Hash(Data.ID), 1121, "seasonPass");
Pass.SetValue("passID", EncDecService.Hash(Data.ID));
Pass.SetValue("holderName", EncDecService.Encrypt(Data.Holder));
Pass.SetValue("validFrom", Convert.ToDateTime(Data.ValidFrom));
Pass.SetValue("validTo", Convert.ToDateTime(Data.ValidTo));
Pass.SetValue("acquiredOn", Convert.ToDateTime(Data.AcquiredOn));
string ResponseMessage;
if (Service.SaveAndPublishWithStatus(Pass))
{
ResponseMessage = "The content has been successfully saved.";
}
else
{
ResponseMessage = "An error occured while saving the season pass.";
}
Response.Set(new StringContent(ResponseMessage, ApiContext.GetEncoding(), "text/plain"));
}
return(Response.Get());
}
public bool CreateLog(Form formModel)
{
bool result = false;
if (formModel.IsSaveLog)
{
var formContent = contentService.GetById(formModel.Id);
var logCollection = formContent.Children().Where(c => c.ContentType.Alias == NodeAlias.LogCollection).FirstOrDefault();
var logName = DateTime.Now.ToString("yyyy-MM-dd - hh:mm:ss tt");
if (formModel.LogName != null)
{
var logNameQuery = formModel.Fields.Where(f => f.Id == formModel.LogName.Id).FirstOrDefault();
if (logNameQuery != null)
{
if (!string.IsNullOrEmpty(logNameQuery.Value))
{
logName = string.Format("{0} [{1}]", logName, logNameQuery.Value);
}
}
}
if (logCollection != null)
{
IContent logNode = contentService.CreateContent(logName, logCollection, NodeAlias.Log, 0);
if (logNode.HasProperty(PropertyAlias.LogDetail))
{
string logDetail = GetLogDetail(formModel);
logNode.SetValue(PropertyAlias.LogDetail, logDetail);
}
result = contentService.SaveAndPublishWithStatus(logNode);
}
}
return(result);
}
public void SyncDataVnexpress()
{
IContentService contentService = Services.ContentService;
var parent = contentService.GetById(1166);
var news = CrawlerHtml();
var pageNewsInDb = Umbraco.Content(1166).Children.ToList();
try
{
foreach (var item in news)
{
var anyNew = pageNewsInDb.Where(x => x.GetProperty("title").Value().Equals(item.Title))?.ToList();
if (anyNew.Count <= 0)
{
var message = contentService.CreateContent($"{item.Title}-{DateTime.Now}", parent.GetUdi(), "new");
message.SetValue("title", item.Title);
message.SetValue("description", item.Description);
message.SetValue("content", item.Content);
message.SetValue("image", item.LinkImage);
Services.ContentService.SaveAndPublish(message);
}
}
}
catch (Exception ex)
{
}
}
public IHttpActionResult CommitVote([FromBody] Vote data)
{
try
{
//validate vote
bool validates = ValidateVote(data.IMEI, data.MatchId, data.PlayerId);
if (validates)
{
string message = "m:" + data.MatchId.ToString() + ", p:" + data.PlayerId.ToString() + ", IMEI: " + data.IMEI.ToString();
//create vote object
var vote = cs.CreateContent(message, data.VoteBatchId, "vote");
//set vote properties
vote.Properties["IMEI"].Value = data.IMEI;
vote.Properties["matchId"].Value = data.MatchId;
vote.Properties["playerId"].Value = data.PlayerId;
cs.Publish(vote);
cs.Save(vote);
return(StatusCode(HttpStatusCode.Created));
}
if (!validates)
{
return(StatusCode(HttpStatusCode.Conflict));
}
}
catch (Exception e)
{
Console.Write(e.Message);
}
return(StatusCode(HttpStatusCode.BadRequest));
}
private int?CreateContent(Item item, int parentId, int userId = 0)
{
var contentTypes = _contentTypeService.GetAllContentTypeAliases();
var contentType = contentTypes.FirstOrDefault(x => item.NodeType.Ref.Replace(" ", "").ToLower().Contains(x.ToLower()));
var content = _contentService.CreateContent(item.Name, parentId, contentType, userId);
return(content.Id);
}
/// <summary>
/// Add a simple content tree to the install
/// </summary>
public static IContent Node(IContentService contentService, int parentId = -1, string typeAlias = "textpage")
{
IContent node = contentService.CreateContent(Utility.RandomString(), parentId, typeAlias);
contentService.SaveAndPublishWithStatus(node);
return(node);
}
/// <summary>
/// Get the correct parent node for a news item
/// It will create if it needs to
/// </summary>
private int GetParentNodeForNewsItem(IContentService contentService, IContent blogPostsFolder, DateTime date)
{
int parentID;
//Create year folder if not present
if (blogPostsFolder.Children().Where(x => x.GetValue <int>("year") == date.Year).Count() != 1)
{
var yearFolder = contentService.CreateContent(date.Year.ToString(), blogPostsFolder.Id, "USNBlogYearFolder");
yearFolder.SetValue("year", date.Year.ToString());
contentService.SaveAndPublishWithStatus(yearFolder);
//Create month folder if not present
if (yearFolder.Children().Where(x => x.GetValue <int>("month") == date.Month).Count() != 1)
{
var monthFolder = contentService.CreateContent(date.ToString("MMMM", CultureInfo.CreateSpecificCulture("en")), yearFolder.Id, "USNBlogMonthFolder");
monthFolder.SetValue("month", date.Month.ToString());
contentService.SaveAndPublishWithStatus(monthFolder);
parentID = monthFolder.Id;
}
else
{
var monthFolder = yearFolder.Children().Where(x => x.GetValue <int>("month") == date.Month).First();
parentID = monthFolder.Id;
}
}
else
{
var yearFolder = blogPostsFolder.Children().Where(x => x.GetValue <int>("year") == date.Year).First();
if (yearFolder.Children().Where(x => x.GetValue <int>("month") == date.Month).Count() != 1)
{
var monthFolder = contentService.CreateContent(date.ToString("MMMM", CultureInfo.CreateSpecificCulture("en")), yearFolder.Id, "USNBlogMonthFolder");
monthFolder.SetValue("disableDelete", 1);
monthFolder.SetValue("month", date.Month.ToString());
contentService.SaveAndPublishWithStatus(monthFolder);
parentID = monthFolder.Id;
}
else
{
var monthFolder = yearFolder.Children().Where(x => x.GetValue <int>("month") == date.Month).First();
parentID = monthFolder.Id;
}
}
return(parentID);
}
internal static IContent GetOrCreateContent(IContentType contentType, string contentName, IContentTypeService contentTypeService, IContentService contentService, IContent parentContent, List <IContent> contentList)
{
var content = contentService.GetContentOfContentType(contentType.Id).FirstOrDefault(x => !x.Trashed);
if (content == null)
{
if (parentContent == null)
{
content = contentService.CreateContent(contentName, -1, contentType.Alias);
}
else
{
content = contentService.CreateContent(contentName, parentContent, contentType.Alias);
}
contentList.Add(content);
}
return(content);
}
private IContent CreatePageComponentsFolder(IContent node, bool returnNode)
{
var filter = _sqlContent.Query <IContent>().Where(x => x.Name == "Components");
long totalChildren;
var pageComponentsNode = _contentService.GetPagedChildren(node.Id, 0, 1, out totalChildren, filter: filter).FirstOrDefault();
if (pageComponentsNode == null)
{
var pageComponentsNodeNew = _contentService.CreateContent("Components", node.GetUdi(), USNConstants.PageComponentsFolderAlias);
pageComponentsNodeNew.SetValue(USNConstants.GeneralDisableDeleteFieldAlias, true);
return(pageComponentsNodeNew);
}
else
{
return(returnNode ? pageComponentsNode : null);
}
}
private void CreateVideo(GuidUdi parentUdi, string title, string thumbnailUrl, string videoUrl)
{
var video = _contentService.CreateContent(title, parentUdi, "video");
video.SetValue("title", title);
video.SetValue("videoThumbnailImageURL", thumbnailUrl);
video.SetValue("videoLinkURL", videoUrl);
_contentService.SaveAndPublish(video);
}
private void CreatePage()
{
var groupsOverviewPage = _umbracoHelper.TypedContentSingleAtXPath(XPathHelper.GetXpath(DocumentTypeAliasConstants.HomePage, DocumentTypeAliasConstants.GroupsOverviewPage));
var content = _contentService.CreateContent("My Groups", groupsOverviewPage.Id, DocumentTypeAliasConstants.GroupsMyGroupsOverviewPage);
content.SetValue(NavigationPropertiesConstants.NavigationNamePropName, "My Groups");
content.SetValue(NavigationPropertiesConstants.IsHideFromLeftNavigationPropName, false);
content.SetValue(NavigationPropertiesConstants.IsHideFromSubNavigationPropName, false);
_contentMigration.SetGridValueAndSaveAndPublishContent(content, "groupsMyGroupsOverviewPageGrid.json");
}
/// <summary>
/// Method to create an IContent object based on the Udi of a parent
/// </summary>
/// <param name="contentService"></param>
/// <param name="name"></param>
/// <param name="parentId"></param>
/// <param name="mediaTypeAlias"></param>
/// <param name="userId"></param>
/// <returns></returns>
public static IContent CreateContent(this IContentService contentService, string name, Udi parentId, string mediaTypeAlias, int userId = 0)
{
var guidUdi = parentId as GuidUdi;
if (guidUdi == null)
{
throw new InvalidOperationException("The UDI provided isn't of type " + typeof(GuidUdi) + " which is required by content");
}
var parent = contentService.GetById(guidUdi.Guid);
return(contentService.CreateContent(name, parent, mediaTypeAlias, userId));
}
public PlayerViewModel AddNewPlayer(PlayerViewModel newPlayer)
{
int nodeID = 2077;
//get node info to add in
var playersNodeName = Umbraco.Content(nodeID).Name;
var playersNodeGuid = Umbraco.Content(nodeID).Key;
GuidUdi currentPageUdi = new GuidUdi(playersNodeName, playersNodeGuid);
//create content node
var data = _contentService.CreateContent(playersNodeName, currentPageUdi, UmbracoAliasConfiguration.Player.Alias, 0);
//define properties
data.Name = newPlayer.Name;
data.SetValue(UmbracoAliasConfiguration.Player.PlayerName, newPlayer.Name);
data.SetValue(UmbracoAliasConfiguration.Player.PlayerAge, newPlayer.Age);
_contentService.SaveAndPublish(data);
return(newPlayer);
}
public async Task <string> CreateContent([FromBody] ContentModel model)
{
try
{
return(await contentService.CreateContent(model));
}
catch (Exception ex)
{
logger.LogError(ex, "Cannot set content");
throw;
}
}
public ActionResult Create(Content _content)
{
try
{
_ContentService.CreateContent(_content);
return(RedirectToAction("Index2"));
}
catch
{
return(View("Index"));
}
}
public int GetItemTypeFolderId(int libraryFolderId, string itemTypeFolderDoctypeAlias, string selectedTypeName)
{
var libraryFolder = _contentService.GetById(libraryFolderId);
IContent itemTypeFolder = null;
string itemTypeFolderDoctypeName;
if (selectedTypeName.Contains(' '))
{
var words = selectedTypeName.Split(' ');
var pluralisedLastWord = _pluralizationServiceWrapper.Pluralize(_variationContextAccessor.VariationContext.Culture, words.Last());
itemTypeFolderDoctypeName = $"{string.Join(" ", words.Take(words.Length - 1))} {pluralisedLastWord}";
}
else
{
itemTypeFolderDoctypeName = _pluralizationServiceWrapper.Pluralize(_variationContextAccessor.VariationContext.Culture, selectedTypeName);
}
var pageIndex = 0;
const int pageSize = 100;
var children = _pagingHelper.GetPagedChildren(_contentService, libraryFolder.Id, pageIndex, pageSize, out var totalRecords);
var hasNextPage = _pagingHelper.HasNextPage(pageIndex, pageSize, totalRecords);
while (hasNextPage)
{
itemTypeFolder = children.SingleOrDefault(x => x.Name == itemTypeFolderDoctypeName);
if (itemTypeFolder != null)
{
break;
}
pageIndex++;
children = _pagingHelper.GetPagedChildren(_contentService, libraryFolder.Id, pageIndex, pageSize, out totalRecords);
hasNextPage = _pagingHelper.HasNextPage(pageIndex, pageSize, totalRecords);
}
if (itemTypeFolder == null)
{
itemTypeFolder = _contentService.CreateContent(itemTypeFolderDoctypeName, libraryFolder.GetUdi(), itemTypeFolderDoctypeAlias);
var publish = _contentService.SaveAndPublish(itemTypeFolder);
if (publish.Result != PublishResultType.SuccessPublish)
{
throw new Exception($"Creating the 'Bento Block Type Folder' named '{itemTypeFolderDoctypeName}s' failed");
}
}
return(itemTypeFolder.Id);
}
public ActionResult SubmitComment(int idProject, string userComment, string contentComment, string typeSubmit = "main-submit",
int idMainPage = 0)
{
IContentService contentService = Services.ContentService;
try
{
if (typeSubmit == "main-submit")
{
var parent = contentService.GetById(idProject);
var comment = contentService.CreateContent($"{userComment}-{DateTime.Now}", parent.GetUdi(), "comment");
comment.SetValue("nameComment", userComment);
comment.SetValue("time", DateTime.Now);
comment.SetValue("idComment", Guid.NewGuid());
comment.SetValue("commentContent", contentComment);
Services.ContentService.SaveAndPublish(comment);
}
else
{
var parent = contentService.GetById(idProject);
var comment = contentService.CreateContent($"{userComment}-{DateTime.Now}", parent.GetUdi(), "replyComment");
comment.SetValue("nameUserReply", userComment);
comment.SetValue("timeReply", DateTime.Now);
comment.SetValue("iDReplyComment", Guid.NewGuid());
comment.SetValue("contentReply", contentComment);
Services.ContentService.SaveAndPublish(comment);
return(RedirectToUmbracoPage(idMainPage));
}
}
catch (Exception)
{
TempData["error-message"] = "Submit Failed !";
}
return(RedirectToUmbracoPage(idProject));
}
public void SendNotiIntoUmbra(ContactModel contactModel)
{
IContentService contentService = Services.ContentService;
var parent = contentService.GetById(1098);
var message = contentService.CreateContent($"{contactModel.Name}-{DateTime.Now}", parent.GetUdi(), "contactContent");
message.SetValue("nameUser", contactModel.Name);
message.SetValue("email", contactModel.Email);
message.SetValue("phoneNumber", contactModel.PhoneNumber);
message.SetValue("message", contactModel.Message);
Services.ContentService.SaveAndPublish(message);
}
private void CreateForbiddenErrorPage()
{
var homePage = _umbracoHelper.TypedContentAtRoot().Single(el => el.DocumentTypeAlias.Equals(DocumentTypeAliasConstants.HomePage));
var errorPages = homePage.Children.Where(el => el.DocumentTypeAlias.Equals(DocumentTypeAliasConstants.ErrorPage));
if (errorPages.Any(ep => ep.Name == ForbiddenPageName))
{
return;
}
var content = _contentService.CreateContent(ForbiddenPageName, homePage.Id, DocumentTypeAliasConstants.ErrorPage);
SetGridValueAndSaveAndPublishContent(content, "forbiddenPageGrid.json");
}
public IEnumerable <int> GetAndEnsureNodeIdsForTags(string currentNodeId, string tags, int containerId, string documentTypeAlias)
{
if (string.IsNullOrWhiteSpace(tags))
{
return(new List <int>());
}
// put posted tags in an array
string[] postedTags = tags.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
// get the current node
IContent node = cs.GetById(int.Parse(currentNodeId));
// get all existing tag nodes in container
IContent tagContainer = cs.GetById(containerId);
IEnumerable <IContent> allTagNodes = tagContainer.Children().Where(x => x.ContentType.Alias == documentTypeAlias);
bool hasNewTags = false;
foreach (string postedTag in postedTags)
{
// get tag names which do not already exist in the tag container
bool found = allTagNodes.Any(x => x.Name == postedTag);
if (!found)
{
// tag node doesnt exist so create new node
var dic = new Dictionary <string, object>()
{
{ documentTypeAlias, postedTag }
};
IContent newTag = cs.CreateContent(postedTag, tagContainer.Id, documentTypeAlias);
cs.SaveAndPublishWithStatus(newTag);
hasNewTags = true;
}
}
// re-get container because new nodes might have been added.
tagContainer = cs.GetById(containerId);
if (hasNewTags)
{
// new tag so sort!
cs.Sort(tagContainer.Children().OrderBy(x => x.Name));
}
// get all tag ids, and return
IEnumerable <int> tagIds = tagContainer.Children().Where(x => postedTags.Contains(x.Name)).Select(x => x.Id);
return(tagIds);
}
public async Task <JsonResult> New(ContentInputViewModel contentInputViewModel, string id)
{
if (CurrentUserId == 0)
{
await TryAuthenticateFromHttpContext(_communityService, _notificationService);
}
if (ModelState.IsValid)
{
var contentDetails = new ContentDetails();
contentDetails.SetValuesFrom(contentInputViewModel);
contentDetails.CreatedByID = CurrentUserId;
contentInputViewModel.ID = contentDetails.ID = _contentService.CreateContent(contentDetails);
}
return(new JsonResult {
Data = contentInputViewModel
});
}
public void SyncDataVnexpress()
{
IContentService contentService = Services.ContentService;
var parent = contentService.GetById(1166);
var news = CrawlerHtml();
foreach (var item in news)
{
var message = contentService.CreateContent($"{item.Title}-{DateTime.Now}", parent.GetUdi(), "new");
message.SetValue("title", item.Title);
message.SetValue("description", item.Description);
message.SetValue("content", item.Content);
message.SetValue("image", item.LinkImage);
Services.ContentService.SaveAndPublish(message);
}
}
private static int CreateCategoryNode(UCategory uCategory, int contentNodeParentId)
{
// create new content
var content = _cs.CreateContent(uCategory.Name, contentNodeParentId, "ProductListing");
// set content properties based on data from Able
content.SetValue("headline", uCategory.Title);
content.SetValue("metaDescription", uCategory.MetaDescription);
content.SetValue("metaKeywords", uCategory.MetaKeywords);
content.SetValue("pageTitle", uCategory.Title);
content.SetValue("bodyText", uCategory.Description);
content.SetValue("summary", uCategory.Summary);
// publish content so we can get nodeId
_cs.Publish(content);
return(content.Id);
}
public static void MakeProduct(UProduct prod, int contentNodeParentId, Guid merchelloGuid)
{
// create new content
var content = _cs.CreateContent(prod.Name.Trim(), contentNodeParentId, "Product");
// set content properties based on data from Able
content.SetValue("headline", prod.Name);
content.SetValue("metaDescription", prod.MetaDescription);
content.SetValue("metaKeywords", prod.MetaKeywords);
content.SetValue("pageTitle", prod.Name);
content.SetValue("bodyText", prod.Description);
content.SetValue("brief", prod.Summary);
// Establish link to merchello product
content.SetValue("product", merchelloGuid.ToString());
// publish content so we can get nodeId
_cs.Publish(content);
// pull in images if we have some
if (prod.Images.Count > 0)
{
// make media objects for each product image
List <string> mediaIds = new List <string>();
foreach (string imageUrl in prod.Images)
{
// make media and get ID
if (!string.IsNullOrEmpty(imageUrl))
{
string mediaNodeId = MakeMediaNode(content, imageUrl, prod.Name);
if (!string.IsNullOrEmpty(mediaNodeId))
{
mediaIds.Add(mediaNodeId);
}
}
}
// save all images to the media picker property value
string idList = string.Join(",", mediaIds.ToArray());
content.SetValue("images", idList);
_cs.Save(content);
}
}
/// <summary>
/// Private method to create new content
/// </summary>
/// <param name="contentService"></param>
/// <param name="contentTypeService"></param>
private static void CreateNewContent(IContentService contentService, IContentTypeService contentTypeService)
{
//We find all ContentTypes so we can show a nice list of everything that is available
var contentTypes = contentTypeService.GetAllContentTypes();
var contentTypeAliases = string.Join(", ", contentTypes.Select(x => x.Alias));
Console.WriteLine("Please enter the Alias of the ContentType ({0}):", contentTypeAliases);
var contentTypeAlias = Console.ReadLine();
Console.WriteLine("Please enter the Id of the Parent:");
var strParentId = Console.ReadLine();
int parentId;
if (int.TryParse(strParentId, out parentId) == false)
{
parentId = -1;//Default to -1 which is the root
}
Console.WriteLine("Please enter the name of the Content to create:");
var name = Console.ReadLine();
//Create the Content
var content = contentService.CreateContent(name, parentId, contentTypeAlias);
foreach (var property in content.Properties)
{
Console.WriteLine("Please enter the value for the Property with Alias '{0}':", property.Alias);
var value = Console.ReadLine();
var isValid = property.IsValid(value);
if (isValid)
{
property.Value = value;
}
else
{
Console.WriteLine("The entered value was not valid and thus not saved");
}
}
//Save the Content
contentService.Save(content);
Console.WriteLine("Content was saved: " + content.HasIdentity);
}
public ServiceResult CreateEvent(IPublishedContent chapter, int userId, string name, string location, DateTime date, string time, string imageUrl, string address,
string mapQuery, string description)
{
IPublishedContent eventsPage = chapter.GetPropertyValue <IPublishedContent>("eventsPage");
IContent @event = _contentService.CreateContent(name, eventsPage.Id, "event", userId);
@event.SetValue(EventPropertyNames.Location, location);
@event.SetValue(EventPropertyNames.Date, date);
if (!string.IsNullOrEmpty(time))
{
@event.SetValue(EventPropertyNames.Time, time);
}
if (!string.IsNullOrEmpty(imageUrl))
{
@event.SetValue(EventPropertyNames.ImageUrl, imageUrl);
}
if (!string.IsNullOrEmpty(address))
{
@event.SetValue(EventPropertyNames.Address, address);
}
if (!string.IsNullOrEmpty(mapQuery))
{
@event.SetValue(EventPropertyNames.MapQuery, mapQuery);
}
if (!string.IsNullOrEmpty(description))
{
@event.SetValue(EventPropertyNames.Description, description);
}
@event.SetValue(EventPropertyNames.Public, false);
_contentService.Publish(@event, userId);
return(new ServiceResult(true));
}
/// <summary>
/// Private method to create new content
/// </summary>
/// <param name="contentService"></param>
/// <param name="contentTypeService"></param>
private static void CreateNewContent(IContentService contentService, IContentTypeService contentTypeService)
{
//We find all ContentTypes so we can show a nice list of everything that is available
var contentTypes = contentTypeService.GetAllContentTypes();
var contentTypeAliases = string.Join(", ", contentTypes.Select(x => x.Alias));
Console.WriteLine("Please enter the Alias of the ContentType ({0}):", contentTypeAliases);
var contentTypeAlias = Console.ReadLine();
Console.WriteLine("Please enter the Id of the Parent:");
var strParentId = Console.ReadLine();
int parentId;
if (int.TryParse(strParentId, out parentId) == false)
parentId = -1;//Default to -1 which is the root
Console.WriteLine("Please enter the name of the Content to create:");
var name = Console.ReadLine();
//Create the Content
var content = contentService.CreateContent(name, parentId, contentTypeAlias);
foreach (var property in content.Properties)
{
Console.WriteLine("Please enter the value for the Property with Alias '{0}':", property.Alias);
var value = Console.ReadLine();
var isValid = property.IsValid(value);
if (isValid)
{
property.Value = value;
}
else
{
Console.WriteLine("The entered value was not valid and thus not saved");
}
}
//Save the Content
contentService.Save(content);
Console.WriteLine("Content was saved: " + content.HasIdentity);
}
private IContent CreateProductContent(IContentService contentService, IContent testCategory, string title, string sku, string price, int stock, string metaDescription, string description, bool useVariantStock, string introduction = null, string features = null)
{
var product = contentService.CreateContent(title, testCategory, Product.NodeAlias);
product.SetValue("title", title);
product.SetValue("url", title);
product.SetValue("sku", sku);
product.SetValue("price", price);
_stockService.SetStock(product.Id, stock, false, string.Empty);
product.SetValue("metaDescription", metaDescription);
product.SetValue("description", description);
if (useVariantStock)
{
product.SetValue("useVariantStock", true);
}
if (introduction != null)
{
if (product.HasProperty("introduction"))
{
product.SetValue("introduction", introduction);
}
}
if (features != null)
{
if (product.HasProperty("features"))
{
product.SetValue("features", features);
}
}
return product;
}
private IContent CreateVariantContent(IContentService contentService, IContent testProductVariantGroup, string color, string sku, string price, int stock, string variantName, bool enableBackorders = false)
{
var testProductVariant = contentService.CreateContent(variantName, testProductVariantGroup, ProductVariant.NodeAlias);
testProductVariant.SetValue("title", color);
testProductVariant.SetValue("sku", sku);
testProductVariant.SetValue("price", price);
testProductVariant.SetValue("backorderStatus", "disable");
_stockService.SubstractStock(testProductVariant.Id, stock, false, string.Empty);
if (enableBackorders)
{
testProductVariant.SetValue("backorderStatus", "enable");
}
return testProductVariant;
}
internal static IContent GetOrCreateContent(IContentType contentType, string contentName, IContentTypeService contentTypeService, IContentService contentService, IContent parentContent, List<IContent> contentList)
{
var content = contentService.GetContentOfContentType(contentType.Id).FirstOrDefault(x => !x.Trashed);
if (content == null)
{
if (parentContent == null)
{
content = contentService.CreateContent(contentName, -1, contentType.Alias);
}
else
{
content = contentService.CreateContent(contentName, parentContent, contentType.Alias);
}
contentList.Add(content);
}
return content;
}
private static IContent CreateVariantGroupContent(IContentService contentService, IContent testProduct, string variantGroup, bool requiredVariant)
{
var testProductVariantGroup = contentService.CreateContent(variantGroup, testProduct, ProductVariantGroup.NodeAlias);
testProductVariantGroup.SetValue("title", variantGroup);
if (requiredVariant)
{
testProductVariantGroup.SetValue("required", true);
}
return testProductVariantGroup;
}
