public override void Generate(KBObject baseObject, PatternInstance instance)
{
if (baseObject is Transaction)
{
//modMain.SetGXPath(Artech.Common.Helpers.IO.PathHelper.StartupPath);
pinstance = instance;
Transaction transaction = (Transaction)baseObject;
HPatternInstance wwInstance = new HPatternInstance(transaction.Model);
settings = wwInstance.Settings;
//Dictionary<string, object> propertiesg = new Dictionary<string, object>();
//propertiesg[Properties.HTMLATT.ReadOnly] = true;
//settings.Grid.Rules
//Dictionary<string, object> propertiesg = new Dictionary<string, object>();
//propertiesg[Properties.HTMLSFL.Rules] = Properties.HTMLSFL.Rules_Values.Rows;
//System.Text.Encoding.w
// string template = System.Text.Encoding.Default.GetString(file.BlobPart.Data);
// testes
/*
KBModel model = Artech.Architecture.UI.Framework.Services.UIServices.KB.CurrentModel;
foreach (WikiFileKBObject file in WikiFileKBObject.GetAll(model)) {
System.Windows.Forms.MessageBox.Show("File: " + file.Name);
byte[] b = file.BlobPart.Data;
string saida = System.Text.StringBuilder .GetString(b);
System.Text.StringBuilder sb = System.Text.StringBuilder();
}
*/
//Antlr.StringTemplate.FileSystemTemplateLoader st = new Antlr.StringTemplate.FileSystemTemplateLoader("");
Generate(transaction, wwInstance);
wwInstance.SaveTo(instance);
}
else if (baseObject is WebPanel)
{
HPatternInstance wwInstance = new HPatternInstance(instance);
if (wwInstance.WebPanelRoot == null)
{
wwInstance.WebPanelRoot = new WebPanelRootElement();
}
wwInstance.SaveTo(instance);
} else {
throw new PatternException(Messages.ParentMustBeTransaction);
}
}
private static void UpdateAttributes(HPatternInstance instance, HPatternSettings settings, Transaction transaction)
{
string picturedefault = settings.Template.PictureCharacterDefault;
foreach (RowElement row in instance.Transaction.GetRows(""))
{
foreach (ColumnElement col in row.Columns)
{
foreach (AttributeElement att in col.Attributes)
{
if (att.Attribute != null)
{
string picture = "";
if (att.Picture.ToLower() == "default")
{
picture = picturedefault;
if (picture != String.Empty && (att.Attribute.Type == eDBType.CHARACTER || att.Attribute.Type == eDBType.VARCHAR))
{
att.Attribute.SetPropertyValue(Properties.ATT.Picture, picture);
att.Attribute.Save();
}
}
else
{
picture = att.Picture;
if (picture != String.Empty)
{
att.Attribute.SetPropertyValue(Properties.ATT.Picture, picture);
att.Attribute.Save();
}
}
}
}
}
}
}
private static bool CanRedirectToView(HPatternInstance instance, out ViewElement view)
{
// Do we have an appropriate view element?
if (instance.Levels.Count > 0 &&
instance.Levels[0].View != null &&
CanRedirectTo(instance.Levels[0].View))
{
view = instance.Levels[0].View;
return true;
}
view = null;
return false;
}
private static bool CanRedirectToSelection(HPatternInstance instance, out SelectionElement selection)
{
// Do we have an appropriate selection element?
if (instance.Levels.Count > 0 &&
instance.Levels[0].Selection != null &&
CanRedirectTo(instance.Levels[0].Selection))
{
selection = instance.Levels[0].Selection;
return true;
}
selection = null;
return false;
}
public static HPatternInstance FastLoadCache(PatternInstance instance)
{
if (instance == null)
throw new ArgumentNullException("instance");
HPatternInstance cachedWWInstance = instance.GetPropertyValue<HPatternInstance>(k_CacheProperty);
if (cachedWWInstance != null)
return cachedWWInstance;
HPatternInstance wwInstance = new HPatternInstance(instance);
return wwInstance;
}
public static Boolean GetAutoResize(String value, HPatternInstance instance)
{
switch (value)
{
case SelectionElement.AutoResizeValue.False:
return false;
case SelectionElement.AutoResizeValue.True:
return true;
default:
return instance.Settings.Grid.AutoResize;
}
}
private static void UpdateProperties(HPatternInstance instance, HPatternSettings settings, Transaction transaction)
{
WebPanel mTransaction = settings.MasterPages.Transaction;
string AMP = SettingsThemeElement.SetObjectThemeValue.True;
string ATema = settings.Theme.SetObjectTheme;
Theme tTema = null;
if (ATema != SettingsThemeElement.SetObjectThemeValue.False)
tTema = settings.Theme.Theme;
foreach (SettingsThemeMasterPageElement sis in settings.CustomThemeMasterPage)
{
if (transaction.Name.IndexOf(sis.Name, StringComparison.InvariantCultureIgnoreCase) >= 0)
{
if (sis.SetMasterPage != SettingsThemeMasterPageElement.SetMasterPageValue.False)
{
mTransaction = sis.Transaction;
AMP = sis.SetMasterPage;
}
if (sis.SetTheme != SettingsThemeMasterPageElement.SetThemeValue.False)
{
tTema = sis.Theme;
ATema = sis.SetTheme;
}
break;
}
}
if (transaction.IsPropertyDefault(Properties.TRN.MasterPage) || AMP == SettingsThemeElement.SetObjectThemeValue.Force)
{
if (mTransaction == null)
{
transaction.SetPropertyValue(Properties.TRN.MasterPage, new WebPanelReference());
}
else
{
transaction.SetPropertyValue(Properties.TRN.MasterPage, new WebPanelReference(mTransaction));
}
}
if (tTema != null)
{
if (transaction.IsPropertyDefault(Properties.TRN.Theme) || ATema == SettingsThemeElement.SetObjectThemeValue.Force)
{
transaction.SetPropertyValue(Properties.TRN.Theme, new KBObjectReference(tTema));
}
}
if (instance.Levels.Count > 0 && instance.Levels[0].View != null)
{
if (instance.Levels[0].View.UseAsSearchViewer)
{
try
{
PropertyManager.PropertySpecDescriptor searchViewerProperty = transaction.GetPropertyDescriptor(Properties.TRN.SearchViewer);
if (searchViewerProperty.IsApplicable && searchViewerProperty.IsBrowsable && searchViewerProperty.IsDefaultValue)
{
WebPanel viewObject = WebPanel.Get(transaction.Model, instance.Levels[0].View.ObjectName);
if (viewObject != null)
transaction.SetPropertyValue(Properties.TRN.SearchViewer, new KBObjectReference(viewObject));
}
}
catch (Exception e) {
LogLicense.LogEmpty(e.Message + e.StackTrace);
}
}
}
}
private static string UpdateEvents(HPatternInstance instance, HPatternSettings settings, Transaction transaction)
{
BasicParser parser = new BasicParser("");
DeleteGeneratedBlocks(parser);
UpdateEventCodes(instance.Settings, parser);
parser.InsertBefore(0, MenuContext.get(instance.WebObject.Actions).Events());
// Se não vou gerar BC e tenho abas
if (!instance.Transaction.WebBC && instance.Transaction.Form.Tabs.Count > 0)
{
Tab tabs = Tab.getTab(instance.Transaction.Form, transaction);
parser.InsertBefore(0, tabs.Subs());
//parser.InsertBefore(0, TemplateAbas.EventsExtra(instance.Transaction.Form));
}
UpdateEventActions(instance, settings, parser);
UpdateEventPrompts(instance, settings,parser);
UpdateEventAfterTrn(instance, transaction, parser);
UpdateEventStart(instance, settings, transaction, parser);
return parser.Text;
}
private void ChangeDocumentation(DocumentationPart docp, KBObject obj, HPatternInstance wwInstance, HPatternSettings settings)
{
TemplateInternal.DocumentationSave(docp, obj, wwInstance, settings);
}
private void AddFirstLevel(Transaction trn, HPatternInstance instance, IList<TransactionAttribute> fixedAttris)
{
string levelKey = String.Format("{0}:{1}", trn.Guid, trn.Structure.Root.Id);
LevelElement levelElement = instance.AddLevel(levelKey);
levelElement.Name = trn.Name;
AddDescriptionAttribute(levelElement, trn.Structure.Root.DescriptionAttribute);
AddSelection(trn, levelElement);
AddPrompt(trn, levelElement);
if (settings.Template.SuggestView)
{
AddView(trn, levelElement, true, trn.Structure.Root.PrimaryKey, trn.Structure.Root, trn.Name, trn.Description, true, fixedAttris);
}
}
private void Generate(Transaction transaction, HPatternInstance instance)
{
instance.UpdateTransaction = HPatternInstance.UpdateTransactionValue.CreateDefault;
if (instance.Transaction == null)
{
instance.Transaction = new TransactionElement();
}
instance.Transaction.Transaction = transaction;
instance.Transaction.BCErrorCode = settings.Template.BCErrorCode;
instance.Transaction.BCSucessCode = settings.Template.BCSucessCode;
HPatternBuildProcess.ClearSuggest();
AddParameters(instance.Transaction.Parameters, true, transaction.Structure.Root.PrimaryKey, new List<TransactionAttribute>());
AddSuggestParameters(instance.Transaction.Parameters, true, false);
AddSuggestActions(instance.Transaction.Actions, instance.Settings,true);
AddFormTransaction(transaction, instance.Transaction.Form);
AddFirstLevel(transaction, instance, new List<TransactionAttribute>());
string tmpn = HPatternBuildProcess.GetSugestName(transaction.Name, instance.Settings);
if (!String.IsNullOrEmpty(tmpn))
instance.Transaction.ObjName = tmpn;
if (instance.Transaction.Form.Tabs.Count == 0 && settings.Template.TabFunction == SettingsTemplateElement.TabFunctionValue.TreeViewAnchor
&& instance.Transaction.Form.Instance.Levels != null && instance.Transaction.Form.Instance.Levels.Count > 0
&& instance.Transaction.Form.Instance.Levels[0].View != null)
{
TabFormElement tabf = instance.Transaction.Form.AddTabForm(transaction.Name);
tabf.Description = transaction.Description;
}
}
private void BuildPrompt(HPatternInstance instance, AttributeElement ae,TransactionAttribute ta,Transaction trn)
{
List<string> listapk = new List<string>();
foreach (AttributeRelation ar in ta.ForeignKeyTo.KeyAttributes)
{
listapk.Add(ar.Related.Name);
}
IEnumerable<WebPanel> listaw = WebPanel.GetAll(instance.Model);
bool geralink = false;
foreach (WebPanel wobj in listaw)
{
// Se este objeto foi gerado pelo Pattern
if (String.IsNullOrEmpty(settings.Template.PromptSuggestNameContains) || wobj.Name.ToLower().IndexOf(settings.Template.PromptSuggestNameContains.ToLower()) >= 0)
{
// Aqui vamos retirar a o loop infinito, então nunca ira sugerir um prompt dele mesmo
bool gera = true;
if (wobj.Parent is PatternInstance)
{
if (((PatternInstance)wobj.Parent).KBObjectKey.Equals(pinstance.KBObjectKey))
gera = false;
}
if (gera)
{
foreach (Signature sig in wobj.GetSignatures())
{
if (sig.ParametersCount > 0)
{
foreach (AttributeRelation ar in ta.ForeignKeyTo.KeyAttributes)
{
geralink = false;
foreach (Parameter par in sig.Parameters)
{
if (par.Object.Name.ToLower().IndexOf(ar.Related.Name.ToLower()) >= 0)
{
geralink = true;
}
}
if (!geralink)
break;
}
if (geralink)
{
LinkElement link = new LinkElement();
ae.Links.Add(link);
link = new LinkElement();
link.WebpanelObject = wobj;
link.Tooltip = wobj.Description;
foreach (AttributeRelation ar in ta.ForeignKeyTo.KeyAttributes)
{
link.Parameters.Add(new ParameterElement(ar.Base.Name));
}
break;
}
}
break;
}
}
}
if (geralink)
{
break;
}
}
}
public static HPatternInstance Load(PatternInstance instance)
{
if (instance == null)
throw new ArgumentNullException("instance");
HPatternInstance cachedWWInstance = instance.GetPropertyValue<HPatternInstance>(k_CacheProperty);
if (cachedWWInstance != null)
return cachedWWInstance;
HPatternInstance wwInstance = new HPatternInstance(instance);
wwInstance.Prepare();
instance.PatternPart.InstanceChanged += new EventHandler<InstanceChangedEventArgs>(wwInstance.AssociatedInstance_InstanceChanged);
instance.SilentSetPropertyValue(k_CacheProperty, wwInstance);
return wwInstance;
}
private static void UpdateEventAfterTrn(HPatternInstance instance, Transaction transaction, BasicParser parser)
{
StringBuilder eventCodeAfterTrn = new StringBuilder();
//if (transaction.IsBusinessComponent)
//{
eventCodeAfterTrn.AppendLine("[web]");
eventCodeAfterTrn.AppendLine("{");
//}
if (instance.Settings.Template.GenerateCallBackLink)
{
eventCodeAfterTrn.AppendLine(Indentation.Indent(String.Format("If &{0}.IsEmpty()", HPatternInstance.PARMCALLBACK), 1));
eventCodeAfterTrn.AppendLine(Indentation.Indent("Return", 2));
eventCodeAfterTrn.AppendLine(Indentation.Indent("Else", 1));
eventCodeAfterTrn.AppendLine(Indentation.Indent(String.Format("PrLinkCallBack(&{0})", HPatternInstance.PARMCALLBACK), 2));
eventCodeAfterTrn.AppendLine(Indentation.Indent("EndIf", 1));
eventCodeAfterTrn.AppendLine("");
}
else
{
bool appendBlankLine = false;
AppendRedirection(instance, eventCodeAfterTrn, "Insert", instance.AfterInsert, ref appendBlankLine);
AppendRedirection(instance, eventCodeAfterTrn, "Update", instance.AfterUpdate, ref appendBlankLine);
// Delete is special because we cannot return to caller when deleting from a view.
if (!AppendRedirection(instance, eventCodeAfterTrn, "Delete", instance.AfterDelete, ref appendBlankLine))
{
SelectionElement emergencyRedirection;
if (instance.Settings.Template.UseTransactionContext && CanRedirectToSelection(instance, out emergencyRedirection))
{
if (appendBlankLine)
eventCodeAfterTrn.AppendLine(String.Empty);
eventCodeAfterTrn.AppendLine("If (&Mode = TrnMode.Delete and not &TrnContext.CallerOnDelete)");
eventCodeAfterTrn.AppendLine(String.Format("\t{0}.Call({1})", emergencyRedirection.ObjectName, emergencyRedirection.Parameters.List()));
eventCodeAfterTrn.Append("Endif");
}
}
}
//if (transaction.IsBusinessComponent)
//{
eventCodeAfterTrn.AppendLine("");
eventCodeAfterTrn.Append("}");
//}
// Add the event (or modify the existing one).
UpdateEventCode(parser, new string[] { "After", "Trn" }, eventCodeAfterTrn.ToString());
}
private void SetObjectsMasterPage(string tipo, bool ar, HPatternInstance wwInstance, InstanceObjectsGroup group, WebPanel masterPage, Theme tTema, string ATema, string AMP)
{
if (group != null && tipo == "p")
{
foreach (WebPanel webPanel in group.GetObjects<WebPanel>())
{
webPanel.SetPropertyValue(Properties.WBP.EncryptUrlParameters, Properties.WBP.EncryptUrlParameters_Values.No);
}
}
if (group != null)
{
foreach (WebPanel webPanel in group.GetObjects<WebPanel>())
{
if (webPanel.IsPropertyDefault(Properties.WBP.MasterPage) || AMP == SettingsThemeElement.SetObjectThemeValue.Force)
{
if (masterPage == null)
{
webPanel.SetPropertyValue(Properties.WBP.MasterPage, new WebPanelReference());
}
else
{
webPanel.SetPropertyValue(Properties.WBP.MasterPage, new WebPanelReference(masterPage));
}
}
if (tTema != null)
{
if (webPanel.IsPropertyDefault(Properties.WBP.Theme) || ATema == SettingsThemeElement.SetObjectThemeValue.Force)
{
webPanel.SetPropertyValue(Properties.WBP.Theme, new KBObjectReference(tTema));
}
}
if (tipo == "p") {
foreach (LevelElement l in wwInstance.Levels) {
foreach (PromptElement p in l.Prompts) {
bool ari = ar;
if (p.AutomaticRefresh.ToLower() == "true")
ari = true;
if (p.AutomaticRefresh.ToLower() == "false")
ari = false;
if (webPanel.Name.ToLower() == p.Name.ToLower()) {
if (ari)
{
webPanel.SetPropertyValue(Properties.WBP.AutomaticRefresh, Properties.WBP.AutomaticRefresh_Values.WhenVariablesInConditionsChange);
}
else
{
webPanel.SetPropertyValue(Properties.WBP.AutomaticRefresh, Properties.WBP.AutomaticRefresh_Values.No);
}
}
}
}
}
if (tipo == "s") {
InstanceObject sl = group.Objects.Find(delegate(InstanceObject iobj) { return iobj.Object == HPatternObject.Selection; });
if (sl != null)
{
if (webPanel.Name == sl.Name) {
foreach (LevelElement l in wwInstance.Levels) {
bool ari = ar;
if (l.Selection.AutomaticRefresh.ToLower() == "true")
ari = true;
if (l.Selection.AutomaticRefresh.ToLower() == "false")
ari = false;
if (ari)
{
webPanel.SetPropertyValue(Properties.WBP.AutomaticRefresh, Properties.WBP.AutomaticRefresh_Values.WhenVariablesInConditionsChange);
}
else
{
webPanel.SetPropertyValue(Properties.WBP.AutomaticRefresh, Properties.WBP.AutomaticRefresh_Values.No);
}
}
}
}
}
}
}
}
private static void UpdateEventPrompts(HPatternInstance instance,HPatternSettings settings, BasicParser parser)
{
string tmp = Helpers.Template.PromptEvents(instance.Transaction.Form, settings);
if (!String.IsNullOrEmpty(tmp))
{
StringBuilder eventCode = new StringBuilder();
//eventCode.AppendLine(Indentation.Indent(k_GeneratedMarkerStart, 1));
eventCode.Append(tmp);
eventCode.Append(Environment.NewLine);
//eventCode.AppendLine(Indentation.Indent(k_GeneratedMarkerEnd, 1));
parser.InsertBefore(0, eventCode.ToString());
}
}
private static void UpdateVariables(HPatternInstance instance, HPatternSettings settings, Transaction transaction)
{
foreach (RowElement row in instance.Transaction.GetRows(""))
{
foreach (ColumnElement col in row.Columns)
{
foreach (VariableElement vare in col.Variables)
{
if (vare.Domain != null) {
Variable var = AddVariable(transaction,vare.Name);
if (var != null)
var.DomainBasedOn = vare.Domain;
}
if (vare.Attribute != null)
{
Variable var = AddVariable(transaction, vare.Name);
if (var != null)
var.AttributeBasedOn = vare.Attribute;
}
}
}
}
Tab tabs = Tab.getTab(instance.Transaction.Form, transaction);
tabs.VariablesTrn();
/*
Variable var2 = AddVariable(transaction, "MenuData");
if (var2 != null)
DataType.ParseInto(transaction.Model, "MenuData", var2);
var2 = AddVariable(transaction, "MenuDataItem");
if (var2 != null)
DataType.ParseInto(transaction.Model, "MenuData.MenuDataItem", var2);
*/
Variable var2 = AddVariable(transaction, "HTTPRequest");
if (var2 != null)
DataType.ParseInto(transaction.Model, "HttpRequest", var2);
var2 = AddVariable(transaction, "n");
if (var2 != null)
{
var2.Type = eDBType.NUMERIC;
var2.Length = 1;
var2.Decimals = 0;
var2.Signed = false;
}
// Add variables for primary key.
foreach (TransactionAttribute trnAtt in transaction.Structure.Root.PrimaryKey)
AddBasedOnVariable(transaction, trnAtt.Name, trnAtt);
// Add variables for Context.
foreach (SettingsContextVariableElement contextVar in settings.Context)
{
Variable var = AddVariable(transaction, contextVar.Name);
if (var != null)
contextVar.SetType(var);
}
// Add variables for Security.
//if (settings.Security.Enabled)
//{
var2 = AddVariable(transaction, "IsAuthorized");
if (var2 != null)
var2.Type = eDBType.Boolean;
//}
if (instance.Transaction.Parameters != null)
{
if (instance.Transaction.Parameters.Count > 0) {
foreach (ParameterElement pare in instance.Transaction.Parameters)
{
if (pare.IsAttribute)
{
TransactionAttribute ta = transaction.Structure.Root.GetAttribute(pare.Name);
if (ta != null)
{
AddBasedOnVariable(transaction, pare.Name, ta);
}
}
else
{
if (!String.IsNullOrEmpty(pare.DomainName))
{
Variable var = AddVariable(transaction, pare.Name.Replace("&",""));
if (var != null)
var.DomainBasedOn = pare.Domain;
}
}
}
}
}
/*
if (instance.Transaction.Form.HasConditionalTabs())
{
Variable var = AddVariable(transaction, "conta");
if (var != null)
{
var.Type = eDBType.NUMERIC;
var.Length = 4;
var.Decimals = 0;
var.Signed = false;
}
}
*/
if (settings.Template.UseTransactionContext)
{
Variable var = AddVariable(transaction, "TrnContext");
if (var != null)
DataType.ParseInto(transaction.Model, "TransactionContext", var);
var = AddVariable(transaction, "WebSession");
if (var != null)
DataType.ParseInto(transaction.Model, "WebSession", var);
if (HasContextAttributes(transaction))
{
// Add variables for Context Attributes (FKs excluding PKs atts)
foreach (TransactionAttribute trnAtt in ContextAttributes(transaction))
AddBasedOnVariable(transaction, "Insert_" + trnAtt.Name, trnAtt);
var = AddVariable(transaction, "TrnContextAtt");
if (var != null)
DataType.ParseInto(transaction.Model, "TransactionContext.Attribute", var);
}
}
addLinkCallBack(instance,transaction.Variables);
MenuContext.get(instance.WebObject.Actions).Variables(transaction.Variables);
}
private static void UpdateEventStart(HPatternInstance instance, HPatternSettings settings, Transaction transaction, BasicParser parser)
{
StringBuilder eventCodeStart = new StringBuilder(100);
eventCodeStart.AppendLine(Messages.VersionHPattern());
Generator.GeneratorParameters parameters = new Generator.GeneratorParameters();
DefaultProvider.PrepareTemplateParameters(parameters);
parameters.Properties["Settings"] = settings;
parameters.Properties["tipo"] = 0;
AppendTemplateOutput(eventCodeStart, "SubLoadContext", parameters);
//if (settings.Security.Enabled)
//{
eventCodeStart.AppendLine("[web]");
eventCodeStart.AppendLine("{");
parameters.Properties["Instance"] = instance;
parameters.Properties["IsTransaction"] = true;
AppendTemplateOutput(eventCodeStart, "SubCheckSecurity", parameters);
//}
if (settings.Security.EventStart != String.Empty)
{
eventCodeStart.AppendLine("");
eventCodeStart.AppendLine(settings.Security.EventStart);
}
eventCodeStart.AppendLine();
eventCodeStart.Append("}");
if (settings.Template.UseTransactionContext)
{
if (eventCodeStart.Length > 0)
eventCodeStart.AppendLine();
eventCodeStart.AppendLine("&TrnContext.FromXml(&WebSession.Get(!\"TrnContext\"))");
if (HasContextAttributes(transaction))
{
eventCodeStart.AppendLine("If (&TrnContext.TransactionName = &Pgmname and &Mode = TrnMode.Insert)");
eventCodeStart.AppendLine("\tFor &TrnContextAtt in &TrnContext.Attributes");
bool first = true;
foreach (TransactionAttribute icAtt in ContextAttributes(transaction))
{
if (first)
{
eventCodeStart.AppendLine("\t\tDo Case");
first = false;
}
eventCodeStart.AppendFormat("\t\t\t// When inserting with instantiated {0}\r\n", icAtt.Name);
eventCodeStart.AppendFormat("\t\t\tCase &TrnContextAtt.AttributeName = !\"{0}\"\r\n", icAtt.Name);
eventCodeStart.AppendFormat("\t\t\t\t&Insert_{0}.FromString(&TrnContextAtt.AttributeValue)\r\n", icAtt.Name);
}
if (!first)
eventCodeStart.AppendLine("\t\tEndcase");
eventCodeStart.AppendLine("\tEndfor");
eventCodeStart.Append("Endif");
}
}
if (settings.Template.EventStart != String.Empty) {
eventCodeStart.AppendLine("");
eventCodeStart.AppendLine(settings.Template.EventStart);
}
eventCodeStart.AppendLine("");
eventCodeStart.AppendLine("[web]");
eventCodeStart.AppendLine("{");
IBaseCollection<RowElement> lista = instance.Transaction.GetRows("",true,true);
foreach (RowElement row in lista)
{
foreach (ColumnElement col in row.Columns)
{
foreach (VariableElement var in col.Variables)
{
if (var.Domain != null || var.Attribute != null)
{
if (!var.Visible || !row.Visible)
{
eventCodeStart.AppendLine("");
eventCodeStart.AppendFormat("&{0}.Visible = false", var.Name);
}
if (!String.IsNullOrEmpty(var.LoadCode))
{
eventCodeStart.AppendLine("");
eventCodeStart.AppendLine(var.LoadCode);
}
if (!String.IsNullOrEmpty(var.LinksEventStart))
{
eventCodeStart.AppendLine("");
eventCodeStart.AppendLine(var.LinksEventStart);
}
}
}
foreach (AttributeElement att in col.Attributes)
{
if (att.Attribute != null)
{
if (!att.Visible || !row.Visible)
{
eventCodeStart.AppendLine("");
eventCodeStart.AppendFormat("{0}.Visible = false", att.AttributeName);
}
if (!String.IsNullOrEmpty(att.LinksEventStart))
{
eventCodeStart.AppendLine("");
eventCodeStart.AppendLine(att.LinksEventStart);
}
if (!String.IsNullOrEmpty(att.EventStart))
{
eventCodeStart.AppendLine("");
eventCodeStart.AppendLine(String.Format(att.EventStart, att.AttributeName, att.AttributeName));
}
}
}
foreach (TextElement text in col.Texts)
{
if (!text.Visible || !row.Visible)
{
eventCodeStart.AppendLine("");
eventCodeStart.AppendFormat("{0}.Visible = false", text.Name);
}
}
}
}
//}
bool setFocus = instance.Transaction.GetSetFocus;
/*
settings.Template.TransactionSetFocus;
if (instance.Transaction.SetFocus.ToLower() == "true")
setFocus = true;
if (instance.Transaction.SetFocus.ToLower() == "true")
setFocus = false;
*/
Artech.Genexus.Common.Objects.Attribute setFocusAtt = instance.Transaction.SetFocusAttribute;
if (setFocusAtt == null && transaction.Structure.Root.DescriptionAttribute != null)
{
setFocusAtt = transaction.Structure.Root.DescriptionAttribute.Attribute;
}
if (setFocus && setFocusAtt != null)
{
eventCodeStart.AppendLine();
eventCodeStart.AppendLine(setFocusAtt.Name + ".SetFocus()");
}
eventCodeStart.AppendLine("");
// Se não vou gerar BC e tenho abas
if (!instance.Transaction.WebBC && instance.Transaction.Form.Tabs.Count > 0)
{
Tab tabs = Tab.getTab(instance.Transaction.Form, transaction);
eventCodeStart.Append(tabs.Events());
//eventCodeStart.Append( TemplateAbas.Start(instance.Transaction.Form));
}
eventCodeStart.AppendLine(Helpers.Template.HMaskEventStart(instance.Transaction, "", false));
eventCodeStart.AppendLine("}");
if (!String.IsNullOrEmpty(instance.Transaction.EventStart))
{
eventCodeStart.AppendLine(Indentation.Indent(instance.Transaction.EventStart, 1));
}
if (eventCodeStart.Length > 0)
UpdateEventCode(parser, new string[] { "Start" }, eventCodeStart.ToString());
}
private static void addLinkCallBack(HPatternInstance instance,VariablesPart variables)
{
if (instance.Settings.Template.GenerateCallBackLink)
{
Variable var = AddVariable(variables,HPatternInstance.PARMCALLBACK);
if (var != null)
var.DomainBasedOn = Domain.Get(instance.Model,HPatternInstance.PARMCALLBACK);
}
}
private static string UpdateRules(HPatternInstance instance, HPatternSettings settings, Transaction transaction)
{
StringBuilder rules = new StringBuilder();
StringBuilder eventCodeAfterTrn = new StringBuilder();
//if (transaction.IsBusinessComponent)
//{
rules.AppendLine("[web]");
rules.AppendLine("{");
//}
// Add 'parm' rule
rules.Append(instance.Transaction.GeraParm(false));
// Add Prompts rule
rules.Append(Helpers.Template.PromptRules(instance.Transaction.Form, settings));
// Add 'primary key rules'
foreach (TransactionAttribute trnAtt in transaction.Structure.Root.PrimaryKey)
{
rules.AppendFormat("\r\n{0} = &{0} if not &{0}.IsEmpty();", trnAtt.Name);
bool edita = false;
bool sai = false;
foreach (RowElement row in Helpers.Template.GetRows(instance.Transaction, ""))
{
foreach (ColumnElement col in row.Columns)
{
foreach (AttributeElement att in col.Attributes)
{
if (att.AttributeName == trnAtt.Name)
{
if (att.Readonly || att.Visible == false || row.Visible == false)
{
edita = true;
}
sai = true;
break;
}
}
if (sai)
break;
}
if (sai)
break;
}
if (edita || (transaction.Structure.Root.PrimaryKey.Count == 1 && trnAtt.Attribute.GetPropertyValue<bool>(Properties.ATT.Autonumber)))
rules.AppendFormat("\r\nnoaccept({0});", trnAtt.Name);
else
rules.AppendFormat("\r\nnoaccept({0}) if not &{0}.IsEmpty();", trnAtt.Name);
}
// Add 'noprompt' rule.
rules.AppendFormat("\r\nnoprompt({0});", GetList(transaction.Structure.Root.PrimaryKey));
// Add context rules if applicable.
if (settings.Template.UseTransactionContext)
{
rules.AppendLine();
foreach (TransactionAttribute trnAtt in ContextAttributes(transaction))
{
rules.AppendFormat("\r\n{0} = &Insert_{0} if &Mode = TrnMode.Insert and not &Insert_{0}.IsEmpty();", trnAtt.Name);
rules.AppendFormat("\r\nnoaccept({0}) if &Mode = TrnMode.Insert and not &Insert_{0}.IsEmpty();", trnAtt.Name);
}
}
if (settings.Security.RuleCode != String.Empty) {
rules.AppendLine(settings.Security.RuleCode);
}
rules.AppendLine();
rules.Append(Helpers.Template.HMaskRuleSave(instance.Transaction, "", ""));
rules.AppendLine();
//if (transaction.IsBusinessComponent)
//{
rules.AppendLine("}");
//}
string ruledate = settings.Template.RuleDate;
string valueruledate = settings.Template.ValueRuleDate;
string ruledatetime = settings.Template.RuleDateTime;
string valueruledatetime = settings.Template.ValueRuleDateTime;
string defaultvalue = "";
string defaultrule = "";
IBaseCollection<RowElement> lista = new BaseCollection<RowElement>();
lista = instance.Transaction.GetRows("",true,true);
foreach (RowElement row in lista)
{
foreach (ColumnElement col in row.Columns)
{
foreach (AttributeElement att in col.Attributes)
{
if (att.Attribute != null)
{
// Atributo Requerido
bool required = att.getRequired(transaction);
if (required)
{
string message = settings.Template.RequiredNotNullMessage;
if (att.RequiredMessage != String.Empty && att.RequiredMessage.ToLower() != "default")
{
message = att.RequiredMessage;
}
message = String.Format(message, (att.Description.Substring(0,1) == "=" ? att.Attribute.Description : att.Description ));
if (att.RequiredAfterVal)
{
rules.AppendLine(String.Format("Error('{0}') if {1}.IsEmpty() on AfterValidate;", message, att.AttributeName));
}
else
{
rules.AppendLine(String.Format("Error('{0}') if {1}.IsEmpty();", message, att.AttributeName));
}
}
// Regra para o atributo
defaultvalue = att.ValueRule;
if (defaultvalue == "<default>" || defaultvalue == String.Empty)
{
defaultvalue = "";
switch (att.Attribute.Type)
{
case eDBType.DATE:
defaultvalue = valueruledate;
break;
case eDBType.DATETIME:
defaultvalue = valueruledatetime;
break;
}
}
defaultrule = att.Rule;
if (defaultrule.ToLower() == "<default>")
{
defaultrule = "";
switch (att.Attribute.Type)
{
case eDBType.DATE:
defaultrule = ruledate;
break;
case eDBType.DATETIME:
defaultrule = ruledatetime;
break;
}
}
if (defaultvalue != String.Empty && defaultrule != String.Empty)
{
switch (defaultrule)
{
case AttributeElement.RuleValue.DefaultRule: // "defaultrule":
rules.AppendLine(String.Format("Default({0},{1});", att.AttributeName, defaultvalue));
break;
case AttributeElement.RuleValue.AfterValidate: // "aftervalidate":
rules.AppendLine(String.Format("{0} = {1} On AfterValidate;", att.AttributeName, defaultvalue));
break;
case AttributeElement.RuleValue.AfterInsert:
rules.AppendLine(String.Format("{0} = {1} On AfterInsert;", att.AttributeName, defaultvalue));
break;
case AttributeElement.RuleValue.AfterUpdate:
rules.AppendLine(String.Format("{0} = {1} On AfterUpdate;", att.AttributeName, defaultvalue));
break;
case AttributeElement.RuleValue.AfterDelete:
rules.AppendLine(String.Format("{0} = {1} On AfterDelete;", att.AttributeName, defaultvalue));
break;
case AttributeElement.RuleValue.BeforeValidate:
rules.AppendLine(String.Format("{0} = {1} On BeforeValidate;", att.AttributeName, defaultvalue));
break;
case AttributeElement.RuleValue.BeforeInsert:
rules.AppendLine(String.Format("{0} = {1} On BeforeInsert;", att.AttributeName, defaultvalue));
break;
case AttributeElement.RuleValue.BeforeUpdate:
rules.AppendLine(String.Format("{0} = {1} On BeforeUpdate;", att.AttributeName, defaultvalue));
break;
case AttributeElement.RuleValue.BeforeDelete:
rules.AppendLine(String.Format("{0} = {1} On BeforeDelete;", att.AttributeName, defaultvalue));
break;
}
}
}
}
}
}
//}
string codes = TemplateInternal.RuleCodes(TemplateInternal.CodeType.Transaction, settings);
if (!String.IsNullOrEmpty(codes))
{
rules.Append(codes);
}
return AppendRules(transaction, rules.ToString());
}
private static bool AppendRedirection(HPatternInstance instance, StringBuilder sb, string mode, string option, ref bool appendBlankLine)
{
string redirectionLine = null;
SelectionElement selection;
if (option == HPatternInstance.AfterInsertValue.GoToSelection && CanRedirectToSelection(instance, out selection))
redirectionLine = String.Format("\t{0}.Call({1})", selection.ObjectName, selection.Parameters.List());
ViewElement view;
if (option == HPatternInstance.AfterInsertValue.GoToView && CanRedirectToView(instance, out view))
{
redirectionLine = String.Format("\t{0}.Call({1})", view.ObjectName, view.Parameters.ListView());
}
if (redirectionLine != null)
{
if (appendBlankLine)
sb.AppendLine(String.Empty);
sb.AppendLine(String.Format("If (&Mode = TrnMode.{0})", mode));
sb.AppendLine(redirectionLine);
sb.Append("Endif");
appendBlankLine = true;
return true;
}
return false;
}
public static String GetWidth(String value, HPatternInstance instance)
{
if (String.IsNullOrEmpty(value))
{
return instance.Settings.Grid.GridWidth;
} else {
return value;
}
}
public static HPatternInstance FastLoad(PatternInstance instance)
{
if (instance == null)
throw new ArgumentNullException("instance");
HPatternInstance wwInstance = new HPatternInstance(instance);
return wwInstance;
}
