/// <summary>
/// 创建Condition实例
/// </summary>
/// <param name="name">名称</param>
/// <param name="type">类型</param>
/// <param name="value">值</param>
public Condition(string name, ConditionTypes type, object value = null)
{
_children = new ConditionCollection(this);
_name = name;
_type = type;
_value = value;
}
public FilterOperand(String property, List<String> propertyLevels, ConditionTypes condition, String value)
{
Property = property;
m_PropertyLevels = propertyLevels;
Condition = condition;
Value = value;
}
public FuzzerFilter()
{
Name = string.Empty;
FilterType = FilterTypes.Include;
ConditionType = ConditionTypes.ResponseHTML;
ConditionValue = string.Empty;
}
IEnumerable <SmsTemplatesParams> addTemplateParams <T>(List <T> itemslist, ConditionTypes condition, KeyCharVariables field)
{
var smsParams = new List <SmsTemplatesParams>();
if (itemslist == null || !itemslist.Any())
{
smsParams.Add(new SmsTemplatesParams
{
Value = "-1",
TypeCondition = condition,
Field = field.ToString()
});
}
else
{
itemslist.ForEach(x =>
{
smsParams.Add(new SmsTemplatesParams
{
Value = x.ToString(),
TypeCondition = condition,
Field = field.ToString()
});
});
}
return(smsParams);
}
private void BuildConditions()
{
if (Model.AddValue != 0)
{
_addsubhoursasminutes = DateTimeHelper.RoundToQuoter((int)(60 * Model.AddValue));
}
if (String.IsNullOrEmpty(Model.Data))
{
return;
}
string[] typeValues = Model.Data.Split('#');
try
{
ConditionBase condition = null;
foreach (string param in typeValues)
{
string[] typeAndValue = param.Split('=');
ConditionTypes ct = (ConditionTypes)Convert.ToInt32(typeAndValue[0]);
condition = CreateConditionByType(ct);
if (condition != null)
{
condition.ParseValue(typeAndValue[1]);
if (Conditions == null)
{
_Conditions = new List <ConditionBase>();
}
Conditions.Add(condition);
}
}
}
finally
{
}
}
/// <summary>
/// 构建条件信息
/// </summary>
/// <param name="type">连接符</param>
/// <param name="comparison">比较符</param>
/// <param name="before">前置值</param>
/// <param name="after">后置值</param>
public Condition(ConditionTypes type, Comparisons comparison, IValue before, IValue after) : this()
{
Type = type;
Comparison = comparison;
Before = before;
After = after;
}
public static bool IsIntegerCondition(ConditionTypes conds)
{
ConditionTypes intConditions = ConditionTypes.TimeBetweenPreviousDayWorkingTime |
ConditionTypes.DurationOfWorkingDay;
return((intConditions & conds) != ConditionTypes.Empty);
}
public FilterOperand(String property, List <String> propertyLevels, ConditionTypes condition, String value)
{
Property = property;
m_PropertyLevels = propertyLevels;
Condition = condition;
Value = value;
}
public FuzzerFilter()
{
Name = string.Empty;
FilterType = FilterTypes.Include;
ConditionType = ConditionTypes.ResponseHTML;
ConditionValue = string.Empty;
}
private void RemoveCondition(string Condition)
{
//when AddOnGoingCondition duration expires Condtion is removed
ConditionTypes Cond = (ConditionTypes)Enum.Parse(typeof(ConditionTypes), Condition);
ConditionsInEffect = ConditionsInEffect.Clear(Cond);
}
/// <summary>
/// Initiate Condition class with parameter, value is dependant on the parameter type.
/// </summary>
/// <param name="type">Type of Comparison check</param>
/// <param name="p">Reference to the parameter</param>
/// <param name="value">Value for the condition, type depends on parameter</param>
public Condition(ConditionTypes type, Parameter p, object value)
{
this.type = type;
this.p = p;
switch (p.type)
{
case Parameter.ParamTypes.BOOLEAN:
boolValue = (bool)value;
break;
case Parameter.ParamTypes.INTEGER:
intValue = (int)value;
break;
case Parameter.ParamTypes.FLOAT:
floatValue = (float)value;
break;
case Parameter.ParamTypes.TRIGGER:
break;
}
}
public void TestOriginalSearchByOtherHttpMethod(HttpMethod inputType, ConditionTypes conditionTypes)
{
var request = conditionTypes == ConditionTypes.Menu ? GetOriginalSearchConditionsParameters(ResourceId.Job) : GetOriginalSearchConditionParameters(ResourceId.Job, firstExpectedId);
var handler = new OriginalSearchManager(conditionTypes == ConditionTypes.Dialog ? ConditionEndpoint : null);
var response = handler.OriginalSearch <object>(request, inputType.ToNetHttpMethod());
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.NotFound));
}
public Listing(double price, ConditionTypes condition, Book bookListed, ListingTypes listingType, User listingCreator)
{
Price = price;
Condition = condition;
BookListed = bookListed;
ListingType = listingType;
ListingCreator = listingCreator;
}
public BaseWMItemView(ConditionTypes type, object value, WMItemList parent)
{
Type = type;
Value = value;
_parent = parent;
InitValue();
UpdateName();
}
public static bool IsLGDoubleCondition(ConditionTypes cond)
{
ConditionTypes doubleConditions = ConditionTypes.DurationOfWorkingTime |
ConditionTypes.DurationOfWorkingTimeSingleDay |
ConditionTypes.DurationOfWorkingTimeByMonth |
ConditionTypes.DurationOfWorkingTimeByWeek;
return((cond & doubleConditions) != ConditionTypes.Empty);
}
private void AddCondition(string Condition)
{
//use AddOnGoingCondition
ConditionTypes Cond = (ConditionTypes)Enum.Parse(typeof(ConditionTypes), Condition);
ConditionsInEffect = ConditionsInEffect.Set(Cond);
// msConditions.Add(Cond);
}
public static bool IsEmptyCondition(ConditionTypes conds)
{
ConditionTypes emptyCondidtions =
ConditionTypes.WorkingTimeOutOfOpeningTimeOfStore |
ConditionTypes.WorkingOverEmployeeContractTime |
ConditionTypes.WorkingOverEmployeeCurrentBalanceHours |
ConditionTypes.WorkingOnFeast;
return((emptyCondidtions & conds) != ConditionTypes.Empty);
}
public void SetPlayerHasMoneyCondition(int abstractValueRequired)
{
conditionTypeSet = ConditionTypes.PlayerHasMoney;
if (playerHasMoneyCondition == null)
{
playerHasMoneyCondition = new PlayerHasMoneyCondition();
}
playerHasMoneyCondition.AbstractValue = abstractValueRequired;
}
public void SetCondition(ConditionTypes Condition, bool Status)
{
if (Status == true)
{
ConditionsInEffect = ConditionsInEffect.Set(Condition);
}
else
{
ConditionsInEffect = ConditionsInEffect.Clear(Condition);
}
}
public BaseWMItemView GetItemByType(ConditionTypes type)
{
foreach (BaseWMItemView bi in this)
{
if (bi.Type == type)
{
return(bi);
}
}
throw new Exception("Not found " + type.ToString());
}
public void SetSkillPossessedCondition(CharacterSkills skill, bool doWeWantTheSkill)
{
conditionTypeSet = ConditionTypes.SkillPossessed;
if (skillPossessedCondition == null)
{
skillPossessedCondition = new SkillPossessedCondition();
}
skillPossessedCondition.IsNeeded = doWeWantTheSkill;
skillPossessedCondition.SkillToCheck = skill;
}
public void SetWorldDateCondition(WorldDate date, InequalityTypes beforeOrAfter)
{
conditionTypeSet = ConditionTypes.WorldDate;
if (WorldDate == null)
{
worldDateCondition = new WorldDateCondition();
}
worldDateCondition.Date = date;
worldDateCondition.TimeOrientation = beforeOrAfter;
}
public void SetBackgroundRequiredCondition(BackgroundDefinition background, bool isRequired)
{
conditionTypeSet = ConditionTypes.BackgroundRequired;
if (backgroundRequiredCondition == null)
{
backgroundRequiredCondition = new BackgroundRequiredCondition();
}
backgroundRequiredCondition.Background = background;
backgroundRequiredCondition.Required = isRequired;
}
public void SetAttributeCheckCondition(CharacterAttribute stat, int value, InequalityTypes type)
{
conditionTypeSet = ConditionTypes.AttributeCheck;
if (attributeCheckCondition == null)
{
attributeCheckCondition = new AttributeCheckCondition();
}
attributeCheckCondition.Attribute = stat;
attributeCheckCondition.ValueChecked = value;
attributeCheckCondition.InequalityType = type;
}
public void SetStoryStateHappenedCondition(string plotName, string stateName, bool hasHappened)
{
conditionTypeSet = ConditionTypes.StoryStateHappened;
if (storyStateHappenedCondition == null)
{
storyStateHappenedCondition = new StoryStateHappenedCondition();
}
storyStateHappenedCondition.HasHappened = hasHappened;
storyStateHappenedCondition.PlotName = plotName;
storyStateHappenedCondition.StateName = stateName;
}
public ConditionalFormattingObject(
string name,
ConditionTypes type,
string tvalue1,
string tvalue2,
bool applyToRow)
: base(name, applyToRow)
{
this.conditionType = type;
this.colorConverter = TypeDescriptor.GetConverter(typeof(Color));
this.tValue1 = tvalue1;
this.tValue2 = tvalue2;
}
public void SetStatisticCheckCondition(CharacterStatistic statistic, InequalityTypes ineqType, float valueToCheck)
{
conditionTypeSet = ConditionTypes.StatisticCheck;
if (statisticCheckCondition == null)
{
statisticCheckCondition = new StatisticsCheckCondition();
}
statisticCheckCondition.InequalityType = ineqType;
statisticCheckCondition.Statistic = statistic;
statisticCheckCondition.ValueChecked = valueToCheck;
}
public void SetPlayerHasItemCondition(ItemScript item, int quantity, bool isRequired)
{
conditionTypeSet = ConditionTypes.PlayerHasItem;
if (playerHasItemCondition == null)
{
playerHasItemCondition = new PlayerHasItemCondition();
}
playerHasItemCondition.Item = item;
playerHasItemCondition.Quantity = quantity;
playerHasItemCondition.IsRequired = isRequired;
}
public void SetAttributeTestCondition(CharacterAttribute stat, int mod, CharacterSkills skill)
{
conditionTypeSet = ConditionTypes.AttributeTest;
if (attributeTestCondition == null)
{
attributeTestCondition = new AttributeTestCondition();
}
attributeTestCondition.AttributeMod = mod;
attributeTestCondition.Attribute = stat;
attributeTestCondition.Skill = skill;
}
public static bool IsOnlyMessageCondition(ConditionTypes conds)
{
ConditionTypes messageCondidtions =
ConditionTypes.DurationOfWorkingDay |
ConditionTypes.TimeBetweenPreviousDayWorkingTime |
ConditionTypes.WorkingOverEmployeeCurrentBalanceHours |
ConditionTypes.BalanceHoursReachesCertainAmount |
ConditionTypes.BalanceHoursMustBeZeroEveryWeekMonthYear |
ConditionTypes.WorkingOnSaturdayOrSunday |
ConditionTypes.WorkingOnSunday |
ConditionTypes.SaldoOnCertainWeeks;
return((messageCondidtions & conds) != ConditionTypes.Empty);
}
public MoveData(DataRow row)
{
this.id = (ushort)(long)row["ID"];
this.name = row["Name"] as string;
this.description = row["Description"] as string;
this.type = GetPokemonTypeFromString(row["Type"] as string);
this.power = (byte)(long)row["Power"];
this.accuracy = (byte)(long)row["Accuracy"];
this.pp = (byte)(long)row["PP"];
this.category = GetMoveCategoryFromString(row["Category"] as string);
this.conditionType = GetConditionTypeFromString(row["ConditionType"] as string);
this.contestDescription = row["ContestDescription"] as string;
this.appeal = (byte)(long)row["Appeal"];
this.jam = (byte)(long)row["Jam"];
}
IEnumerable <SmsSendConditions> addSendConditions(string param, ConditionTypes condition, KeyCharVariables kcv)
{
var smsConditions = new List <SmsSendConditions>();
if (!string.IsNullOrEmpty(param))
{
smsConditions.Add(new SmsSendConditions
{
TypeCondition = condition,
Value = param,
Parameter = kcv.ToString()
});
}
return(smsConditions);
}
/// <summary>
/// 向后拼接一个条件连接符。
/// </summary>
/// <param name="conditionType">条件连接符</param>
protected virtual void BuildConditionType(ConditionTypes conditionType)
{
switch (conditionType)
{
case ConditionTypes.And:
BuildCode(Code_And);
break;
case ConditionTypes.Or:
BuildCode(Code_Or);
break;
default:
throw new NotSupportedException();
}
}
public ConditionItemControl(ConditionTypes condition)
{
m_Condition = condition;
Text = condition.ToString();
switch (condition)
{
case ConditionTypes.Equal:
Icon = UriResources.Images.Equal16;
Text = Localization.Filter_Equal;
break;
case ConditionTypes.Contains:
Icon = UriResources.Images.Contain16;
Text = Localization.Filter_Contains;
break;
case ConditionTypes.BeginWith:
Icon = UriResources.Images.BeginWith16;
Text = Localization.Filter_BeginWith;
break;
}
}
private ConditionBase CreateConditionByType(ConditionTypes ct)
{
ConditionBase c = null;
switch (ct)
{
case ConditionTypes.DurationOfWorkingDay: c = new ConditionDurationOfWorkingDaysInRow(); break;
case ConditionTypes.DurationOfWorkingTime: c = new ConditionDurationOfWorkingTime(); break;
case ConditionTypes.DurationOfWorkingTimeByMonth: c = new ConditionDurationOfWorkingTimeOnMonth(); break;
case ConditionTypes.DurationOfWorkingTimeByWeek: c = new ConditionDurationOfWorkingTimeOnWeek(); break;
case ConditionTypes.DurationOfWorkingTimeSingleDay: c = new ConditionDurationOfWorkingTimeOnSingleDay(); break;
case ConditionTypes.TimeBetweenPreviousDayWorkingTime: c = new ConditionTimeBetweenPreviousDayWorkingTime(); break;
case ConditionTypes.WorkingOnFeast: c = new ConditionWorkingOnFeast(); break;
case ConditionTypes.WorkingOnSpecialWeekdays: c = new ConditionWorkingOnSpecialWeekdays(); break;
case ConditionTypes.WorkingOverEmployeeContractTime: c = new ConditionWorkingOverEmployeeContractTime(); break;
case ConditionTypes.WorkingOverEmployeeCurrentBalanceHours: c = new ConditionWorkingOverEmployeeCurrentBalanceHours(); break;
case ConditionTypes.WorkingTimeBetweenSeveralHours: c = new ConditionWorkingTimeBetweenSeveralHours(); break;
case ConditionTypes.WorkingTimeOutOfOpeningTimeOfStore: c = new ConditionWorkingTimeOutOfOpeningStore(); break;
case ConditionTypes.BalanceHoursReachesCertainAmount: c = new ConditionBalanceHoursReachesCertainAmount(); break;
case ConditionTypes.BalanceHoursMustBeZeroEveryWeekMonthYear: c = new ConditionBalanceHoursMustBeZeroEveryWeekMonthYear(); break;
case ConditionTypes.WorkingOnSunday: c = new ConditionWorkingOnSunday(); break;
case ConditionTypes.WorkingOnSaturdayOrSunday: c = new ConditionWorkingOnSundayOrSaturday(); break;
case ConditionTypes.SaldoOnCertainWeeks: c = new ConditionSaldoOnCertainWeeks(); break;
}
if (c != null)
c.Owner = this;
return c;
}
public ConditionBase(ConditionTypes type)
{
_conditionType = type;
}
public Condition(string key, ConditionTypes type, string value)
{
throw new System.NotImplementedException();
}
public static bool IsOnlyMessageCondition(ConditionTypes conds)
{
ConditionTypes messageCondidtions =
ConditionTypes.DurationOfWorkingDay |
ConditionTypes.TimeBetweenPreviousDayWorkingTime |
ConditionTypes.WorkingOverEmployeeCurrentBalanceHours |
ConditionTypes.BalanceHoursReachesCertainAmount |
ConditionTypes.BalanceHoursMustBeZeroEveryWeekMonthYear |
ConditionTypes.WorkingOnSunday |
ConditionTypes.WorkingOnSaturdayOrSunday |
ConditionTypes.SaldoOnCertainWeeks;
return ((messageCondidtions & conds) != ConditionTypes.Empty);
}
public ConditionDurationOfWorkingTimeOnSingleDay(ConditionTypes type)
: base(type)
{
}
