/// <summary>
/// Fills class name selector with data.
/// </summary>
private void FillClassNameSelector(string assemblyName)
{
// Clear items
drpClassName.DropDownList.Items.Clear();
if (String.IsNullOrEmpty(assemblyName))
{
return;
}
if (MacroProcessor.ContainsMacro(assemblyName))
{
// Include macro value if specified
drpClassName.DropDownList.Items.Add(ClassName);
return;
}
var classes = ClassHelper.GetClasses(assemblyName, Settings);
if (classes != null)
{
// Fill drop-down list
foreach (string className in classes)
{
drpClassName.DropDownList.Items.Add(className);
}
// Select first item if nothing was selected
if ((classes.Count > 0) && !AllowEmpty && (drpClassName.SelectedIndex < 0) && String.IsNullOrEmpty(drpClassName.SelectedValue))
{
drpClassName.SelectedIndex = 0;
}
}
else
{
drpClassName.DropDownList.Items.Add(drpClassName.SelectedValue);
}
}
/// <summary>
/// Returns true if user control is valid.
/// </summary>
public override bool IsValid()
{
string value = uniSelector.TextBoxSelect.Text.Trim();
// If macro or special value, do not validate
if (MacroProcessor.ContainsMacro(value) || value == string.Empty)
{
return(true);
}
try
{
// Check if query exists
QueryInfoProvider.GetQueryInfo(value);
}
catch
{
ValidationError = GetString("query.queryorclassnotexist").Replace("%%code%%", value);
return(false);
}
return(true);
}
/// <summary>
/// Returns true if user control is valid.
/// </summary>
public override bool IsValid()
{
if (SelectionMode == SelectionModeEnum.SingleTextBox)
{
// If macro or special value, do not validate
string value = uniSelector.TextBoxSelect.Text.Trim();
if (!MacroProcessor.ContainsMacro(value) && (value != "") && (value != TreeProvider.ALL_CULTURES))
{
// Check if culture exists
CultureInfo ci = CultureInfoProvider.GetCultureInfo(value);
if (ci == null)
{
ValidationError = GetString("formcontrols_selectculture.notexist").Replace("%%code%%", value);
return(false);
}
else
{
return(true);
}
}
}
return(true);
}
private string Validate(string value, bool allowPreselect)
{
if (!string.IsNullOrEmpty(value))
{
// If alternative form name contains macro or is not full name, it is always valid
if (MacroProcessor.ContainsMacro(value) || !ValidationHelper.IsFullName(value))
{
return(string.Empty);
}
// Try to get alternative form object
AlternativeFormInfo afi = AlternativeFormInfoProvider.GetAlternativeFormInfo(value);
if (afi == null)
{
if (allowPreselect)
{
// Alternative form does not exist
DataClassInfo di = DataClassInfoProvider.GetDataClassInfo(value);
if ((di == null) && (value != string.Empty))
{
return(GetString("altform.selectaltform.notexist").Replace("%%code%%", value));
}
else
{
return(String.Empty);
}
}
else
{
return(GetString("altforms.selectaltform.formnotexist").Replace("%%code%%", value));
}
}
}
return(string.Empty);
}
/// <summary>
/// Returns true if user control is valid.
/// </summary>
public override bool IsValid()
{
bool valid = true;
// Check 'options' validity
if (lstOptions.SelectedIndex == ListSourceIndex)
{
// Some option must be included
if (String.IsNullOrWhiteSpace(txtValue.Text))
{
ValidationError += GetString("TemplateDesigner.ErrorDropDownListOptionsEmpty") + " ";
valid = false;
}
else
{
// Parse lines
int lineIndex;
string[] lines = txtValue.Text.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
for (lineIndex = 0; lineIndex <= lines.GetUpperBound(0); lineIndex++)
{
// Loop through only not-empty lines
string line = lines[lineIndex];
if (!String.IsNullOrWhiteSpace(line))
{
// Get line items
string[] items = line.Replace(SpecialFieldsDefinition.SEMICOLON_TO_REPLACE, SpecialFieldsDefinition.REPLACED_SEMICOLON).Split(';');
// Every line must have value and item element and optionally visibility macro
if (items.Length > 3)
{
ValidationError += GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidFormat") + " ";
valid = false;
break;
}
// Check for possible macro (with/without visibility condition)
if (items.Length <= 2)
{
string specialMacro = items[0].Trim();
// Check if special macro is used
if (SpecialFieldsDefinition.IsSpecialFieldMacro(specialMacro))
{
string macro = (items.Length == 2) ? items[1].Trim() : String.Empty;
// If special field macro used and second item isn't macro show error
if (!String.IsNullOrEmpty(macro) && !MacroProcessor.ContainsMacro(macro))
{
ValidationError += string.Format(GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidMacroFormat"), lineIndex + 1) + " ";
valid = false;
break;
}
}
}
// Validate input value
var checkType = new DataTypeIntegrity(items[0], EditedFieldDataType);
var result = checkType.ValidateDataType();
if (!String.IsNullOrEmpty(result))
{
ValidationError += string.Format(GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidValue"), lineIndex + 1) + " " + result + " ";
valid = false;
break;
}
}
}
}
}
// Check SQL query validity
else if ((lstOptions.SelectedIndex == SqlSourceIndex) && String.IsNullOrWhiteSpace(txtValue.Text))
{
ValidationError += GetString("TemplateDesigner.ErrorDropDownListQueryEmpty") + " ";
valid = false;
}
else if ((lstOptions.SelectedIndex == MacroSourceIndex) && String.IsNullOrWhiteSpace(txtValue.Text))
{
ValidationError += GetString("TemplateDesigner.ErrorDropDownListMacroEmpty") + " ";
valid = false;
}
return(valid);
}
/// <summary>
/// Sets time controls (dropdown with interval and textbox with interval value). Returns true if time controls are to be hided.
/// </summary>
private bool SetTimeControls()
{
HitsIntervalEnum interval = HitsIntervalEnumFunctions.StringToHitsConversion(mIntervalStr);
DateTime from = DateTimeHelper.ZERO_TIME;
DateTime to = DateTimeHelper.ZERO_TIME;
object dcFrom = null;
object dcTo = null;
if (mParameters != null)
{
// Load fromdate and todate from report parameters (passed from query string)
dcFrom = mParameters.Table.Columns["FromDate"];
dcTo = mParameters.Table.Columns["ToDate"];
if (dcFrom != null)
{
from = ValidationHelper.GetDateTime(mParameters["FromDate"], DateTimeHelper.ZERO_TIME);
}
if (dcTo != null)
{
to = ValidationHelper.GetDateTime(mParameters["ToDate"], DateTimeHelper.ZERO_TIME);
}
}
// If one contains zero time, set all time radio button. In such situation, report can maintain unlimited fromdate or todate.
if ((from == DateTimeHelper.ZERO_TIME) || (to == DateTimeHelper.ZERO_TIME))
{
mCheckLast = false;
}
// If one is not set, hide limitdata panel
if ((dcFrom == null) || (dcTo == null))
{
ucInterval.DefaultPeriod = SchedulingHelper.PERIOD_DAY;
return(true);
}
int diff = 0;
bool noAddToDiff = false;
// If interval is not known, but 'from' and 'to' is set (f.e. preview, webpart,..) - compute interval from date values
if (interval == HitsIntervalEnum.None)
{
String sFrom = ValidationHelper.GetString(mParameters["FromDate"], String.Empty).ToLowerCSafe();
String sTo = ValidationHelper.GetString(mParameters["ToDate"], String.Empty).ToLowerCSafe();
mCheckLast = true;
if (MacroProcessor.ContainsMacro(sFrom) && MacroProcessor.ContainsMacro(sTo))
{
if (sFrom.Contains("addhours"))
{
interval = HitsIntervalEnum.Hour;
}
else if (sFrom.Contains("adddays"))
{
interval = HitsIntervalEnum.Day;
}
else if (sFrom.Contains("addweeks"))
{
interval = HitsIntervalEnum.Week;
}
else if (sFrom.Contains("addmonths"))
{
interval = HitsIntervalEnum.Month;
}
else if (sFrom.Contains("addyears"))
{
interval = HitsIntervalEnum.Year;
}
var macroResolverSettings = new MacroSettings
{
AvoidInjection = false,
Culture = CultureHelper.EnglishCulture.Name
};
to = DateTime.Now;
from = ValidationHelper.GetDateTime(MacroResolver.Resolve(sFrom, macroResolverSettings), DateTime.Now, macroResolverSettings.Culture);
noAddToDiff = true;
}
else if ((from != DateTimeHelper.ZERO_TIME) && (to != DateTimeHelper.ZERO_TIME))
{
// Set interval as greatest possible interval (365+ days -> years, 30+days->months ,...)
diff = (int)(to - from).TotalDays;
if (diff >= 365)
{
interval = HitsIntervalEnum.Year;
}
else if (diff >= 30)
{
interval = HitsIntervalEnum.Month;
}
else if (diff >= 7)
{
interval = HitsIntervalEnum.Week;
}
else if (diff >= 1)
{
interval = HitsIntervalEnum.Day;
}
else
{
interval = HitsIntervalEnum.Hour;
}
}
}
// Set default period and diff based on interval
switch (interval)
{
case HitsIntervalEnum.Year:
diff = to.Year - from.Year;
ucInterval.DefaultPeriod = SchedulingHelper.PERIOD_MONTH;
break;
case HitsIntervalEnum.Month:
diff = ((to.Year - from.Year) * 12) + to.Month - from.Month;
ucInterval.DefaultPeriod = SchedulingHelper.PERIOD_MONTH;
break;
case HitsIntervalEnum.Week:
diff = (int)(to - from).TotalDays / 7;
ucInterval.DefaultPeriod = SchedulingHelper.PERIOD_WEEK;
break;
case HitsIntervalEnum.Day:
diff = (int)(to - from).TotalDays;
ucInterval.DefaultPeriod = SchedulingHelper.PERIOD_DAY;
break;
case HitsIntervalEnum.Hour:
diff = (int)(to - from).TotalHours;
ucInterval.DefaultPeriod = SchedulingHelper.PERIOD_HOUR;
break;
case HitsIntervalEnum.None:
mCheckLast = false;
break;
}
// Add current
if (!noAddToDiff)
{
diff++;
}
if (interval != HitsIntervalEnum.None)
{
drpLast.SelectedValue = HitsIntervalEnumFunctions.HitsConversionToString(interval);
}
if (!mCheckLast)
{
// Defaul settings for no time
ucInterval.DefaultPeriod = SchedulingHelper.PERIOD_DAY;
}
if (diff != 0)
{
txtLast.Text = diff.ToString();
}
return(false);
}
/// <summary>
/// Save settings to the form field info.
/// </summary>
public bool Save()
{
if (FieldInfo != null)
{
FieldInfo.Name = GetAttributeName();
FieldInfo.AllowEmpty = AllowEmpty;
FieldInfo.System = IsSystem;
FieldInfo.TranslateField = TranslateField;
FieldInfo.IsUnique = IsUnique;
FieldInfo.ReferenceToObjectType = ReferenceToObjectType;
FieldInfo.ReferenceType = ReferenceType;
if (plcResolveDefaultValue.Visible)
{
FieldInfo.SetResolveDefaultValue(chkResolveDefaultValue.Checked);
}
string defaultValue = null;
bool isMacro;
switch (AttributeType)
{
case FieldDataType.DateTime:
case FieldDataType.Date:
{
string datetimevalue = ValidationHelper.GetString(datetimeDefaultValue.Value, string.Empty);
isMacro = datetimeDefaultValue.IsMacro;
if (isMacro || MacroProcessor.ContainsMacro(datetimevalue))
{
defaultValue = datetimevalue;
}
else if (DateTimeHelper.IsNowOrToday(datetimevalue))
{
defaultValue = datetimevalue;
}
else if (ValidationHelper.GetDateTime(datetimevalue, DateTime.MinValue) == DateTimeHelper.ZERO_TIME)
{
defaultValue = string.Empty;
}
else
{
defaultValue = datetimevalue;
}
}
break;
case FieldDataType.Boolean:
if (AllowEmpty && SystemContext.DevelopmentMode)
{
isMacro = rbDefaultValue.IsMacro;
if (isMacro)
{
defaultValue = ValidationHelper.GetString(rbDefaultValue.Value, string.Empty);
}
else
{
// Positive choice checked - based on ThreeStateCheckBox.ascx
if (rbDefaultValue.Value.Equals(1))
{
defaultValue = "true";
}
// Negative choice checked - based on ThreeStateCheckBox.ascx
if (rbDefaultValue.Value.Equals(0))
{
defaultValue = "false";
}
}
}
else
{
isMacro = chkDefaultValue.IsMacro;
defaultValue = ValidationHelper.GetString(chkDefaultValue.Value, string.Empty);
}
break;
case FieldDataType.LongText:
defaultValue = ValidationHelper.GetString(txtLargeDefaultValue.Value, string.Empty).Trim();
isMacro = txtLargeDefaultValue.IsMacro;
break;
case FormFieldControlTypeCode.DOCUMENT_ATTACHMENTS:
string defValue = ValidationHelper.GetString(txtDefaultValue.Value, string.Empty).Trim();
isMacro = txtDefaultValue.IsMacro;
defaultValue = (string.IsNullOrEmpty(defValue)) ? null : defValue;
break;
default:
if (txtDefaultValue.Visible)
{
defaultValue = ValidationHelper.GetString(txtDefaultValue.Value, string.Empty).Trim();
isMacro = txtDefaultValue.IsMacro;
}
else
{
isMacro = false;
}
break;
}
FieldInfo.SetPropertyValue(FormFieldPropertyEnum.DefaultValue, defaultValue, isMacro);
return(true);
}
return(false);
}
/// <summary>
/// Sets default value according to attribute type.
/// </summary>
public void SetDefaultValue()
{
txtDefaultValue.Value = String.Empty;
txtLargeDefaultValue.Value = String.Empty;
chkDefaultValue.Value = false;
datetimeDefaultValue.Value = DateTimeHelper.ZERO_TIME;
if (FieldInfo != null)
{
bool isMacro;
string defaultValue = FieldInfo.GetPropertyValue(FormFieldPropertyEnum.DefaultValue, out isMacro);
switch (AttributeType)
{
case FieldDataType.DateTime:
case FieldDataType.Date:
{
if (isMacro || MacroProcessor.ContainsMacro(defaultValue))
{
datetimeDefaultValue.SetValue(defaultValue, isMacro);
}
else if (DateTimeHelper.IsNowOrToday(defaultValue))
{
datetimeDefaultValue.SetValue(defaultValue);
}
else if (string.IsNullOrEmpty(defaultValue))
{
datetimeDefaultValue.Value = String.Empty;
}
else
{
datetimeDefaultValue.SetValue(ValidationHelper.GetDateTimeSystem(defaultValue, DateTimeHelper.ZERO_TIME));
}
}
break;
case FieldDataType.Boolean:
if (AllowEmpty && SystemContext.DevelopmentMode)
{
if (isMacro)
{
rbDefaultValue.SetValue(defaultValue, true);
}
else
{
// Set three state checkbox
bool?value = ValidationHelper.GetNullableBoolean(defaultValue, null);
if (value.HasValue)
{
rbDefaultValue.SetValue(value.Value ? 1 : 0);
}
else
{
rbDefaultValue.SetValue(-1);
}
}
}
else
{
chkDefaultValue.SetValue(defaultValue, isMacro);
}
break;
case FieldDataType.LongText:
txtLargeDefaultValue.SetValue(defaultValue, isMacro);
break;
case FieldDataType.Double:
case FieldDataType.Decimal:
if (isMacro || MacroProcessor.ContainsMacro(defaultValue))
{
txtDefaultValue.SetValue(defaultValue, isMacro);
}
else
{
Double dblVal = ValidationHelper.GetDoubleSystem(defaultValue, Double.NaN);
txtDefaultValue.SetValue(!Double.IsNaN(dblVal) ? dblVal.ToString() : null);
}
break;
default:
txtDefaultValue.SetValue(defaultValue, isMacro);
break;
}
}
}
/// <summary>
/// Save button is clicked.
/// </summary>
protected void lnkSave_Click(object sender, EventArgs e)
{
// Check 'EditForm' permission
if (!currentUser.IsAuthorizedPerResource("cms.form", "EditForm"))
{
RedirectToAccessDenied("cms.form", "EditForm");
}
// Validate form
string errorMessage = new Validator().NotEmpty(txtEmailFrom.Text.Trim(), GetString("bizform_edit_autoresponder.emptyemail")).NotEmpty(txtEmailSubject.Text.Trim(), GetString("bizform_edit_autoresponder.emptysubject")).Result;
// Check if from e-mail contains macro expression or e-mails separated by semicolon
if (string.IsNullOrEmpty(errorMessage) && !MacroProcessor.ContainsMacro(txtEmailFrom.Text.Trim()) && !ValidationHelper.IsEmail(txtEmailFrom.Text.Trim()))
{
errorMessage = GetString("bizform_edit_autoresponder.emptyemail");
}
if ((string.IsNullOrEmpty(errorMessage)) || (!pnlCustomLayout.Visible))
{
errorMessage = String.Empty;
if (formInfo != null)
{
// Save custom layout
if (!string.IsNullOrEmpty(drpEmailField.SelectedValue))
{
formInfo.FormConfirmationTemplate = htmlEditor.ResolvedValue.Trim();
formInfo.FormConfirmationEmailField = drpEmailField.SelectedValue;
formInfo.FormConfirmationEmailSubject = txtEmailSubject.Text.Trim();
formInfo.FormConfirmationSendFromEmail = txtEmailFrom.Text.Trim();
try
{
BizFormInfoProvider.SetBizFormInfo(formInfo);
ShowChangesSaved();
EnableDisableForm(formInfo.FormConfirmationTemplate);
}
catch (Exception ex)
{
errorMessage = ex.Message;
}
}
// Delete custom layout if exists
else
{
formInfo.FormConfirmationTemplate = null;
formInfo.FormConfirmationEmailField = drpEmailField.SelectedValue;
formInfo.FormConfirmationEmailSubject = string.Empty;
formInfo.FormConfirmationSendFromEmail = string.Empty;
// Delete all attachments
MetaFileInfoProvider.DeleteFiles(formInfo.FormID, BizFormInfo.OBJECT_TYPE, ObjectAttachmentsCategories.FORMLAYOUT);
try
{
BizFormInfoProvider.SetBizFormInfo(formInfo);
if (IsLayoutSet)
{
ShowConfirmation(GetString("Bizform_Edit_Autoresponder.LayoutDeleted"));
}
else
{
ShowChangesSaved();
}
EnableDisableForm(formInfo.FormConfirmationTemplate);
}
catch (Exception ex)
{
errorMessage = ex.Message;
}
}
}
}
if (!string.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
}
}
/// <summary>
/// Save button is clicked.
/// </summary>
protected void lnkSave_Click(object sender, EventArgs e)
{
// Check 'EditForm' permission
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("cms.form", "EditForm"))
{
RedirectToAccessDenied("cms.form", "EditForm");
}
string errorMessage = null;
if (formInfo != null)
{
if (chkSendToEmail.Checked)
{
// Validate form
errorMessage = new Validator().NotEmpty(txtFromEmail.Text, GetString("BizFormGeneral.EmptyFromEmail"))
.NotEmpty(txtToEmail.Text, GetString("BizFormGeneral.EmptyToEmail"))
.NotEmpty(txtSubject.Text, GetString("BizFormGeneral.EmptyEmailSubject")).Result;
// Check if to e-mail contains macro expression or e-mails separated by semicolon
if (string.IsNullOrEmpty(errorMessage) && !MacroProcessor.ContainsMacro(txtToEmail.Text.Trim()) && !txtToEmail.IsValid())
{
errorMessage = GetString("BizFormGeneral.EmptyToEmail");
}
// Check if from e-mail contains macro expression or e-mails separated by semicolon
if (string.IsNullOrEmpty(errorMessage) && !MacroProcessor.ContainsMacro(txtFromEmail.Text.Trim()) && !txtFromEmail.IsValid())
{
errorMessage = GetString("BizFormGeneral.EmptyFromEmail");
}
if (string.IsNullOrEmpty(errorMessage))
{
formInfo.FormSendFromEmail = txtFromEmail.Text.Trim();
formInfo.FormSendToEmail = txtToEmail.Text.Trim();
formInfo.FormEmailSubject = txtSubject.Text.Trim();
formInfo.FormEmailAttachUploadedDocs = chkAttachDocs.Checked;
if (chkCustomLayout.Checked)
{
formInfo.FormEmailTemplate = htmlEditor.ResolvedValue.Trim();
}
else
{
formInfo.FormEmailTemplate = null;
}
}
}
else
{
formInfo.FormSendFromEmail = null;
formInfo.FormSendToEmail = null;
formInfo.FormEmailSubject = null;
formInfo.FormEmailTemplate = null;
txtToEmail.Text = string.Empty;
txtFromEmail.Text = string.Empty;
txtSubject.Text = string.Empty;
chkAttachDocs.Checked = true;
htmlEditor.ResolvedValue = string.Empty;
}
if (string.IsNullOrEmpty(errorMessage))
{
try
{
BizFormInfo.Provider.Set(formInfo);
ShowChangesSaved();
EnableDisableForm(formInfo.FormEmailTemplate);
}
catch (Exception ex)
{
errorMessage = ex.Message;
}
}
if (!string.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
}
}
}
/// <summary>
/// Returns true if user control is valid.
/// </summary>
public override bool IsValid()
{
bool valid = true;
// Check 'options' validity
if (lstOptions.SelectedIndex == ListSourceIndex)
{
// Some option must be included
if (string.IsNullOrEmpty(txtValue.Text.Trim()))
{
ValidationError += GetString("TemplateDesigner.ErrorDropDownListOptionsEmpty") + " ";
valid = false;
}
else
{
// Parse lines
int lineIndex = 0;
string[] lines = txtValue.Text.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
for (lineIndex = 0; lineIndex <= lines.GetUpperBound(0); lineIndex++)
{
// Loop through only not-empty lines
if ((lines[lineIndex] != null) && (lines[lineIndex].Trim() != string.Empty))
{
// Get line items
string[] items = lines[lineIndex].Replace(SpecialFieldsDefinition.SEMICOLON_TO_REPLACE, SpecialFieldsDefinition.REPLACED_SEMICOLON).Split(';');
// Every line must have value and item element and optionally visibility macro
if (items.Length > 3)
{
ValidationError += GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidFormat") + " ";
valid = false;
break;
}
else
{
// Check for possible macro (with/without visibility condition)
if (items.Length <= 2)
{
string specialMacro = items[0].Trim();
// Check if special macro is used
if (SpecialFieldsDefinition.IsSpecialFieldMacro(specialMacro))
{
string macro = (items.Length == 2) ? items[1].Trim() : String.Empty;
// If special field macro used and second item isn't macro show error
if (!String.IsNullOrEmpty(macro) && !MacroProcessor.ContainsMacro(macro))
{
ValidationError += string.Format(GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidMacroFormat"), lineIndex + 1) + " ";
valid = false;
break;
}
}
}
// Check valid Double format
if (FieldInfo.DataType == FieldDataType.Double)
{
if (!ValidationHelper.IsDouble(items[0]) && !(FieldInfo.AllowEmpty && string.IsNullOrEmpty(items[0])))
{
ValidationError += string.Format(GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidDoubleFormat"), lineIndex + 1) + " ";
valid = false;
break;
}
}
// Check valid Integer format
else if (FieldInfo.DataType == FieldDataType.Integer)
{
if (!ValidationHelper.IsInteger(items[0]) && !(FieldInfo.AllowEmpty && string.IsNullOrEmpty(items[0])))
{
ValidationError += string.Format(GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidIntFormat"), lineIndex + 1) + " ";
valid = false;
break;
}
}
// Check valid Long integer format
else if (FieldInfo.DataType == FieldDataType.LongInteger)
{
if (!ValidationHelper.IsLong(items[0]) && !(FieldInfo.AllowEmpty && string.IsNullOrEmpty(items[0])))
{
ValidationError += string.Format(GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidLongIntFormat"), lineIndex + 1) + " ";
valid = false;
break;
}
}
// Check valid Date time format
else if (FieldInfo.DataType == FieldDataType.DateTime)
{
if ((ValidationHelper.GetDateTime(items[0], DateTimeHelper.ZERO_TIME) == DateTimeHelper.ZERO_TIME) && !FieldInfo.AllowEmpty)
{
ValidationError += string.Format(GetString("TemplateDesigner.ErrorDropDownListOptionsInvalidDateTimeFormat"), lineIndex + 1) + " ";
valid = false;
break;
}
}
}
}
}
}
}
// Check SQL query validity
else if ((lstOptions.SelectedIndex == SqlSourceIndex) && (string.IsNullOrEmpty(txtValue.Text.Trim())))
{
ValidationError += GetString("TemplateDesigner.ErrorDropDownListQueryEmpty") + " ";
valid = false;
}
else if ((lstOptions.SelectedIndex == MacroSourceIndex) && (string.IsNullOrEmpty(txtValue.Text.Trim())))
{
ValidationError += GetString("TemplateDesigner.ErrorDropDownListMacroEmpty") + " ";
valid = false;
}
return(valid);
}
