/// <summary>
/// Returns a dynamic representation of the provided content object.
/// </summary>
/// <returns></returns>
/// <remarks></remarks>
public static dynamic AsDynamic(this Content content)
{
Mandate.ParameterNotNull(content, "content");
return(content.Bend());
}
/// <summary>
/// Gets the parent of the current Content entity relationships
/// </summary>
/// <param name="collection"></param>
/// <returns></returns>
public static File ParentAsFile(this EntityRelationCollection collection)
{
Mandate.ParameterNotNull(collection, "collection");
return(collection.Parent <File>(FixedRelationTypes.FileRelationType));
}
/// <summary>
/// Gets the decendents or self of the current Content entity relationships
/// </summary>
/// <param name="collection"></param>
/// <returns></returns>
public static IEnumerable <File> DescendentsOrSelfAsFile(this EntityRelationCollection collection)
{
Mandate.ParameterNotNull(collection, "collection");
return(collection.DescendentsOrSelf <File>(FixedRelationTypes.FileRelationType));
}
/// <summary>
/// Returns a logger for the object's type
/// </summary>
/// <param name="getTypeFromInstance"></param>
/// <returns></returns>
public static ILog LoggerFor(object getTypeFromInstance)
{
Mandate.ParameterNotNull(getTypeFromInstance, "getTypeFromInstance");
return(LogManager.GetLogger(getTypeFromInstance.GetType()));
}
protected OrderCreationAttemptChainTaskBase(IInvoice invoice)
{
Mandate.ParameterNotNull(invoice, "invoice");
_invoice = invoice;
}
/// <summary>
/// Initializes a new instance of the <see cref="OfferRedemptionResultBase{TAward}"/> class for fail.
/// </summary>
/// <param name="exception">
/// The exception.
/// </param>
/// <param name="messages">
/// The messages.
/// </param>
protected OfferRedemptionResultBase(Exception exception, IEnumerable <string> messages = null)
{
Mandate.ParameterNotNull(exception, "exception");
Exception = exception;
Success = false;
}
/// <summary>
/// When editing or creating a document type, this binds the model, checks for errors, determines which
/// actions to take based on the button pressed, adds appropriate notifications and persists the data.
/// </summary>
/// <param name="model"></param>
/// <param name="entity"></param>
/// <returns></returns>
private ActionResult ProcessSubmit(TEditorModel model, EntitySchema entity, IGroupUnit <IContentStore> uow)
{
Mandate.ParameterNotNull(model, "model");
EnsureSelectListData(model);
//bind the model to the posted values
model.BindModel(this);
//process creating a new tab
ProcessCreatingTab(model);
//process deleting a tab
var tabToDelete = ProcessDeletingTab(model);
//process deleting property
var propToDelete = ProcessDeletingProperty(model);
//check if we are NOT adding a new property, if not then remove the invalid required validation
if (!model.IsCreatingNewProperty)
{
foreach (var m in ModelState.Where(x => x.Key.StartsWith("NewProperty")))
{
m.Value.Errors.Clear();
}
}
if (!ModelState.IsValid)
{
AddValidationErrorsNotification();
EnsureNoInBuiltProperties(model);
return(View("Edit", model));
}
//convert to persistence entity
if (entity == null)
{
//map to a new entity
entity = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <TEditorModel, EntitySchema>(model);
}
else
{
//map to existing
BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map(model, entity);
}
//if we're creating a new property, then add one
if (model.IsCreatingNewProperty)
{
//need to set the ordinal to the max sort order for the properties on the tab its being saved to
var defsOnGroup = entity.AttributeDefinitions.Where(x => x.AttributeGroup.Id == model.NewProperty.TabId).ToArray();
var maxOrdinal = defsOnGroup.Any() ? defsOnGroup.Max(x => x.Ordinal) : 0;
model.NewProperty.SortOrder = entity.AttributeDefinitions.Any()
? maxOrdinal + 1
: 0;
var propertyEntity = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <DocumentTypeProperty, AttributeDefinition>(model.NewProperty);
entity.AttributeDefinitions.Add(propertyEntity);
}
// Manage relations
EnsureInheritanceRelations(model, entity, uow);
//Save the entity
uow.Repositories.Schemas.AddOrUpdate(entity);
Notifications.Add(new NotificationMessage(
"DocumentType.Save.Message".Localize(this),
"DocumentType.Save.Title".Localize(this),
NotificationType.Success));
return(RedirectToAction("Edit", new { id = entity.Id }));
}
/// <summary>
/// Gets all the configuration settings matching <paramref name="sectionName"/> by first searching for all consumable configuration files contained in
/// <paramref name="absolutePluginRoot"/>. For every configuration found which has a matching section name, yields back the output specified in the provided
/// delegate <paramref name="deferred"/>.
/// </summary>
/// <example>
/// If you have a custom <see cref="ConfigurationSection"/> called <see cref="FoundationConfigurationSection"/>, you can ask for a specific setting like so:
/// <code>
/// var myValue = DeepConfigManager.Default.GetFirstWebSetting<FoundationConfigurationSection, string>("rebel.foundation", x => x.FoundationSettings.ApplicationTierAlias, "~/App_Plugins");
/// </code>
/// This will first scan the ~/App_Plugins folder recursively to find configuraiton settings called 'rebel.foundation' that are readable as <see cref="FoundationConfigurationSection"/>,
/// and for all those it finds (including the main app config) it will invoke the delegate provided in <paramref name="deferred"/>.
/// </example>
/// <typeparam name="TSection">The type of the section.</typeparam>
/// <typeparam name="TOut">The type outputted by the expression in <paramref name="deferred"/>.</typeparam>
/// <param name="sectionName">Name of the section in the configuration files.</param>
/// <param name="deferred">The deffered expression.</param>
/// <param name="applicationRoot">The application root path.</param>
/// <param name="absolutePluginRoot">The absolute plugin root path.</param>
/// <param name="pluginBasePath">The relative plugin root path.</param>
/// <returns></returns>
public IEnumerable <TOut> GetWebSettings <TSection, TOut>(string sectionName, Expression <Func <TSection, TOut> > deferred, string applicationRoot, string absolutePluginRoot, string pluginBasePath) where TSection : ConfigurationSection
{
Mandate.ParameterNotNullOrEmpty(sectionName, "sectionName");
Mandate.ParameterNotNull(deferred, "deferred");
Mandate.ParameterNotNullOrEmpty(applicationRoot, "applicationRoot");
Mandate.ParameterNotNullOrEmpty(absolutePluginRoot, "absolutePluginRoot");
Mandate.ParameterNotNullOrEmpty(pluginBasePath, "pluginBasePath");
Mandate.ParameterCondition(!Path.IsPathRooted(pluginBasePath), "pluginBasePath");
Mandate.ParameterCondition(Path.IsPathRooted(applicationRoot), "applicationRoot");
Mandate.ParameterCondition(Path.IsPathRooted(absolutePluginRoot), "absolutePluginRoot");
var accessorDelegate = deferred.Compile();
var isHosted = System.Web.Hosting.HostingEnvironment.IsHosted;
if (!isHosted)
{
LogHelper.Warn <DeepConfigManager>("DeepConfigManager is designed for web applications, outside of a web context all config elements must follow normal configuraiton rules");
}
foreach (var searchPath in GetSearchPaths(pluginBasePath, absolutePluginRoot))
{
TSection localSection = null;
try
{
if (isHosted)
{
localSection = WebConfigurationManager.GetSection(sectionName, searchPath) as TSection;
}
else
{
localSection = ConfigurationManager.GetSection(sectionName) as TSection;
}
}
catch (Exception e)
{
LogHelper.Error <DeepConfigManager>("Error parsing config section in path " + searchPath + ". This config is being skipped.", e);
continue;
}
// By default ASP.NET inherits settings down the config chain.
// Since this configuration is purely for overriding in the opposite direction, we specifically don't want to include settings that are
// inherited, since in this loop through sub-config locations we may later move to a setting file which contains a specific, genuine overriding value.
if (localSection != null
//this check is required! ... if there is say a 'task' section declared, this file will be found, but if there are not tasks then the 'source' will be null!!
//this fixes: U5-735
&& localSection.ElementInformation.Source != null &&
!IsRootConfig(searchPath, localSection.ElementInformation.Source, applicationRoot))
{
var val = GetConfigValue(deferred, accessorDelegate, localSection);
yield return(val);
}
}
// Finally add the app default to the enumerable at the end
var mainSection = WebConfigurationManager.GetSection(sectionName) as TSection;
if (mainSection != null)
{
yield return(accessorDelegate.Invoke(mainSection));
}
}
public DeepConfigManager(Func <string, string> mapPathDelegate)
{
Mandate.ParameterNotNull(mapPathDelegate, "mapPathDelegate");
_mapPathDelegate = mapPathDelegate;
}
/// <summary>
/// Serializes the provider config section and returns the XElement to which the operation was performed.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="section">The section.</param>
/// <param name="sectionPath">The section path.</param>
/// <param name="writeSectionDeclaration">if set to <c>true</c> [write section declaration].</param>
/// <returns></returns>
public static XElement SerializeProviderConfigSection(
XDocument config,
ConfigurationElement section,
string sectionPath,
bool writeSectionDeclaration)
{
Mandate.ParameterNotNull(config, "config");
Mandate.ParameterNotNull(section, "section");
Mandate.ParameterNotNull(sectionPath, "sectionPath");
Mandate.ParameterCondition(config.Root != null, "config");
Mandate.ParameterCondition(config.Root.Elements().Any(x => x.Name == "configSections"), "config");
var sectionParts = sectionPath.Split('/').ToList();
if (writeSectionDeclaration)
{
//ensure the section group declarations's exist
var configSectionsDeclaration = config.Root.Elements("configSections").Single();
var currGroupDeclaration = configSectionsDeclaration;
foreach (var part in sectionParts)
{
//if this is the last part, we need to write a section, otherwise write a sectionGroup
if (part == sectionParts.Last())
{
var newSection = new XElement("section",
new XAttribute("name", part),
new XAttribute("type", section.GetType().AssemblyQualifiedName),
new XAttribute("requirePermission", false));
currGroupDeclaration.Add(newSection);
}
else
{
//if the section group doesn't exist, then create it
if (!currGroupDeclaration.Elements("sectionGroup").Where(x => (string)x.Attribute("name") == part).Any())
{
var newGroup = new XElement("sectionGroup",
new XAttribute("name", part));
currGroupDeclaration.Add(newGroup);
currGroupDeclaration = newGroup;
}
else
{
currGroupDeclaration = currGroupDeclaration.Elements("sectionGroup").Where(x => (string)x.Attribute("name") == part).First();
}
}
}
}
//now create the real section
var currParent = config.Root;
foreach (var part in sectionParts)
{
if (!currParent.Elements(part).Any())
{
var newSection = new XElement(part);
currParent.Add(newSection);
currParent = newSection;
}
else
{
currParent = currParent.Element(part);
}
}
AddPropertiesToElement(section, currParent);
return(currParent);
}
///<summary>
/// Constructor
///</summary>
///<param name="context"></param>
private DeepConfigManager(HttpContextBase context)
{
Mandate.ParameterNotNull(context, "context");
_mapPathDelegate = path => context.Server.MapPath(path);
}
/// <summary>
/// Creates a custom individual route for the specified controller plugin. Individual routes
/// are required by controller plugins to map to a unique URL based on ID.
/// </summary>
/// <param name="controllerName"></param>
/// <param name="controllerType"></param>
/// <param name="routes">An existing route collection</param>
/// <param name="controllerSuffixName">
/// The suffix name that the controller name must end in before the "Controller" string for example:
/// ContentTreeController has a controllerSuffixName of "Tree", this is used for route constraints.
/// </param>
/// <param name="defaultAction"></param>
/// <param name="defaultId"></param>
/// <param name="area"></param>
/// <param name="umbracoTokenValue">The DataToken value to set for the 'umbraco' key, this defaults to 'backoffice' </param>
/// <param name="routeTokens">By default this value is just {action}/{id} but can be modified for things like web api routes</param>
/// <param name="isMvc">Default is true for MVC, otherwise false for WebAPI</param>
/// <remarks>
/// </remarks>
internal static Route RouteControllerPlugin(this AreaRegistration area, string controllerName, Type controllerType, RouteCollection routes,
string controllerSuffixName, string defaultAction, object defaultId,
string umbracoTokenValue = "backoffice",
string routeTokens = "{action}/{id}",
bool isMvc = true)
{
Mandate.ParameterNotNullOrEmpty(controllerName, "controllerName");
Mandate.ParameterNotNull(controllerSuffixName, "controllerSuffixName");
Mandate.ParameterNotNull(controllerType, "controllerType");
Mandate.ParameterNotNull(routes, "routes");
Mandate.ParameterNotNull(defaultId, "defaultId");
var umbracoArea = GlobalSettings.UmbracoMvcArea;
//routes are explicitly name with controller names and IDs
var url = umbracoArea + "/" + area.AreaName + "/" + controllerName + "/" + routeTokens;
Route controllerPluginRoute;
//var meta = PluginController.GetMetadata(controllerType);
if (isMvc)
{
//create a new route with custom name, specified url, and the namespace of the controller plugin
controllerPluginRoute = routes.MapRoute(
//name
string.Format("umbraco-{0}-{1}", area.AreaName, controllerName),
//url format
url,
//set the namespace of the controller to match
new[] { controllerType.Namespace });
//set defaults
controllerPluginRoute.Defaults = new RouteValueDictionary(
new Dictionary <string, object>
{
{ "controller", controllerName },
{ "action", defaultAction },
{ "id", defaultId }
});
}
else
{
controllerPluginRoute = routes.MapHttpRoute(
//name
string.Format("umbraco-{0}-{1}-{2}", "api", area.AreaName, controllerName),
//url format
url,
new { controller = controllerName, id = defaultId });
//web api routes don't set the data tokens object
if (controllerPluginRoute.DataTokens == null)
{
controllerPluginRoute.DataTokens = new RouteValueDictionary();
}
//look in this namespace to create the controller
controllerPluginRoute.DataTokens.Add("Namespaces", new[] { controllerType.Namespace });
}
//Don't look anywhere else except this namespace!
controllerPluginRoute.DataTokens.Add("UseNamespaceFallback", false);
//constraints: only match controllers ending with 'controllerSuffixName' and only match this controller's ID for this route
if (controllerSuffixName.IsNullOrWhiteSpace() == false)
{
controllerPluginRoute.Constraints = new RouteValueDictionary(
new Dictionary <string, object>
{
{ "controller", @"(\w+)" + controllerSuffixName }
});
}
//match this area
controllerPluginRoute.DataTokens.Add("area", area.AreaName);
controllerPluginRoute.DataTokens.Add("umbraco", umbracoTokenValue); //ensure the umbraco token is set
return(controllerPluginRoute);
}
/// <summary>
/// Compares the current object with another object of the same type.
/// </summary>
/// <returns>
/// A value that indicates the relative order of the objects being compared. The return value has the following meanings: Value Meaning Less than zero This object is less than the <paramref name="other"/> parameter.Zero This object is equal to <paramref name="other"/>. Greater than zero This object is greater than <paramref name="other"/>.
/// </returns>
/// <param name="other">An object to compare with this object.</param>
public int CompareTo(TypedAttributeName other)
{
Mandate.ParameterNotNull(other, "other");
return(string.Compare(other.Alias, Alias, StringComparison.InvariantCultureIgnoreCase));
}
/// <summary>
/// Constructor to setup an existing DocumentTypeProperty from a DataType
/// </summary>
/// <param name="dataType"></param>
public DocumentTypeProperty(DataType dataType)
{
Mandate.ParameterNotNull(dataType, "dataType");
DataType = dataType;
DataTypeId = DataType.Id;
}
public override void Build(IContainerBuilder containerBuilder, IBuilderContext context)
{
Mandate.ParameterNotNull(containerBuilder, "containerBuilder");
Mandate.ParameterNotNull(context, "context");
var configMgr = DeepConfigManager.Default;
var configMain = context.ConfigurationResolver
.GetConfigSection(HiveConfigurationSection.ConfigXmlKey) as HiveConfigurationSection;
if (configMain == null)
{
throw new ConfigurationErrorsException(
string.Format("Configuration section '{0}' not found when building packaging provider '{1}'",
HiveConfigurationSection.ConfigXmlKey, ProviderKey));
}
var readWriteConfig = configMain.AvailableProviders.ReadWriters[ProviderKey] ?? configMain.AvailableProviders.Readers[ProviderKey];
if (readWriteConfig == null)
{
throw new ConfigurationErrorsException(
string.Format("No configuration found for persistence provider '{0}'", ProviderKey));
}
var localConfig = DeepConfigManager
.Default
.GetWebSettings <ProviderConfigurationSection, ProviderConfigurationSection>(readWriteConfig.ConfigSectionKey, x => x, "~/App_Plugins")
.First();
if (localConfig == null)
{
throw new ConfigurationErrorsException(
"Unable to resolve the configuration for the FileSystem repository");
}
//TODO: Fix hard-coded plugin folder path --Aaron
var supportedExtensions =
configMgr.GetWebSetting <ProviderConfigurationSection, string>(readWriteConfig.ConfigSectionKey,
x => x.SupportedExtensions, "~/App_Plugins");
var rootPath = configMgr.GetWebSetting <ProviderConfigurationSection, string>(readWriteConfig.ConfigSectionKey,
x => x.RootPath, "~/App_Plugins");
var excludeExtensions = configMgr.GetWebSetting <ProviderConfigurationSection, string>(readWriteConfig.ConfigSectionKey,
x => x.ExcludeExetensions, "~/App_Plugins");
if (!rootPath.EndsWith("/"))
{
rootPath = rootPath + "/";
}
containerBuilder
.ForFactory(x => new ProviderBootstrapper(localConfig))
.Named <AbstractProviderBootstrapper>(ProviderKey)
.ScopedAs.Singleton();
containerBuilder
.ForFactory(c => new DataContextFactory(
supportedExtensions,
c.Resolve <HttpContextBase>().Server.MapPath(rootPath),
rootPath,
excludeExtensions)
)
.Named <AbstractDataContextFactory>(ProviderKey)
.ScopedAs.NewInstanceEachTime();
containerBuilder
.For <ReadWriteUnitOfWorkFactory>()
.Named <IReadOnlyUnitOfWorkFactory>(ProviderKey)
.ScopedAs.Singleton();
containerBuilder
.For <ReadWriteUnitOfWorkFactory>()
.Named <IReadWriteUnitOfWorkFactory>(ProviderKey)
.ScopedAs.Singleton();
}
/// <summary>
/// Initializes a new instance of the <see cref="CheckoutPaymentMethodModelFactory{TPaymentMethodModel}"/> class.
/// </summary>
/// <param name="merchelloContext">
/// The merchello context.
/// </param>
public CheckoutPaymentMethodModelFactory(IMerchelloContext merchelloContext)
{
Mandate.ParameterNotNull(merchelloContext, "merchelloContext");
_gatewayContext = merchelloContext.Gateways;
}
/// <summary>
/// Initializes a new instance of the <see cref="OfferRedemptionResultBase{TAward}"/> class for success.
/// </summary>
/// <param name="award">
/// The award.
/// </param>
/// <param name="messages">
/// The messages.
/// </param>
protected OfferRedemptionResultBase(TAward award, IEnumerable <string> messages = null)
{
Mandate.ParameterNotNull(award, "award");
Award = award;
Success = true;
}
protected ActionResult ProcessSubmit(UserGroupEditorModel model, UserGroup entity)
{
Mandate.ParameterNotNull(model, "model");
//bind it's data
model.BindModel(this);
//if there's model errors, return the view
if (!ModelState.IsValid)
{
AddValidationErrorsNotification();
return(View("Edit", model));
}
//persist the data
using (var uow = Hive.Create <ISecurityStore>())
{
if (entity == null)
{
//map to new entity
entity =
BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map
<UserGroupEditorModel, UserGroup>(model);
}
else
{
//map to existing entity
BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map(model, entity);
}
uow.Repositories.AddOrUpdate(entity);
// Save permissions
var metaDataumList = new List <RelationMetaDatum>();
foreach (var permissionModel in model.Permissions)
{
var permission = BackOfficeRequestContext.RegisteredComponents.Permissions.SingleOrDefault(x => x.Metadata.Id == permissionModel.PermissionId);
if (permission == null)
{
throw new NullReferenceException("Could not find permission with id " + permissionModel.PermissionId);
}
metaDataumList.Add(BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <RelationMetaDatum>(permissionModel));
}
// Change permissions relation
uow.Repositories.ChangeOrCreateRelationMetadata(entity.Id, FixedHiveIds.SystemRoot, FixedRelationTypes.PermissionRelationType, metaDataumList.ToArray());
uow.Complete();
Notifications.Add(new NotificationMessage(
"UserGroup.Save.Message".Localize(this),
"UserGroup.Save.Title".Localize(this),
NotificationType.Success));
//add path for entity for SupportsPathGeneration (tree syncing) to work
GeneratePathsForCurrentEntity(uow.Repositories.GetEntityPaths <TypedEntity>(entity.Id, FixedRelationTypes.DefaultRelationType));
return(RedirectToAction("Edit", new { id = entity.Id }));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceResolver"/> class.
/// </summary>
/// <param name="cache">
/// The <see cref="CacheHelper"/>.
/// </param>
/// <remarks>
/// Used for testing
/// </remarks>
internal ServiceResolver(CacheHelper cache)
{
Mandate.ParameterNotNull(cache, "cache");
this._cache = cache;
}
public void MapFrom <TMember>(Func <TSource, TMember> sourceMember)
{
Mandate.ParameterNotNull(sourceMember, "sourceMember");
ResultOfMapFrom = sourceMember((TSource)_info.Source.Value);
}
public PluginControllerFactory(IRebelApplicationContext applicationContext)
{
Mandate.ParameterNotNull(applicationContext, "applicationContext");
ApplicationContext = applicationContext;
}
public void MapUsing <TMember>(MemberMapper <TSource, TMember> memberMapper)
{
Mandate.ParameterNotNull(memberMapper, "memberMapper");
ResultOfMapFrom = memberMapper.GetValue((TSource)_info.Source.Value);
}
public DependencyHelper(ProviderMetadata providerMetadata, CacheHelper cacheHelper)
: base(providerMetadata)
{
Mandate.ParameterNotNull(cacheHelper, "cacheHelper");
CacheHelper = cacheHelper;
}
/// <summary>
/// Constructor accepting an IDatabaseFactory instance
/// </summary>
/// <param name="dbFactory"></param>
internal PetaPocoUnitOfWorkProvider(IDatabaseFactory dbFactory)
{
Mandate.ParameterNotNull(dbFactory, "dbFactory");
_dbFactory = dbFactory;
}
/// <summary>
/// Processes the submit.
/// </summary>
/// <param name="createModel">The create model.</param>
/// <param name="editModel">The model.</param>
/// <param name="entity">The entity.</param>
/// <returns></returns>
protected ActionResult ProcessSubmit(CreateUserModel createModel, TEditorModel editModel, TUserType entity)
{
Mandate.ParameterNotNull(editModel, "model");
var isNew = entity == null;
// Clear out any previous groups before mapping, as we just want whatever is selected now
editModel.Groups = Enumerable.Empty <HiveId>();
//bind it's data
editModel.BindModel(this);
//if there's model errors, return the view
if (!ModelState.IsValid)
{
AddValidationErrorsNotification();
EnsureViewBagData();
return(isNew ? View("CreateNew", createModel) : View("Edit", editModel));
}
//persist the data
if (isNew)
{
editModel.Id = HiveId.Empty;
editModel.LastPasswordChangeDate = DateTime.UtcNow;
editModel.LastActivityDate = DateTime.UtcNow;
editModel.LastLoginDate = DateTime.UtcNow;
entity = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <TEditorModel, TUserType>(editModel);
MembershipCreateStatus status;
entity = MembershipService.Create(entity, out status);
if (status != MembershipCreateStatus.Success)
{
ModelState.AddModelError("", status.Localize());
EnsureViewBagData();
return(View("CreateNew", createModel));
}
}
else
{
BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map(editModel, entity);
try
{
MembershipService.Update(entity);
}
catch (ArgumentException ex)
{
ModelState.AddModelError("", ex.Message);
AddValidationErrorsNotification();
EnsureViewBagData();
return(View("Edit", editModel));
}
}
OnAfterSave(entity);
//TODO: Need to display the right messages
Notifications.Add(new NotificationMessage(
"User.Save.Message".Localize(this),
"User.Save.Title".Localize(this),
NotificationType.Success));
GeneratePathsForCurrentEntity(entity);
return(RedirectToAction("Edit", new { id = entity.Id }));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public RenderControllerFactory(IUmbracoApplicationContext applicationContext)
{
Mandate.ParameterNotNull(applicationContext, "applicationContext");
ApplicationContext = applicationContext;
}
/// <summary>
/// Gets the ancestors of the current Content entity relationships
/// </summary>
/// <param name="collection"></param>
/// <returns></returns>
public static IEnumerable <File> AncestorsAsFile(this EntityRelationCollection collection)
{
Mandate.ParameterNotNull(collection, "collection");
return(collection.Ancestors <File>(FixedRelationTypes.FileRelationType));
}
public ProductRepository(IDatabaseUnitOfWork work, IRuntimeCacheProvider cache, IProductVariantRepository productVariantRepository)
: base(work, cache)
{
Mandate.ParameterNotNull(productVariantRepository, "productVariantRepository");
_productVariantRepository = productVariantRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="BraintreeApiRequestFactory"/> class.
/// </summary>
/// <param name="settings">
/// The settings.
/// </param>
public BraintreeApiRequestFactory(BraintreeProviderSettings settings)
{
Mandate.ParameterNotNull(settings, "settings");
this._settings = settings;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProductInventoryValidationVisitor"/> class.
/// </summary>
/// <param name="merchello">
/// The merchello.
/// </param>
public ProductInventoryValidationVisitor(MerchelloHelper merchello)
{
Mandate.ParameterNotNull(merchello, "merchello");
_merchello = merchello;
}