public void SyncObjectState <TEntity>(TEntity entity) where TEntity : class, IObjectState
{
Entry(entity).State = StateHelper.ConvertState(entity.ObjectState);
}
public static string Register(List <InputData> fields, IDialogContext context)
{
string fail = "";
string name = "";
string email = "";
string card = "";
string gender = "";
foreach (InputData f in fields)
{
switch (f.attribute)
{
case name_field:
if (f.value != "")
{
name = f.value;
}
else
{
fail += "Preciso que me diga o seu nome.\n";
}
break;
case email_field:
if (f.value != "")
{
try
{
var m = new MailAddress(f.value);
email = f.value;
}
catch
{
fail += "O email não está no formato correcto (exemplo: [email protected]).\n";
}
}
else
{
fail += "Por favor insira o seu email. Com ele irei conseguir identificá-lo melhor.\n";
}
break;
case gender_field:
gender = f.value;
break;
case client_id_field:
if (f.value != "")
{
card = f.value;
}
break;
}
}
if (email != StateHelper.GetUser(context).Email&& UserController.getUserByEmail(email) != null && email != "")
{
fail += "O email que inseriu já está associado a uma outra conversa.\n";
}
else
{
Random r = new Random();
UserController.CreateUser(email, name, (r.Next(25) + 1).ToString(), gender);
User u = UserController.getUserByEmail(email);
ContextController.CreateContext(u);
CRMController.AddCustomer(u);
if (card != "0")
{
UserController.SetCustomerCard(u, card);
u.CustomerCard = card;
}
StateHelper.SetUser(context, u);
}
return(fail);
}
public ActionResult Puck(string variant = null)
{
try
{
StateHelper.SetFirstRequestUrl();
if (PuckCache.ShouldSync && !PuckCache.IsSyncQueued)
{
PuckCache.IsSyncQueued = true;
//was using HostingEnvironment.QueueBackgroundWorkItem and passing in cancellation token
//can't do that in asp.net core so passing in a new cancellation token which is a bit pointless
System.Threading.Tasks.Task.Factory.StartNew(() => SyncHelper.Sync(new CancellationToken()));
}
var uri = Request.GetUri();
string path = uri.AbsolutePath.ToLower();
var dmode = this.GetDisplayModeId();
if (path == "/")
{
path = string.Empty;
}
string domain = uri.Host.ToLower();
string searchPathPrefix;
if (!PuckCache.DomainRoots.TryGetValue(domain, out searchPathPrefix))
{
if (!PuckCache.DomainRoots.TryGetValue("*", out searchPathPrefix))
{
throw new Exception("domain roots not set. DOMAIN:" + domain);
}
}
string searchPath = searchPathPrefix.ToLower() + path;
//do redirects
string redirectUrl;
if (PuckCache.Redirect301.TryGetValue(searchPath, out redirectUrl))
{
Response.GetTypedHeaders().CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
{
Public = true,
MaxAge = TimeSpan.FromMinutes(PuckCache.RedirectOuputCacheMinutes)
};
Response.Redirect(redirectUrl, true);
}
if (PuckCache.Redirect302.TryGetValue(searchPath, out redirectUrl))
{
Response.GetTypedHeaders().CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
{
Public = true,
MaxAge = TimeSpan.FromMinutes(PuckCache.RedirectOuputCacheMinutes)
};
Response.Redirect(redirectUrl, false);
}
if (string.IsNullOrEmpty(variant))
{
variant = GetVariant(searchPath);
}
HttpContext.Items["variant"] = variant;
//set thread culture for future api calls on this thread
//Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(variant);
IList <Dictionary <string, string> > results;
#if DEBUG
using (MiniProfiler.Current.Step("lucene"))
{
results = puck.core.Helpers.QueryHelper <BaseModel> .Query(
string.Concat("+", FieldKeys.Published, ":true", " +", FieldKeys.Path, ":", $"\"{searchPath}\"", " +", FieldKeys.Variant, ":", variant)
);
}
#else
results = puck.core.Helpers.QueryHelper <BaseModel> .Query(
string.Concat("+", FieldKeys.Published, ":true", " +", FieldKeys.Path, ":", $"\"{searchPath}\"", " +", FieldKeys.Variant, ":", variant)
);
#endif
var result = results == null ? null : results.FirstOrDefault();
BaseModel model = null;
if (result != null)
{
#if DEBUG
using (MiniProfiler.Current.Step("deserialize"))
{
model = JsonConvert.DeserializeObject(result[FieldKeys.PuckValue], ApiHelper.GetTypeFromName(result[FieldKeys.PuckType])) as BaseModel;
}
#else
model = JsonConvert.DeserializeObject(result[FieldKeys.PuckValue], ApiHelper.GetTypeFromName(result[FieldKeys.PuckType])) as BaseModel;
#endif
if (!PuckCache.OutputCacheExclusion.Contains(searchPath))
{
int cacheMinutes;
if (!PuckCache.TypeOutputCache.TryGetValue(result[FieldKeys.PuckType], out cacheMinutes))
{
if (!PuckCache.TypeOutputCache.TryGetValue(typeof(BaseModel).Name, out cacheMinutes))
{
cacheMinutes = PuckCache.DefaultOutputCacheMinutes;
}
}
Response.GetTypedHeaders().CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
{
Public = true,
MaxAge = TimeSpan.FromMinutes(cacheMinutes)
};
}
}
if (model == null)
{
//404
return(View(PuckCache.Path404));
}
var cache = PuckCache.Cache;
object cacheValue;
//string templatePath = result[FieldKeys.TemplatePath];
string templatePath = model.TemplatePath;
if (!string.IsNullOrEmpty(dmode))
{
string cacheKey = CacheKeys.PrefixTemplateExist + dmode + templatePath;
if (cache.TryGetValue(cacheKey, out cacheValue))
{
templatePath = cacheValue as string;
}
else
{
string dpath = templatePath.Insert(templatePath.LastIndexOf('.') + 1, dmode + ".");
if (System.IO.File.Exists(ApiHelper.MapPath(dpath)))
{
templatePath = dpath;
}
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSlidingExpiration(TimeSpan.FromMinutes(PuckCache.DisplayModesCacheMinutes));
cache.Set(cacheKey, templatePath, cacheEntryOptions);
}
}
return(View(templatePath, model));
}
catch (Exception ex)
{
PuckCache.PuckLog.Log(ex);
ViewBag.Error = ex.Message;
return(View(PuckCache.Path500));
}
}
public void SyncObjectState(object entity)
{
Entry(entity).State = StateHelper.ConvertState(((IObjectState)entity).ObjectState);
}
public static StateDictionary GetState(this ResultWrapper result)
{
var actionId = result.ActionId;
return(StateHelper.InitializeState(actionId));
}
protected override Overtrade?ComputeByIndexImpl(IEnumerable <decimal> mappedInputs, int index) => StateHelper.IsOvertrade(_rsi[index]);
public Control RenderMacro(Hashtable pageElements, int documentId)
{
TraceInfo("renderMacro", string.Format("Rendering started (macro: {0}, type: {1}, cacheRate: {2})", Name, MacroType, Model.CacheDuration));
StateHelper.SetContextValue(MacrosAddedKey, StateHelper.GetContextValue <int>(MacrosAddedKey) + 1);
String macroHtml = null;
Control macroControl = null;
// zb-00037 #29875 : parse attributes here (and before anything else)
foreach (var prop in Model.Properties)
{
prop.Value = helper.parseAttribute(pageElements, prop.Value);
}
Model.CacheIdentifier = GetCacheIdentifier(Model);
if (Model.CacheDuration > 0)
{
if (CacheMacroAsString(Model))
{
macroHtml = _macroCache["macroHtml_" + Model.CacheIdentifier] as String;
// FlorisRobbemont:
// An empty string means: macroHtml has been cached before, but didn't had any output (Macro doesn't need to be rendered again)
// An empty reference (null) means: macroHtml has NOT been cached before
if (macroHtml != null)
{
if (MacroNeedsToBeClearedFromCache(Model, "macroHtml_DateAdded_" + Model.CacheIdentifier))
{
macroHtml = null;
TraceInfo("renderMacro", string.Format("Macro removed from cache due to file change '{0}'.", Model.CacheIdentifier));
}
else
{
TraceInfo("renderMacro", string.Format("Macro Content loaded from cache '{0}'.", Model.CacheIdentifier));
}
}
}
else
{
var cacheContent = _macroCache["macroControl_" + Model.CacheIdentifier] as MacroCacheContent;
if (cacheContent != null)
{
macroControl = cacheContent.Content;
macroControl.ID = cacheContent.ID;
if (MacroNeedsToBeClearedFromCache(Model, "macroControl_DateAdded_" + Model.CacheIdentifier))
{
TraceInfo("renderMacro", string.Format("Macro removed from cache due to file change '{0}'.", Model.CacheIdentifier));
macroControl = null;
}
else
{
TraceInfo("renderMacro", string.Format("Macro Control loaded from cache '{0}'.", Model.CacheIdentifier));
}
}
}
}
// FlorisRobbemont: Empty macroHtml (not null, but "") doesn't mean a re-render is necessary
if (macroHtml == null && macroControl == null)
{
var renderFailed = false;
var macroType = Model.MacroType != MacroTypes.Unknown ? (int)Model.MacroType : MacroType;
switch (macroType)
{
case (int)MacroTypes.XSLT:
macroControl = loadMacroXSLT(this, Model, pageElements);
break;
case (int)MacroTypes.Script:
try
{
TraceInfo("umbracoMacro", "MacroEngine script added (" + ScriptFile + ")");
var result = LoadMacroScript(Model, documentId);
macroControl = new LiteralControl(result.Result);
if (result.ResultException != null)
{
// we'll throw the error if we run in release mode, show details if we're in release mode!
renderFailed = true;
if (HttpContext.Current != null && !HttpContext.Current.IsDebuggingEnabled)
{
throw result.ResultException;
}
}
break;
}
catch (Exception e)
{
renderFailed = true;
Exceptions.Add(e);
Log.Instance.LogError("RenderMacro: " + e);
var result = new LiteralControl("Error loading MacroEngine script (file: " + ScriptFile + ")");
macroControl = result;
break;
}
default:
if (GlobalSettings.DebugMode)
{
macroControl = new LiteralControl("<Macro: " + Name + " (" + ScriptAssembly + "," + ScriptType + ")>");
}
break;
}
// Add result to cache if successful
if (!renderFailed && Model.CacheDuration > 0)
{
// do not add to cache if there's no member and it should cache by personalization
if (!Model.CacheByMember || (Model.CacheByMember && Member.GetCurrentMember() != null))
{
if (macroControl != null)
{
// NH: Scripts and XSLT can be generated as strings, but not controls as page events wouldn't be hit (such as Page_Load, etc)
if (CacheMacroAsString(Model))
{
string outputCacheString;
using (var sw = new StringWriter())
{
var hw = new HtmlTextWriter(sw);
macroControl.RenderControl(hw);
outputCacheString = sw.ToString();
}
_macroCache.Insert("macroHtml_" + Model.CacheIdentifier, outputCacheString, null, DateTime.Now.AddSeconds(Model.CacheDuration), TimeSpan.Zero, CacheItemPriority.NotRemovable, //FlorisRobbemont: issue #27610 -> Macro output cache should not be removable
null);
_macroCache.Insert("macroHtml_DateAdded_" + Model.CacheIdentifier, DateTime.Now, null, DateTime.Now.AddSeconds(Model.CacheDuration), TimeSpan.Zero, CacheItemPriority.NotRemovable, //FlorisRobbemont: issue #27610 -> Macro output cache should not be removable
null);
// zb-00003 #29470 : replace by text if not already text
// otherwise it is rendered twice
if (!(macroControl is LiteralControl))
{
macroControl = new LiteralControl(outputCacheString);
}
TraceInfo("renderMacro", string.Format("Macro Content saved to cache '{0}'.", Model.CacheIdentifier));
}
else
{
_macroCache.Insert("macroControl_" + Model.CacheIdentifier, new MacroCacheContent(macroControl, macroControl.ID), null, DateTime.Now.AddSeconds(Model.CacheDuration), TimeSpan.Zero, CacheItemPriority.NotRemovable, //FlorisRobbemont: issue #27610 -> Macro output cache should not be removable
null);
_macroCache.Insert("macroControl_DateAdded_" + Model.CacheIdentifier, DateTime.Now, null, DateTime.Now.AddSeconds(Model.CacheDuration), TimeSpan.Zero, CacheItemPriority.NotRemovable, //FlorisRobbemont: issue #27610 -> Macro output cache should not be removable
null);
TraceInfo("renderMacro", string.Format("Macro Control saved to cache '{0}'.", Model.CacheIdentifier));
}
}
}
}
}
else if (macroControl == null)
{
macroControl = new LiteralControl(macroHtml);
}
return(macroControl);
}
protected override Trend?ComputeByIndexImpl(int index) => StateHelper.IsTrending(_closePriceChange[index]);
private bool validateAccess(XmlNode node)
{
// check if this area should be shown at all
string onlyOnceValue = StateHelper.GetCookieValue(generateCookieKey(node));
if (!String.IsNullOrEmpty(onlyOnceValue))
{
return(false);
}
// the root user can always see everything
if (CurrentUser.IsRoot())
{
return(true);
}
else if (node != null)
{
XmlNode accessRules = node.SelectSingleNode("access");
bool retVal = true;
if (accessRules != null && accessRules.HasChildNodes)
{
string currentUserType = CurrentUser.UserType.Alias.ToLowerInvariant();
//Update access rules so we'll be comparing lower case to lower case always
var denies = accessRules.SelectNodes("deny");
foreach (XmlNode deny in denies)
{
deny.InnerText = deny.InnerText.ToLowerInvariant();
}
var grants = accessRules.SelectNodes("grant");
foreach (XmlNode grant in grants)
{
grant.InnerText = grant.InnerText.ToLowerInvariant();
}
string allowedSections = ",";
foreach (BusinessLogic.Application app in CurrentUser.Applications)
{
allowedSections += app.alias.ToLower() + ",";
}
XmlNodeList grantedTypes = accessRules.SelectNodes("grant");
XmlNodeList grantedBySectionTypes = accessRules.SelectNodes("grantBySection");
XmlNodeList deniedTypes = accessRules.SelectNodes("deny");
// if there's a grant type, everyone who's not granted is automatically denied
if (grantedTypes.Count > 0 || grantedBySectionTypes.Count > 0)
{
retVal = false;
if (grantedBySectionTypes.Count > 0 && accessRules.SelectSingleNode(String.Format("grantBySection [contains('{0}', concat(',',.,','))]", allowedSections)) != null)
{
retVal = true;
}
else if (grantedTypes.Count > 0 && accessRules.SelectSingleNode(String.Format("grant [. = '{0}']", currentUserType)) != null)
{
retVal = true;
}
}
// if the current type of user is denied we'll say nay
if (deniedTypes.Count > 0 && accessRules.SelectSingleNode(String.Format("deny [. = '{0}']", currentUserType)) != null)
{
retVal = false;
}
}
return(retVal);
}
return(false);
}
public async Task OnGameActionRequested(GameActionRequest actionRequest, StateHelper stateHelper)
{
// OnGameActionRequested is called when the bot actually needs to take an action. Below is an example of how this can
// be done and what events your bot will need to handle.
//
// To see all of the actions your must handle, look at GameActionType.
//
// actionRequest.State is the root of the state object for the game. This holds all things like players, coin amounts,
// what building are in the marketplace, states of the current turn, etc.
// Essentially, this object is everything you would see on the table when playing the game.
//
// The statehelper is a very useful tool that will answer many current state questions. The state helper takes a perspective user
// when it's created, that it will use as a default player if no player is given.
// For example, the Player.GetPlayerName function takes an option playerIndex. If not given, it will return your name.
//
// There are 4 modules to the state helper. Each helper has functions specific the to topic.
// Player
// ex. GetPlayer(), GetNumberOfLandmarksOwned(), GetMaxRollsAllowed(), CanHaveExtraTurn()
// Marketplace
// ex. GetMaxBuildingsInGame(), GetBuiltBuildingsInCurrentGame(), GetBuildingTypesBuildableInMarketplace()
// CurrentTurn
// ex. CanRollOrReRoll(), GetPossibleActions(), CanTakeAction()
// BuildingRules
// This helper holds all of the building types and the rules of them. ex. BuildingRules[buildingIndex].GetColor()
//
// Always roll if it's an option.
if (actionRequest.PossibleActions.Contains(GameActionType.RollDice))
{
// How many dice can we roll?
int maxDiceCount = stateHelper.Player.GetMaxCountOfDiceCanRoll();
// Can we re-roll
int rollsSoFar = stateHelper.GetState().CurrentTurnState.Rolls;
bool canReRoll = stateHelper.Player.GetMaxRollsAllowed() < rollsSoFar;
// If we can't reroll, auto commit the dice. Otherwise don't, so we can reroll if we want.
Logger.Log(Log.Info, "Rolling the dice!");
GameActionResponse result = await m_bot.SendAction(GameAction <object> .CreateRollDiceAction(maxDiceCount, !canReRoll));
if (!result.Accepted)
{
await Shutdown("failed to roll dice.", result.Error);
}
else
{
Logger.Log(Log.Info, "Done");
}
return;
}
if (actionRequest.PossibleActions.Contains(GameActionType.CommitDiceResult))
{
// This action is used if you want to see the dice results before they are committed.
// It's useful to see the results if you have the ability to re-roll, so you can decided to re-roll.
// But if the `autoCommitResults` flag is set to true when you call `CreateRollDiceAction` this wont' get called,
// because the server will always do this for you.
GameActionResponse result = await m_bot.SendAction(GameAction <object> .CreateCommitDiceResultAction());
if (!result.Accepted)
{
await Shutdown("failed to commit dice.", result.Error);
}
else
{
Logger.Log(Log.Info, "Done");
}
}
if (actionRequest.PossibleActions.Contains(GameActionType.BuildBuilding))
{
// Get all building that are in the marketplace currently.
List <int> buildable = stateHelper.Marketplace.GetBuildingTypesBuildableInMarketplace();
// Filter it down to only buildings we can afford.
List <int> affordable = stateHelper.Player.FilterBuildingIndexesWeCanAfford(buildable);
// Randomly pick one.
int buildingIndex = affordable[m_random.RandomInt(0, affordable.Count - 1)];
Logger.Log(Log.Info, $"Requesting to build {stateHelper.BuildingRules[buildingIndex].GetName()}...");
GameActionResponse result = await m_bot.SendAction(GameAction <object> .CreateBuildBuildingAction(buildingIndex));
if (!result.Accepted)
{
await Shutdown("failed to build building.", result.Error);
}
else
{
Logger.Log(Log.Info, $"We just bought {stateHelper.BuildingRules[buildingIndex].GetName()}!");
}
return;
}
if (actionRequest.PossibleActions.Contains(GameActionType.TvStationPayout))
{
// Our Tv Station activated! Let's take 5 coins from a player at random.
GamePlayer randomPlayer = GetRandomPlayer(stateHelper);
Logger.Log(Log.Info, $"Our Tv Station was activated, let's take coins from player {randomPlayer.Name}!");
GameActionResponse result = await m_bot.SendAction(GameAction <object> .CreateTvStationPayoutAction(randomPlayer.PlayerIndex));
if (!result.Accepted)
{
// If random bot fails, it instantly shuts down.
await Shutdown("failed to respond to tv station payout.", result.Error);
}
else
{
Logger.Log(Log.Info, $"We taken coins from player {randomPlayer.Name} for our tv station!");
}
return;
}
if (actionRequest.PossibleActions.Contains(GameActionType.BusinessCenterSwap))
{
// Our Business Center activated! Let's randomly pick a player and building to swap.
GamePlayer randomPlayer = GetRandomPlayer(stateHelper);
BuildingBase ourBuilding = GetRandomOwnedNonMajorBuidling(stateHelper, null);
BuildingBase theirBuilding = GetRandomOwnedNonMajorBuidling(stateHelper, randomPlayer.PlayerIndex);
GameActionResponse result;
if (randomPlayer == null || ourBuilding == null || theirBuilding == null)
{
// If there aren't any building we can use, skip the action.
Logger.Log(Log.Info, $"Our Business Center was activated, but there weren't the correct building to swap. So we will skip!");
result = await m_bot.SendAction(GameAction <object> .CreateBusinessCenterSwapAction(0, 0, 0, true));
}
else
{
Logger.Log(Log.Info, $"Our Business Center was activated, swap our {ourBuilding.GetName()} for {randomPlayer.Name}'s {theirBuilding.GetName()}!");
result = await m_bot.SendAction(GameAction <object> .CreateBusinessCenterSwapAction(randomPlayer.PlayerIndex, ourBuilding.GetBuildingIndex(), theirBuilding.GetBuildingIndex()));
}
if (!result.Accepted)
{
// If random bot fails, it instantly shuts down.
await Shutdown("failed to respond to business center swap.", result.Error);
}
else
{
Logger.Log(Log.Info, $"Business center swap done!");
}
return;
}
if (actionRequest.PossibleActions.Contains(GameActionType.EndTurn))
{
// If we can't roll the dice or build a building, we must not have enough funds.
// Just end the turn.
Logger.Log(Log.Info, "There's nothing to do, requesting turn end...");
GameActionResponse result = await m_bot.SendAction(GameAction <object> .CreateEndTurnAction());
if (!result.Accepted)
{
// If random bot fails, it instantly shuts down.
await Shutdown("failed to end our turn.", result.Error);
}
else
{
Logger.Log(Log.Info, $"We have {stateHelper.Player.GetPlayer().Coins} coins and can't buy anything, so we ended the turn.");
}
return;
}
Logger.Log(Log.Error, $"Hmm, we were asked for an action but didn't know what to do with...");
foreach (GameActionType type in actionRequest.PossibleActions)
{
Logger.Log(Log.Error, $" ... {type.ToString()}");
await Shutdown("received an unknown action.", null);
}
}
public virtual void SyncEntityState <TEntity>(TEntity entity) where TEntity : class, IObjectState
{
entity.SyncObjectState(StateHelper.ConvertState(Entry(entity).State));
}
public void SetUp()
{
stateHelper = new StateHelper("Test");
}
/// <summary>
/// This method will parse the attribute value to look for some special syntax such as
/// [@requestKey]
/// [%sessionKey]
/// [#pageElement]
/// [$recursiveValue]
/// </summary>
/// <param name="pageElements"></param>
/// <param name="attributeValue"></param>
/// <returns></returns>
/// <remarks>
/// You can even apply fallback's separated by comma's like:
///
/// [@requestKey],[%sessionKey]
///
/// </remarks>
public static string parseAttribute(IDictionary pageElements, string attributeValue)
{
// Check for potential querystring/cookie variables
// SD: not sure why we are checking for len 3 here?
if (attributeValue.Length > 3 && attributeValue.StartsWith("["))
{
var attributeValueSplit = (attributeValue).Split(',');
// before proceeding, we don't want to process anything here unless each item starts/ends with a [ ]
// this is because the attribute value could actually just be a json array like [1,2,3] which we don't want to parse
//
// however, the last one can be a literal, must take care of this!
// so here, don't check the last one, which can be just anything
if (attributeValueSplit.Take(attributeValueSplit.Length - 1).All(x =>
//must end with [
x.EndsWith("]") &&
//must start with [ and a special char
(x.StartsWith("[@") || x.StartsWith("[%") || x.StartsWith("[#") || x.StartsWith("[$"))) == false)
{
return(attributeValue);
}
foreach (var attributeValueItem in attributeValueSplit)
{
attributeValue = attributeValueItem;
var trimmedValue = attributeValue.Trim();
// Check for special variables (always in square-brackets like [name])
if (trimmedValue.StartsWith("[") &&
trimmedValue.EndsWith("]"))
{
attributeValue = trimmedValue;
// find key name
var keyName = attributeValue.Substring(2, attributeValue.Length - 3);
var keyType = attributeValue.Substring(1, 1);
switch (keyType)
{
case "@":
attributeValue = HttpContext.Current.Request[keyName];
break;
case "%":
attributeValue = StateHelper.GetSessionValue <string>(keyName);
if (String.IsNullOrEmpty(attributeValue))
{
attributeValue = StateHelper.GetCookieValue(keyName);
}
break;
case "#":
if (pageElements[keyName] != null)
{
attributeValue = pageElements[keyName].ToString();
}
else
{
attributeValue = "";
}
break;
case "$":
if (pageElements[keyName] != null && pageElements[keyName].ToString() != string.Empty)
{
attributeValue = pageElements[keyName].ToString();
}
else
{
// reset attribute value in case no value has been found on parents
attributeValue = String.Empty;
XmlDocument umbracoXML = presentation.UmbracoContext.Current.GetXml();
String[] splitpath = (String[])pageElements["splitpath"];
for (int i = 0; i < splitpath.Length - 1; i++)
{
XmlNode element = umbracoXML.GetElementById(splitpath[splitpath.Length - i - 1].ToString());
if (element == null)
{
continue;
}
string xpath = UmbracoConfig.For.UmbracoSettings().Content.UseLegacyXmlSchema ? "./data [@alias = '{0}']" : "{0}";
XmlNode currentNode = element.SelectSingleNode(string.Format(xpath,
keyName));
if (currentNode != null && currentNode.FirstChild != null &&
!string.IsNullOrEmpty(currentNode.FirstChild.Value) &&
!string.IsNullOrEmpty(currentNode.FirstChild.Value.Trim()))
{
HttpContext.Current.Trace.Write("parameter.recursive", "Item loaded from " + splitpath[splitpath.Length - i - 1]);
attributeValue = currentNode.FirstChild.Value;
break;
}
}
}
break;
}
if (attributeValue != null)
{
attributeValue = attributeValue.Trim();
if (attributeValue != string.Empty)
{
break;
}
}
else
{
attributeValue = string.Empty;
}
}
}
}
return(attributeValue);
}
public JsonResult Edit(Settings model)
{
string msg = "";
bool success = false;
try
{
// TODO: Add update logic here
//default language
if (!string.IsNullOrEmpty(model.DefaultLanguage))
{
var metaDL = repo.GetPuckMeta().Where(x => x.Name == DBNames.Settings && x.Key == DBKeys.DefaultLanguage).FirstOrDefault();
if (metaDL != null)
{
metaDL.Value = model.DefaultLanguage;
}
else
{
var newMeta = new PuckMeta();
newMeta.Name = DBNames.Settings;
newMeta.Key = DBKeys.DefaultLanguage;
newMeta.Value = model.DefaultLanguage;
repo.AddMeta(newMeta);
}
}
//enable local prefix
var metaELP = repo.GetPuckMeta().Where(x => x.Name == DBNames.Settings && x.Key == DBKeys.EnableLocalePrefix).FirstOrDefault();
if (metaELP != null)
{
metaELP.Value = model.EnableLocalePrefix.ToString();
}
else
{
var newMeta = new PuckMeta();
newMeta.Name = DBNames.Settings;
newMeta.Key = DBKeys.EnableLocalePrefix;
newMeta.Value = model.EnableLocalePrefix.ToString();
repo.AddMeta(newMeta);
}
//languages
if (model.Languages != null && model.Languages.Count > 0)
{
var metaLanguages = repo.GetPuckMeta().Where(x => x.Name == DBNames.Settings && x.Key == DBKeys.Languages).ToList();
if (metaLanguages.Count > 0)
{
metaLanguages.ForEach(x =>
{
repo.DeleteMeta(x);
});
}
model.Languages.ForEach(x => {
var newMeta = new PuckMeta();
newMeta.Name = DBNames.Settings;
newMeta.Key = DBKeys.Languages;
newMeta.Value = x;
repo.AddMeta(newMeta);
});
}
//redirects
if (model.Redirect != null && model.Redirect.Count > 0)
{
var redirectMeta = repo.GetPuckMeta().Where(x => x.Name == DBNames.Redirect301 || x.Name == DBNames.Redirect302).ToList();
redirectMeta.ForEach(x => {
repo.DeleteMeta(x);
});
//count of 1 and key/value of null indicates delete only so inserts are skipped
if (!(model.Redirect.Count == 1 && string.IsNullOrEmpty(model.Redirect.First().Key)))
{
model.Redirect.ToList().ForEach(x =>
{
var newMeta = new PuckMeta();
newMeta.Name = x.Key.StartsWith(DBNames.Redirect301) ? DBNames.Redirect301 : DBNames.Redirect302;
newMeta.Key = x.Key.Substring(newMeta.Name.Length);
newMeta.Value = x.Value;
repo.AddMeta(newMeta);
});
}
}
//fieldgroup
if (model.TypeGroupField != null && model.TypeGroupField.Count > 0)
{
foreach (var mod in apiHelper.AllModels(true))
{
var fieldGroupMeta = repo.GetPuckMeta().Where(x => x.Name.StartsWith(DBNames.FieldGroups + mod.AssemblyQualifiedName)).ToList();
fieldGroupMeta.ForEach(x =>
{
repo.DeleteMeta(x);
});
}
model.TypeGroupField.ForEach(x => {
var values = x.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
var newMeta = new PuckMeta();
newMeta.Name = DBNames.FieldGroups + values[0];
newMeta.Key = values[1];
newMeta.Value = values[2];
repo.AddMeta(newMeta);
});
}
//typeallowedtypes
if (model.TypeAllowedTypes != null && model.TypeAllowedTypes.Count > 0)
{
var typeAllowedTypesMeta = repo.GetPuckMeta().Where(x => x.Name == DBNames.TypeAllowedTypes).ToList();
typeAllowedTypesMeta.ForEach(x => {
repo.DeleteMeta(x);
});
model.TypeAllowedTypes.ForEach(x => {
var values = x.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
var newMeta = new PuckMeta();
newMeta.Name = DBNames.TypeAllowedTypes;
newMeta.Key = values[0];
newMeta.Value = values[1];
repo.AddMeta(newMeta);
});
}
//typeallowedtemplates
if (model.TypeAllowedTemplates != null && model.TypeAllowedTemplates.Count > 0)
{
var typeAllowedTemplatesMeta = repo.GetPuckMeta().Where(x => x.Name == DBNames.TypeAllowedTemplates).ToList();
typeAllowedTemplatesMeta.ForEach(x =>
{
repo.DeleteMeta(x);
});
model.TypeAllowedTemplates.ForEach(x =>
{
var values = x.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
var newMeta = new PuckMeta();
newMeta.Name = DBNames.TypeAllowedTemplates;
newMeta.Key = values[0];
newMeta.Value = values[1];
repo.AddMeta(newMeta);
});
}
//cachepolicy
if (model.CachePolicy == null)
{
model.CachePolicy = new List <string>();
}
var cacheTypes = new List <string>();
if (model.CachePolicy.Count > 0)
{
foreach (var entry in model.CachePolicy)
{
var type = entry.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries)[0];
cacheTypes.Add(type);
var minutes = entry.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries)[1];
int min;
if (!int.TryParse(minutes, out min))
{
throw new Exception("cache policy minutes not int for type:" + type);
}
var meta = repo.GetPuckMeta().Where(x => x.Name == DBNames.CachePolicy && x.Key.ToLower().Equals(type.ToLower())).FirstOrDefault();
if (meta != null)
{
meta.Value = minutes;
}
else
{
meta = new PuckMeta()
{
Name = DBNames.CachePolicy, Key = type, Value = minutes
};
repo.AddMeta(meta);
}
}
}
//delete unset
repo.GetPuckMeta().Where(x => x.Name == DBNames.CachePolicy && !cacheTypes.Contains(x.Key)).ToList().ForEach(x => repo.DeleteMeta(x));
//orphan types
if (model.Orphans != null && model.Orphans.Count > 0)
{
foreach (var entry in model.Orphans)
{
var t1 = entry.Key;
var t2 = entry.Value;
contentService.RenameOrphaned(t1, t2);
}
}
repo.SaveChanges();
StateHelper.UpdateDefaultLanguage();
StateHelper.UpdateCacheMappings();
StateHelper.UpdateRedirectMappings();
success = true;
}
catch (Exception ex)
{
msg = ex.Message;
success = false;
}
return(Json(new { success = success, message = msg }));
}
public static string parseAttribute(IDictionary pageElements, string attributeValue)
{
// Check for potential querystring/cookie variables
if (attributeValue.Length > 3 && attributeValue.Substring(0, 1) == "[")
{
string[] attributeValueSplit = (attributeValue).Split(',');
foreach (string attributeValueItem in attributeValueSplit)
{
attributeValue = attributeValueItem;
// Check for special variables (always in square-brackets like [name])
if (attributeValueItem.Substring(0, 1) == "[" &&
attributeValueItem.Substring(attributeValueItem.Length - 1, 1) == "]")
{
// find key name
string keyName = attributeValueItem.Substring(2, attributeValueItem.Length - 3);
string keyType = attributeValueItem.Substring(1, 1);
switch (keyType)
{
case "@":
attributeValue = HttpContext.Current.Request[keyName];
break;
case "%":
attributeValue = StateHelper.GetSessionValue <string>(keyName);
if (String.IsNullOrEmpty(attributeValue))
{
attributeValue = StateHelper.GetCookieValue(keyName);
}
break;
case "#":
if (pageElements[keyName] != null)
{
attributeValue = pageElements[keyName].ToString();
}
else
{
attributeValue = "";
}
break;
case "$":
if (pageElements[keyName] != null && pageElements[keyName].ToString() != string.Empty)
{
attributeValue = pageElements[keyName].ToString();
}
else
{
// reset attribute value in case no value has been found on parents
attributeValue = String.Empty;
XmlDocument umbracoXML = presentation.UmbracoContext.Current.GetXml();
String[] splitpath = (String[])pageElements["splitpath"];
for (int i = 0; i < splitpath.Length - 1; i++)
{
XmlNode element = umbracoXML.GetElementById(splitpath[splitpath.Length - i - 1].ToString());
if (element == null)
{
continue;
}
string xpath = UmbracoSettings.UseLegacyXmlSchema ? "./data [@alias = '{0}']" : "{0}";
XmlNode currentNode = element.SelectSingleNode(string.Format(xpath,
keyName));
if (currentNode != null && currentNode.FirstChild != null &&
!string.IsNullOrEmpty(currentNode.FirstChild.Value) &&
!string.IsNullOrEmpty(currentNode.FirstChild.Value.Trim()))
{
HttpContext.Current.Trace.Write("parameter.recursive", "Item loaded from " + splitpath[splitpath.Length - i - 1]);
attributeValue = currentNode.FirstChild.Value;
break;
}
}
}
break;
}
if (attributeValue != null)
{
attributeValue = attributeValue.Trim();
if (attributeValue != string.Empty)
{
break;
}
}
else
{
attributeValue = string.Empty;
}
}
}
}
return(attributeValue);
}
