static public bool IsInterval(Property prop)
{
if (prop.Type != CIMType.DateTime)
{
throw new ArgumentException();
}
try
{
string subtype = string.Empty;
Qualifier subtypeQual = prop.Qualifiers["Subtype"];
subtype = subtypeQual.Value.ToString();
if (subtype.ToUpper() == "INTERVAL")
{
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
static public String GetMethodDescription(String methName,
ManagementObject curObj,
string connectAs,
string pw)
{
try
{
Qualifier descrQual = null;
Method verboseMeth = null;
if (!curObj.Path.IsClass)
{
ManagementClass classObj = WmiHelper.GetClassObject(curObj, connectAs, pw);
verboseMeth = classObj.Methods[methName];
}
else
{
verboseMeth = ((ManagementClass)curObj).Methods[methName];
}
descrQual = verboseMeth.Qualifiers["Description"];
return(descrQual.Value.ToString());
}
catch (Exception)
{
//2880: removed message here
return("");
}
}
internal static Qualifier BuildCanonicalQualifier(Qualifier sourceQualifier, string canonicalName)
{
if (null == sourceQualifier)
{
return(BuildQualifierByFilePathName(canonicalName));
}
Qualifier newQualifier;
switch (sourceQualifier.GuidOrNameCase)
{
case Qualifier.GuidOrNameOneofCase.Anonymous:
throw new ArgumentException($"Source is temporary model qualifier");
case Qualifier.GuidOrNameOneofCase.None:
newQualifier = BuildQualifierByFilePathName(canonicalName);
break;
case Qualifier.GuidOrNameOneofCase.Named:
newQualifier = new Qualifier(sourceQualifier);
newQualifier.Named.Frags.Insert(newQualifier.Named.Frags.Count - 1, canonicalName);
break;
default:
throw new NotImplementedException();
}
return(newQualifier);
}
static public String GetPropertyDescription(String propName,
ManagementObject curObj,
string connectAs,
string pw)
{
try
{
if (curObj == null)
{
throw new ArgumentNullException("curObj");
}
Property verboseProp = null;
if (!curObj.Path.IsClass)
{
ManagementObject classObj = WmiHelper.GetClassObject(curObj, connectAs, pw);
verboseProp = classObj.Properties[propName];
}
else
{
verboseProp = curObj.Properties[propName];
}
string descr = string.Empty;
Qualifier descrQual = verboseProp.Qualifiers["Description"];
descr = descrQual.Value.ToString();
return(descr);
}
catch (Exception)
{
return("");
}
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>
/// A hash code for the current object.
/// </returns>
public override int GetHashCode()
{
unchecked
{
return(((Qualifier?.GetHashCode() ?? 0) * 397) ^ (EndpointInstance?.GetHashCode() ?? 0));
}
}
public override void VisitQualifier(Qualifier n)
{
n.Expression.Visit(this);
switch (n.Type.ToLower())
{
case "date":
_lastSeenType = n.InternalType = new TypeDate();
break;
case "real":
_lastSeenType = n.InternalType = new TypeReal();
break;
case "integer":
_lastSeenType = n.InternalType = new TypeInteger();
break;
case "string":
_lastSeenType = n.InternalType = new TypeString();
break;
case "boolean":
_lastSeenType = n.InternalType = new TypeBoolean();
break;
default:
throw new Exception("Unknown type qualifier: (" + n.Type + ")");
}
}
public bool TryParse(string mechanism, out Term term)
{
Match match = _mechanismRegex.Match(mechanism);
if (match.Success)
{
string qualifierToken = match.Groups["qualifier"].Value;
string mechanismToken = match.Groups["mechanism"].Value.ToLower();
string argumentToken = match.Groups["argument"].Value;
Qualifier qualifier = _qualifierParser.Parse(qualifierToken);
if (!_parserStrategies.TryGetValue(mechanismToken, out IMechanismParserStrategy strategy))
{
throw new ArgumentException($"No strategy found to process {mechanismToken}");
}
term = strategy.Parse(mechanism, qualifier, argumentToken);
if (qualifier == Qualifier.Unknown)
{
string message = string.Format(SpfParserResource.UnknownQualifierErrorMessage, qualifierToken);
string markdown = string.Format(SpfParserMarkdownResource.UnknownQualifierErrorMessage, qualifierToken);
term.AddError(new Error(Id, ErrorType.Error, message, markdown));
}
return(true);
}
term = null;
return(false);
}
private AbsolutePath GetLogDirectory(ProjectWithPredictions projectFile, Qualifier qualifier)
{
var success = Root.TryGetRelative(PathTable, projectFile.FullPath, out var inFolderPathFromEnlistmentRoot);
Contract.Assert(success);
// We hardcode the log to go under the output directory Logs/MSBuild (and follow the project structure underneath)
// The 'official' log directory (defined by Configuration.Logging) is not stable in CloudBuild across machines, and therefore it would
// introduce cache misses
var result = m_frontEndHost.Configuration.Layout.OutputDirectory
.Combine(PathTable, "Logs")
.Combine(PathTable, "MSBuild")
.Combine(PathTable, inFolderPathFromEnlistmentRoot);
// Build a string with just the qualifier and global property values (e.g. 'debug-x86'). That should be unique enough.
// Projects can be evaluated multiple times with different global properties (but same qualifiers), so just
// the qualifier name is not enough
List <string> values = qualifier.Values.Select(value => value.ToString(m_context.StringTable))
.Union(projectFile.GlobalProperties.Where(kvp => kvp.Key != s_isGraphBuildProperty).Select(kvp => kvp.Value))
.Select(value => PipConstructionUtilities.SanitizeStringForSymbol(value))
.OrderBy(value => value, StringComparer.Ordinal) // Let's make sure we always produce the same string for the same set of values
.ToList();
if (values.Count > 0)
{
var valueIdentifier = string.Join("-", values);
result = result.Combine(PathTable, valueIdentifier);
}
return(result);
}
private bool CheckQualifier(Qualifier qualifier, float currentValue, TransitionData nextItem)
{
float transitionValue = (nextItem.isFloat == 1 ? nextItem.floatValue : nextItem.intValue);
switch (qualifier)
{
case Qualifier.Equal:
return(currentValue == transitionValue);
case Qualifier.LessThan:
return(currentValue < transitionValue);
case Qualifier.LessThanOrEqual:
return(currentValue <= transitionValue);
case Qualifier.MoreThan:
return(currentValue > transitionValue);
case Qualifier.MoreThanOrEqual:
return(currentValue >= transitionValue);
case Qualifier.NotEqual:
return(currentValue != transitionValue);
case Qualifier.None:
return(true);
}
return(false);
}
override public bool Equals(object?obj)
{
if (this == obj)
{
return(true);
}
if (obj == null)
{
return(false);
}
if (!(obj is QualifierValue))
{
return(false);
}
QualifierValue other = (QualifierValue)obj;
if (!Qualifier.Equals(other.Qualifier))
{
return(false);
}
if (!Value.Equals(other.Value))
{
return(false);
}
return(true);
}
/// <summary>
/// A new IFC model from existing internal model.
/// </summary>
/// <param name="model">The model</param>
/// <param name="logger">The log instance</param>
/// <param name="qualifier">The qualifier</param>
/// <returns></returns>
public static IfcModel ByXbimModel(IModel model, Qualifier qualifier, Logger logger)
{
IfcModel ifcModel;
ModelCache.Instance.TryGetOrCreateModel(qualifier, q => new IfcModel(new IfcStore(model, logger), qualifier), out ifcModel);
return(ifcModel);
}
private static T Get <T>(Qualifier qualifier)
{
object f = null;
switch (qualifier?.GuidOrNameCase ?? Qualifier.GuidOrNameOneofCase.None)
{
case Qualifier.GuidOrNameOneofCase.Anonymous:
if (!FunctionCache.TryRemove(qualifier, out f))
{
Log.LogError("{0}: Key '{1}' is not existing.", typeof(DynamicDelegation), qualifier);
}
break;
case Qualifier.GuidOrNameOneofCase.Named:
if (!FunctionCache.TryGetValue(qualifier, out f))
{
Log.LogError("{0}: Key '{1}' is not existing.", typeof(DynamicDelegation), qualifier);
}
break;
default:
Log.LogWarning("{0}: Key '{1}' is not valid.", typeof(DynamicDelegation), qualifier);
break;
}
return((T)f);
}
/// <summary>
/// Writes the specified qualifier.
/// </summary>
/// <param name="qualifiers">
/// The qualifier.
/// </param>
/// <param name="writePreQualifiers">
/// if set to <c>true</c> [write pre qualifiers].
/// </param>
/// <returns>
/// This instance
/// </returns>
public ShaderWriter Write(Qualifier qualifiers, bool writePreQualifiers)
{
if (qualifiers == Qualifier.None)
{
return(this);
}
foreach (var genericQualifier in qualifiers.Values)
{
var qualifier = (Qualifier)genericQualifier;
if (qualifier == Qualifier.None || qualifier.IsPost == writePreQualifiers)
{
continue;
}
if (qualifier.IsPost)
{
Write(" ");
}
VisitDynamic(qualifier);
if (!qualifier.IsPost)
{
Write(" ");
}
}
return(this);
}
/// <summary>
/// Generate Code
/// </summary>
/// <param name="compilationUnit"> Compilation Unit resulting from TypeCobol Parsing</param>
/// <param name="columns">Columns layout</param>
public void Generate(CompilationUnit compilationUnit, ColumnsLayout columns = ColumnsLayout.FreeTextFormat)
{
//Check if there is any error in diags
if (compilationUnit.AllDiagnostics().Any(d => d.Info.Severity == Compiler.Diagnostics.Severity.Error))
{
AnalyticsWrapper.Telemetry.TrackEvent("[Generation] Diagnostics Detected", EventType.Genration);
throw new GenerationException("Unable to generate because of error diagnostics", null, null, false, false);
}
AnalyticsWrapper.Telemetry.TrackEvent("[Generation] Started", EventType.Genration);
// STEP 0: Initialize the global values.
RootNode = compilationUnit.ProgramClassDocumentSnapshot.Root;
SymTable = compilationUnit.ProgramClassDocumentSnapshot.Root.SymbolTable;
Layout = columns;
//Create the Initial target document.
CreateTargetDocument();
// STEP 1: modify tree to adapt it to destination language
// 1.1 Run the Qualifier action on this node
Qualifier qualifier = new Qualifier(this, RootNode);
qualifier.Execute();
// 1.2 Perform other actions
Actions.Perform(RootNode);
// STEP 2: convert tree to destination language code
TreeToCode();
AnalyticsWrapper.Telemetry.TrackEvent("[Generation] Ended", EventType.Genration);
}
internal virtual void PrepMisc(MailMessage mail, Qualifier qualifier)
{
if (Settings.PriorityFunction != null)
{
mail.Priority = Settings.PriorityFunction(qualifier);
}
}
public override void VisitQualifier(Qualifier n)
{
n.Expression.Visit(this);
MethodInfo info = null;
switch (n.Type.ToLower())
{
case "date":
info = typeof(DateTime).GetMethod("Parse", BindingFlags.Public | BindingFlags.Static, null,
new[] { _lastWalkedType }, null);
break;
case "real":
info = typeof(Double).GetMethod("Parse", BindingFlags.Public | BindingFlags.Static, null,
new[] { _lastWalkedType }, null);
break;
case "integer":
info = typeof(Int32).GetMethod("Parse", BindingFlags.Public | BindingFlags.Static, null,
new[] { _lastWalkedType }, null);
break;
case "boolean":
info = typeof(Boolean).GetMethod("Parse", BindingFlags.Public | BindingFlags.Static, null,
new[] { _lastWalkedType }, null);
break;
default:
throw new Exception("Invalid type qualifier: (" + n.Type + ")");
}
_gen.Emit(OpCodes.Call, info);
}
/// <summary>
/// Constructor to build an answer based only on the parameters given. Use this to create an answer
/// based on text fields provided on a web form or when using a large query of answers to be more time
/// efficient.
/// </summary>
/// <param name="ansID"></param>
/// <param name="answer"></param>
/// <param name="score"></param>
/// <param name="qualifier"></param>
public Answer(int ansID, string answer, int score, Qualifier qualifier)
{
this.ansID = ansID;
this.answerText = answer;
this.score = score;
this.qualifier = qualifier;
}
protected void Handle_Click(object sender, EventArgs e)
{
mSurveyData = (Review_Data)Session["survey"];
RadioButtonList rbl = (RadioButtonList)sender;
String RadioButtonListID = rbl.ID; // Comfort, Noise, etc...
int a = 0;
String selection = rbl.SelectedItem.Text; // Poor, Fair, etc..
Survey_Criteria criteria = StringToEnum(RadioButtonListID);
Qualifier q = StringToQualifier(selection);
try
{
mSurveyData.Add(criteria, q);
} catch (Exception ex) {; }
ListItem li = FlightSelection.SelectedItem;
String msg = "";
if (li != null)
{
msg = li.Text;
mLastError = msg;
}
Session["survey"] = mSurveyData;
if (mSurveyData.Count == 5) // we are ready to submit our data
{
Session[SURVEY_READY_FOR_SUBMISSION] = true;
}
else
{
Session[SURVEY_READY_FOR_SUBMISSION] = false;
}
}
private void WriteQualifier(Qualifier q, bool padAfter)
{
if (padAfter)
{
if ((q & Qualifier.Const) != 0)
{
sb.Append("const ");
}
if ((q & Qualifier.Volatile) != 0)
{
sb.Append("volatile ");
}
if ((q & Qualifier.Restricted) != 0)
{
sb.Append("restricted ");
}
}
else
{
if ((q & Qualifier.Const) != 0)
{
sb.Append(" const");
}
if ((q & Qualifier.Volatile) != 0)
{
sb.Append(" volatile");
}
if ((q & Qualifier.Restricted) != 0)
{
sb.Append(" restricted");
}
}
}
public void NotifyMissing(Qualifier qualifier)
{
if (_missingValueAction != null)
{
_missingValueAction(qualifier);
}
}
private void formRepairRange_Shown(object sender, EventArgs e)
{
comboBoxInterpolateMethod.SelectedIndex = 0;
comboBoxRepairInterval.SelectedIndex = 0;
rangeQuality = Qualifier.ProcessRange(range);
if (rangeQuality == null)
{
_ = MessageBox.Show(this, "Произошла ошибка при открытии ряда. Возможно, ряд слишком короткий", "Открытие ряда", MessageBoxButtons.OK, MessageBoxIcon.Warning);
this.Close();
return;
}
labelCompletness.Text = "Полнота ряда: " + (rangeQuality.Completeness * 100).ToString("0.00") + "%";
labelMaxEmptySpace.Text = "Максимальный перерыв в измерениях: " + rangeQuality.MaxEmptySpace.TotalDays.ToString("0.000") + " дней";
labelRangeLength.Text = "Длительность ряда: " + range.Length.ToText();
string dt;
if (rangeQuality.Intervals.Count > 1)
{
StandartIntervals min = rangeQuality.Intervals.Min <RangeInterval, StandartIntervals>((i) => i.Interval);
StandartIntervals max = rangeQuality.Intervals.Max <RangeInterval, StandartIntervals>((i) => i.Interval);
dt = $"минимальный: {min.Description()}, максимальный: {max.Description()}";
}
else
{
dt = rangeQuality.Intervals[0].Interval.Description();
}
labelInterval.Text = "Δt: " + dt;
}
/// <summary>
/// Check compound qualifiers
/// </summary>
/// <param name="qualifiers"></param>
private void CheckQualifiers(Dictionary <string, Qualifier> qualifiers)
{
foreach (Qualifier qual in qualifiers.Values)
{
if (qual.IsCompositeQualifier) //it's a 'compound qualifier'
{
string[] codes = qual.Code.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
string description = "";
foreach (string code in codes)
{
Qualifier matchingQual = qualifiers[code];
description += matchingQual.Description + ", ";
}
description = description.Remove(description.LastIndexOf(","));
qual.Description = description;
}
}
foreach (Qualifier qual in qualifiers.Values)
{
if (String.IsNullOrEmpty(qual.Description))
{
qual.Description = "unknown";
}
}
}
public override Qualifier Select(IContext context)
{
Qualifier bestQualifier = defaultQualifier;
float bestScore = defaultQualifier != null?defaultQualifier.Score(context) : float.MinValue;
for (int i = 0; i < qualifiers.Count; ++i)
{
var qualifier = qualifiers[i];
var score = qualifier.Score(context);
if (score > bestScore)
{
bestScore = score;
bestQualifier = qualifier;
}
}
if (AIDebuggingHook.debugger != null)
{
AIDebuggingHook.debugger.BestQualifier(bestQualifier, this);
}
if (bestQualifier == null)
{
return(null);
}
return(bestQualifier.Select(context));
}
/**
* Add a qualifier.
*
* @param qualifier The qualifier.
*/
public void AddQualifier(Qualifier qualifier)
{
if (this._qualifiers == null)
{
this._qualifiers = new List <Qualifier>();
}
this._qualifiers.Add(qualifier);
}
public static TimeStringFormatter Define(Qualifier qualifier, string suffix)
{
if (string.IsNullOrEmpty(suffix))
{
return(Define(qualifier));
}
return(new TimeStringFormatter(Merge(qualifier.aDay, suffix), Merge(qualifier.days, suffix), Merge(qualifier.aHour, suffix), Merge(qualifier.hours, suffix), Merge(qualifier.aMinute, suffix), Merge(qualifier.minutes, suffix), Merge(qualifier.aSecond, suffix), Merge(qualifier.seconds, suffix), Merge(qualifier.lessThanASecond, suffix)));
}
public static TimeStringFormatter Define(string prefix, Qualifier qualifier)
{
if (string.IsNullOrEmpty(prefix))
{
return(Define(qualifier));
}
return(new TimeStringFormatter(Merge(prefix, qualifier.aDay), Merge(prefix, qualifier.days), Merge(prefix, qualifier.aHour), Merge(prefix, qualifier.hours), Merge(prefix, qualifier.aMinute), Merge(prefix, qualifier.minutes), Merge(prefix, qualifier.aSecond), Merge(prefix, qualifier.seconds), Merge(prefix, qualifier.lessThanASecond)));
}
public void ToSearchQueryWithOneValue()
{
Qualifier qualifier = new Qualifier("state", new string [] {"VIC"});
string query = "upload_qualifiers[0][dataset_attribute_name]=state";
query += "&upload_qualifiers[0][qualifier_values][]=VIC";
Assert.AreEqual(query, qualifier.ToSearchQuery(0));
}
/**
* Add a qualifier.
*
* @param qualifier The qualifier.
*/
public void AddQualifier(Qualifier qualifier)
{
if (_qualifiers == null)
{
_qualifiers = new List <Qualifier>();
}
_qualifiers.Add(qualifier);
}
private static SpfRecord CreateSpfRecord(string value, Qualifier qualifier)
{
All all = new All(value, qualifier);
return(new SpfRecord("", new Version(""), new List <Term> {
all
}, string.Empty));
}
private void sendBCD(uint address, uint value)
{
byte[] dataTx;
////////////// data link layer /////////////////////////////
DataLink_Header DL = new DataLink_Header();
DL.Control = new ControlByte(0xC4); // user data (unconfirm);
DL.Destination = 65535;
DL.Source = 1;
////////////// transport /////////////////////////////
Transport_Header TH = new Transport_Header(0xc0); // transport alway 0xc4 for master
///////////// Application Header /////////////////////////////
Application_Header AP = new Application_Header();
// Application Control
ApplicationControl AC = new ApplicationControl();
AC.FIN = true;
AC.FIR = true;
AC.SEQ = 0;
AP.ApplicationControl = AC;
AP.FunctionCode = 2; // Write Function = 2
//////////////////////////// Object ////////////////////////////////
//----------------------- Object Field---------------------------//
Object_Field[] OF = new Object_Field[1]; //have 1 object type
// Object Header //
Object_Header OH;
Qualifier Q;
ObjectData OD;
// Object Header 1 O:60 V:2
OH = new Object_Header();
OH.ObjectGroup = 101; //Object
OH.ObjectVariation = 2; // Var
Q = new Qualifier(0x17); // Qualifier Code = 0x17 fixed
OH.Qualifier = Q;
OH.Count = 1; // have 1 data object
OF[0] = new Object_Field();
OF[0].ObjectHeader = OH; // Object Header
OD = new ObjectData(); //Data
//Object Data
OD.ObjData = new O101V2(value);
OF[0].Obj = new ObjectData[1];
OD.address = address;
OF[0].Obj[0] = OD;
// move to application header class
AP.Object = OF;
////////////////////////// DNP /////////////////////////////
DNP_Frame dnpFrame = new DNP_Frame(DL, TH, AP);
dataTx = dnpFrame.ToRawData();
this.serialPort1.Write(dataTx, 0, dataTx.Length);
}
// Module defining this command
// Optional custom code for this activity
/// <summary>
/// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run.
/// </summary>
/// <param name="context">The NativeActivityContext for the currently running activity.</param>
/// <returns>A populated instance of System.Management.Automation.PowerShell</returns>
/// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks>
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context)
{
System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create();
System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName);
// Initialize the arguments
if (Path.Expression != null)
{
targetCommand.AddParameter("Path", Path.Get(context));
}
if (LiteralPath.Expression != null)
{
targetCommand.AddParameter("LiteralPath", LiteralPath.Get(context));
}
if (Qualifier.Expression != null)
{
targetCommand.AddParameter("Qualifier", Qualifier.Get(context));
}
if (NoQualifier.Expression != null)
{
targetCommand.AddParameter("NoQualifier", NoQualifier.Get(context));
}
if (Parent.Expression != null)
{
targetCommand.AddParameter("Parent", Parent.Get(context));
}
if (Leaf.Expression != null)
{
targetCommand.AddParameter("Leaf", Leaf.Get(context));
}
if (Resolve.Expression != null)
{
targetCommand.AddParameter("Resolve", Resolve.Get(context));
}
if (IsAbsolute.Expression != null)
{
targetCommand.AddParameter("IsAbsolute", IsAbsolute.Get(context));
}
if (Credential.Expression != null)
{
targetCommand.AddParameter("Credential", Credential.Get(context));
}
return(new ActivityImplementationContext()
{
PowerShellInstance = invoker
});
}
public void ToSearchQueryWithMultipleValues()
{
Qualifier qualifier = new Qualifier("state name", new string[] { "VIC", "ACT & NSW" });
string query = "upload_qualifiers[0][dataset_attribute_name]=state+name";
query += "&upload_qualifiers[0][qualifier_values][]=VIC";
query += "&upload_qualifiers[0][qualifier_values][]=ACT+%26+NSW";
Assert.AreEqual(query, qualifier.ToSearchQuery(0));
}
override public int GetHashCode()
{
int prime = 31;
int result = 1;
result = prime * result + Qualifier.GetHashCode();
result = prime * result + Value.GetHashCode();
return(result);
}
/// <summary>
/// Permanently deletes a qualifier from the database and from the study it was being used in.
/// </summary>
/// <param name="qualifier"></param>
/// <param name="study"></param>
public static void DeleteQualifier(Qualifier qualifier, Study study)
{
if (qualifier.QualID <= 0) {
throw new Exception("Invalid qualifier to delete, the qualID = " + qualifier.QualID);
}
if (study.StudyID <= 0) {
throw new Exception("Invalid study to delete, the studyID = " + study.StudyID);
}
string queryString = "delete from Study_Qualifiers where Qual_ID = " + qualifier.QualID + " and Study_ID = " + study.StudyID;
DatabaseQuery query = new DatabaseQuery(queryString, DatabaseQuery.Type.Delete);
}
public void Start()
{
activeMinions = new List<GameObject>();
projectile = this.GetProvider().GetAbility<Projectile>();
spawn = this.GetProvider().GetAbility<Spawn>();
colorChanger = GetComponent<ColorChanger>();
target = GetComponent<Target>();
spawn.Enable(target.Team, new LaneElement[]{GetComponent<LaneElement>()}, colorChanger.color);
teamSelector = TargetManager.IsOpposing(target);
GetComponent<CharacterEventListener>().AddCallback(CharacterEvents.Hit, Activate);
lane = GetComponent<Lane>();
}
public static FunctionStackInfo Create(string file, string name, uint line, uint column, uint bytes, Qualifier qualifiers)
{
return new FunctionStackInfo()
{
Bytes = bytes,
Column = column,
FullPath = file,
FunctionName = name,
Line = line,
Qualifiers = qualifiers
};
}
/// <summary>
/// Constructor used to query the database and create an answer object based on the id
/// passed in. The ID must exist in the database or this will fail.
/// </summary>
/// <param name="ansID"></param>
public Answer(int ansID)
{
string queryString = "select Answer, Rank from Answers where Ans_ID = " + ansID;
DatabaseQuery query = new DatabaseQuery(queryString, DatabaseQuery.Type.Select);
this.answerText = query.Results[0][0];
this.score = Convert.ToInt32(query.Results[0][1]);
this.ansID = ansID;
queryString = "select Qual_ID from Answers where Ans_ID = " + ansID;
query = new DatabaseQuery(queryString, DatabaseQuery.Type.Select);
int qualID = Convert.ToInt32(query.Results[0][0]);
this.qualifier = new Qualifier(qualID);
}
/// <summary>
/// Constructor that queries the database to get all relevant information about a study
/// and create an object out of it. this constructor uses significantly more overhead than
/// the following one so it should only be used if it is not feasible to use the other one.
/// </summary>
/// <param name="studyID"></param>
public Study(int studyID)
{
string queryString = "select name, Description, Incentive, Creation_Date, Expired, Res_ID from Study where Study_ID = " + studyID.ToString();
DatabaseQuery query = new DatabaseQuery(queryString, DatabaseQuery.Type.Select);
this.name = query.Results[0][0];
this.description = query.Results[0][1];
this.incentive = query.Results[0][2];
this.dateCreated = Convert.ToDateTime(query.Results[0][3]);
this.expired = Convert.ToBoolean(Convert.ToInt32(query.Results[0][4]));
this.researcherID = Convert.ToInt32(query.Results[0][5]);
this.studyID = studyID;
queryString = "select Q.Qual_ID, Question, Description, Res_ID from Study_Qualifiers SQ, Qualifiers Q where Study_ID = " + studyID + " and Q.Qual_ID = SQ.Qual_ID";
query = new DatabaseQuery(queryString, DatabaseQuery.Type.Select);
foreach (List<String> result in query.Results) {
int qualID = Convert.ToInt32(result[0]);
string question = result[1];
string description = result[2];
int resID = Convert.ToInt32(result[3]);
Qualifier tempQualifiers = new Qualifier(qualID, question, description, resID);
this.qualifiers.Add(tempQualifiers);
}
}
/// <summary>
/// Inserts a pre-existing qualifier into the Study_Qualifier table.
/// Doesn't insert into the Qualifier table because its pre-existing.
/// </summary>
/// <param name="qualifier"></param>
/// <param name="studyID"></param>
/// <returns></returns>
public static int InsertExisingQualifier(Qualifier qualifier, int studyID)
{
string queryString = "insert into Study_Qualifiers " +
"(Qual_ID, Study_ID) " +
"values " +
"(" + qualifier.QualID + ", " + studyID + ")";
DatabaseQuery query = new DatabaseQuery(queryString, DatabaseQuery.Type.Insert);
return query.LastInsertID;
}
public VagueDate(float startYear, float endYear, float startError, float endError, Qualifier qualifier)
{
StartYear = startYear;
EndYear = endYear;
StartError = startError;
EndError = endError;
DateQualifier = qualifier;
}
/// <summary>
/// Inserts a new qualifier into the database
/// </summary>
/// <param name="qualifier"></param>
/// <returns>Returns the qualifierID</returns>
public static int InsertQualifier(Qualifier qualifier, int studyID)
{
List<string> scrubbedInput = sanitizeInputs(qualifier.Question, qualifier.Description);
string queryString = "insert into Qualifiers " +
"(Question, Description, Res_ID) " +
"values " +
"('" + scrubbedInput[0] + "','" + scrubbedInput[1] + "', " + qualifier.ResID + ")";
DatabaseQuery query = new DatabaseQuery(queryString, DatabaseQuery.Type.Insert);
int qualID = query.LastInsertID;
queryString = "insert into Study_Qualifiers " +
"(Qual_ID, Study_ID) " +
"values " +
"(" + qualID + ", " + studyID + ")";
query = new DatabaseQuery(queryString, DatabaseQuery.Type.Insert);
return qualID;
}
public VagueDate(float startYear, float endYear, float startError, float endError)
{
StartYear = startYear;
EndYear = endYear;
StartError = startError;
EndError = endError;
if (StartError == 0 && EndError == 0 && StartYear == EndYear)
{
DateQualifier = Qualifier.Exact;
}
else if (StartError == 0 && 0 < EndError)
{
DateQualifier = Qualifier.After;
}
else if (EndError == 0 && 0 < StartError)
{
DateQualifier = Qualifier.Before;
}
else if (StartYear != EndYear)
{
DateQualifier = Qualifier.Between;
}
else if (0 < StartError && 0 < EndError)
{
DateQualifier = Qualifier.Circa;
}
}
public VagueDate(float startYear, float endYear, Qualifier qualifier)
{
StartYear = startYear;
EndYear = endYear;
DateQualifier = qualifier;
switch (DateQualifier)
{
case Qualifier.Exact:
StartError = 0;
EndError = 0;
break;
case Qualifier.Circa:
StartError = 10;
EndError = 10;
break;
case Qualifier.Before:
StartError = 10;
EndError = 0;
break;
case Qualifier.After:
StartError = 0;
EndError = 10;
break;
case Qualifier.Between:
StartError = 0;
EndError = 0;
break;
}
}
/// <summary>
/// This is the page load method and is called whenever the ParticipantStudy
/// page is loaded. If the page is a post back it sets the main panel
/// visibility to true. If it is not a post back, the visibility gets set to
/// false. The method sets the study name and description appropriately, and then
/// loads the main qualifier panel with inner panels containing the questions and
/// answers.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Page_Load(object sender, EventArgs e)
{
// Assign our local variables
qualCount = 0; // used to check if all the qualifiers for a study have been previously answered.
bool skipFlag = false; // used to determine if we need to skip a particular qualifier
int partID = ((Participant)Session["user"]).UserID;
study = new Study(Convert.ToInt32(Request.QueryString["study_id"]));
List<int> ansIDs = DAL.GetParticipantAnswers(partID);
List<string> resNameEamil = DAL.GetResearcher(study.ResearcherID);
// Assign all of the qualifiers for the study
studyQualifiers = study.Qualifiers;
if (!IsPostBack) {
pnlQuals.Visible = false;
}
lblName.Text = study.Name;
lblResName.Text = resNameEamil[0];
lblResEmail.Text = resNameEamil[1];
lblDescription.Text = study.Description;
// Logic to go through and check for previously answered Study Qualifiers
for (int i = 0; i < studyQualifiers.Count; i++) {
skipFlag = false;
qual = studyQualifiers[i];
foreach (int id in ansIDs) {
foreach (Answer ans in qual.Answers) {
if (id == ans.AnsID) {
skipFlag = true;
qualCount++;
break;
}
}
if (skipFlag == true) {
break;
}
}
// if the qualifier has previously been answered don't add it to the list,
// if not do add it.
if (skipFlag == true) {
continue;
}
else {
relevantQualifiers.Add(qual);
}
// Create our individual question and answer
pnlQuals.Controls.Add(CreateQuestionAnswer(qual));
pnlQuals.Controls.Add(new LiteralControl("<br />"));
}
}
public static IEnumerable<Target> GetTargets(Qualifier qualifier)
{
return singleton.targets.Where(x => x != null && qualifier(x));
}
public void AddPopulationDataQualifiers(Statement statement, PopulationData data)
{
var pointInTimeQualifier = new Qualifier(statement, SnakType.Value, new EntityId(WikiBase.PropertyIdPointInTime), TimeValue.DateValue(data.referencedate));
// statement.Qualifiers.Add(pointInTimeQualifier); // already added by the constructor
var method = String.Empty;
switch ( data.source )
{
case PopulationDataSourceType.Census:
method = WikiBase.ItemCensuses;
break;
case PopulationDataSourceType.DOPA:
method = WikiBase.ItemRegistration;
break;
}
if ( !String.IsNullOrEmpty(method) )
{
var methodQualifier = new Qualifier(statement, SnakType.Value, new EntityId(WikiBase.PropertyIdDeterminationMethod), new EntityIdValue(new EntityId(method)));
// statement.Qualifiers.Add(methodQualifier); // already added by the constructor
}
}
public void AddCategoryListOf(Item item, Entity entity, EntityType entityType)
{
if ( !item.Claims.Any(x => x.IsAboutProperty(WikiBase.PropertyIdIsListOf)) )
{
var dataValue = new EntityIdValue(new EntityId(WikiBase.WikiDataItems[entityType]));
var snak = new Snak(SnakType.Value, new EntityId(WikiBase.PropertyIdIsListOf), dataValue);
var claim = item.createStatementForSnak(snak);
claim.save(GetClaimSaveEditSummary(claim));
var dataValue2 = new EntityIdValue(new EntityId(entity.wiki.wikidata));
var qualifier = new Qualifier(claim, SnakType.Value, new EntityId(WikiBase.PropertyIdIsInAdministrativeUnit), dataValue2);
qualifier.Save(GetQualifierSaveEditSummary(qualifier));
}
}
/// <summary>
/// Updates a qualifier. NOTE: the qualifier must have its qualID field properly set or it will throw an exception.
/// </summary>
/// <param name="qualifier"></param>
public static void UpdateQualifier(Qualifier qualifier)
{
List<string> scrubbedInput = sanitizeInputs(qualifier.Question, qualifier.Description);
if (qualifier.QualID <= 0) {
throw new Exception("Invalid qualifier to update, the QualID= " + qualifier.QualID);
}
string queryString = "update Qualifiers set " +
"Question = '" + scrubbedInput[0] + "'," +
"Description = '" + scrubbedInput[1] + "'," +
"Res_ID = " + qualifier.ResID + " " +
"where Qual_ID = " + qualifier.QualID;
DatabaseQuery query = new DatabaseQuery(queryString, DatabaseQuery.Type.Update);
}
/// <summary>
/// Get the default edit summary for a qualifier save.
/// </summary>
/// <param name="value">Qualifier to be parsed.</param>
/// <returns>Edit summary.</returns>
/// <exception cref="ArgumentNullException"><paramref name="value"/> is <c>null</c>.</exception>
public String GetQualifierSaveEditSummary(Qualifier value)
{
if ( value == null )
throw new ArgumentNullException("value");
var result = String.Empty;
// include qualifier info?
if ( String.IsNullOrEmpty(value.Hash) )
{
result = String.Format("Added one qualifier of claim: [[Property:P{0}]]", value.Statement.mainSnak.PropertyId.NumericId);
}
else
{
result = String.Format("Changed one qualifier of claim: [[Property:P{0}]]", value.Statement.mainSnak.PropertyId.NumericId);
}
return result;
}
public virtual void VisitQualifier(Qualifier n)
{
}
protected AbstractSubSonicRelationAttribute(Qualifier qualifier)
{
_qualifier = qualifier;
}
/// <summary>
/// This method takes a single qualifier object as a parameter and returns a
/// panel control. The function of this method is to create individual question
/// and answers. It uses a RadioButtonList as the user functionality. Hence a
/// user will only be able to select one answer per question. The panel acts
/// as our container for the controls. We first add the question, and then add
/// each ListItem to the RadioButtonList. Once all the answers are in the
/// RadioButtonList, we add that to the wrapper panel. Once our panel is all
/// setup we return it.
/// </summary>
/// <param name="question"></param>
/// <returns></returns>
private Panel CreateQuestionAnswer(Qualifier question)
{
Panel panel = new Panel();
Label lblQuest = new Label();
RadioButtonList rbList = new RadioButtonList();
ListItem li = null;
rbList.Font.Size = 12;
lblQuest.Font.Size = 14;
lblQuest.Text = question.Question;
panel.Controls.Add(lblQuest);
panel.Controls.Add(new LiteralControl("<br />"));
for (int i = 0; i < question.Answers.Count; i++) {
li = new ListItem();
li.Text = question.Answers[i].AnswerText;
rbList.Items.Add(li);
}
panel.Controls.Add(rbList);
return panel;
}
/// <summary>
/// Gets all the studies in the database and returns them in a list
/// </summary>
/// <returns></returns>
public static List<Study> GetStudies()
{
List<Study> studies = new List<Study>();
string queryString = "select study_id, name, Description, Incentive, Creation_Date, Expired, Res_ID from Study";
DatabaseQuery query1 = new DatabaseQuery(queryString, DatabaseQuery.Type.Select);
for (int i = 0; i < query1.Results.Count; i++) {
int studyID = Convert.ToInt32(query1.Results[i][0]);
string name = query1.Results[i][1];
string description = query1.Results[i][2];
string incentive = query1.Results[i][3];
DateTime dateCreated = Convert.ToDateTime(query1.Results[i][4]);
bool expired = Convert.ToBoolean(Convert.ToInt32(query1.Results[i][5]));
int researcherID = Convert.ToInt32(query1.Results[i][6]);
List<Qualifier> qualifiers = new List<Qualifier>();
queryString = "select Q.Qual_ID, Question, Description, Res_ID from Study_Qualifiers SQ, Qualifiers Q where Study_ID = " + studyID + " and Q.Qual_ID = SQ.Qual_ID";
DatabaseQuery query2 = new DatabaseQuery(queryString, DatabaseQuery.Type.Select);
foreach (List<String> result in query2.Results) {
int qualID = Convert.ToInt32(result[0]);
string question = result[1];
string qualDescription = result[2];
int resID = Convert.ToInt32(result[3]);
Qualifier tempQualifiers = new Qualifier(qualID, question, description, resID);
qualifiers.Add(tempQualifiers);
}
Study temp = new Study(studyID, name, description, incentive, dateCreated, expired, researcherID, qualifiers);
studies.Add(temp);
}
return studies;
}
/// <summary>
/// Autofills in the forms required for editing a qualifier
/// </summary>
/// <param name="qualifier">The qualifier that is going to be auto-populated</param>
private void fillInQualForms(Qualifier qualifier, bool enabled)
{
tbQualDesc.Text = qualifier.Description;
tbQuestion.Text = qualifier.Question;
//make sure the listbox is empty before populating it
lbAnswerList.Items.Clear();
//go through each answer in the qualifier and add it to the listbox
foreach (Answer answer in qualifier.Answers) {
ListItem item = new ListItem(answer.AnswerText + " [" + answer.Score.ToString() + "]", answer.AnsID.ToString());
lbAnswerList.Items.Add(item);
}
if (enabled) {
foreach (Control control in pnlNewQuals.Controls) {
if (control is WebControl) {
WebControl webControl = (WebControl)control;
webControl.Enabled = true;
}
}
}
else {
foreach (Control control in pnlNewQuals.Controls) {
if (control is WebControl) {
WebControl webControl = (WebControl)control;
if (webControl.ID != btnContinue.ID && webControl.ID != btnQualCancel.ID) {
webControl.Enabled = false;
}
}
}
}
}
/// <summary>
/// Returns all of the qualifiers in the database.
/// </summary>
/// <param name="parID"></param>
/// <returns></returns>
public static List<Qualifier> GetQualifiers(int parID)
{
string queryString = "select distinct Qual_ID from Answers " +
"where Qual_ID not in(select Qual_ID from Answers As A " +
"inner join Participant_Answers As PA on A.Ans_ID = PA.Ans_ID " +
"where PA.Par_ID = " + parID.ToString() + ")";
Qualifier qual = null;
List<Qualifier> quals = new List<Qualifier>();
DatabaseQuery query = new DatabaseQuery(queryString, DatabaseQuery.Type.Select);
for (int i = 0; i < query.Results.Count; i++) {
qual = new Qualifier(Convert.ToInt32(query.Results[i][0]));
quals.Add(qual);
}
return quals;
}
public CaTypeQualifiedNumber() {
m_qfr = Qualifier.AtLeast;
}
/// <summary>
/// This method takes all the information from the answer and qualifier fields and
/// populates the database. It will first populate the Qualifier table, then it
/// will populate the Study_Qualifier table, and finally it will populate the
/// Answer table. It will then clear all the text fields and the user may provide
/// another qualifier.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnSaveQualifier(object sender, EventArgs e)
{
List<Answer> answersInListBox = new List<Answer>();
int studyID;
//error checking to make sure they filled out all of the forms correctly
if (tbQuestion.Text.Equals(string.Empty) || lbAnswerList.Items.Count == 0) {
lblErrorCont.Visible = true;
return;
}
lblErrorCont.Visible = false;
//code to save the qualifier if it was selected from the list of previously created qualifiers
foreach (Qualifier existingQual in existingQualList) {
// we only need to enter this logic when the qualifier is new
if ((existingQual.Question.Equals(tbQuestion.Text)) && (((bool)Session["qualIsNew"]) == true)) {
study.Qualifiers.Add(existingQual);
studyID = -1;
if (isEdit) {
studyID = Convert.ToInt32(Request.QueryString["study_id"]);
}
study = new Study(studyID, tbName.Text, tbDescription.Text, tbIncentive.Text, DateTime.Now, cbStdExpired.Checked, ((Researcher)(Session["user"])).UserID, study.Qualifiers);
Session["study"] = study;
// clear the contents of the fields for new entries
tbQualDesc.Text = string.Empty;
tbQuestion.Text = string.Empty;
tbAnswer.Text = string.Empty;
tbScore.Text = string.Empty;
lbAnswerList.Items.Clear();
populateQualifiers(study.Qualifiers);
Session["qualEditIndex"] = -1;
pnlQuals.Visible = false;
pnlExistingQuals.Visible = true;
return;
}
}
Qualifier qualifier = null;
int qualID = ((lbQualifiers.Items.Count+1)*-1);
if (qualEditIndex > -1) {
qualID = study.Qualifiers[qualEditIndex].QualID;
}
qualifier = new Qualifier(qualID, tbQuestion.Text, tbQualDesc.Text, Convert.ToInt32(((Researcher)Session["user"]).UserID));
//clear all of the answers and then add them in one at a time to the qualifier
qualifier.Answers.Clear();
foreach (ListItem item in lbAnswerList.Items) {
List<String> ansRank = sepearateAnswerAndRank(item.Text);
string ans = ansRank[0];
int rank = Convert.ToInt32(ansRank[1]);
int ansID = -1;
if (Convert.ToInt32(item.Value) > 0) {
ansID = Convert.ToInt32(item.Value);
}
Answer answer = new Answer(ansID, ans, rank, qualifier);
qualifier.Answers.Add(answer);
}
//qualifier doesn't exist, add it to the list
if (qualifier.QualID < 0) {
study.Qualifiers.Add(qualifier);
}
//qualifier already exists, we are just updating it, remove the old one and replace it with the new one
else {
study.Qualifiers.Remove(study.Qualifiers[qualEditIndex]);
study.Qualifiers.Add(qualifier);
}
studyID = -1;
if (isEdit) {
studyID = Convert.ToInt32(Request.QueryString["study_id"]);
}
study = new Study(studyID, tbName.Text, tbDescription.Text, tbIncentive.Text, DateTime.Now, cbStdExpired.Checked, ((Researcher)(Session["user"])).UserID, study.Qualifiers);
Session["study"] = study;
// clear the contents of the fields for new entries
tbQualDesc.Text = string.Empty;
tbQuestion.Text = string.Empty;
tbAnswer.Text = string.Empty;
tbScore.Text = string.Empty;
lbAnswerList.Items.Clear();
populateQualifiers(study.Qualifiers);
Session["qualEditIndex"] = -1;
pnlQuals.Visible = false;
pnlExistingQuals.Visible = true;
}
/// <summary>
/// This method takes the raw data that is in the dictionary and constructs the
/// list of qualifiers from it.
/// </summary>
/// <param name="rawData">raw data is in the form of a dictionary</param>
/// <returns>returns the list of qualifiers constructed from the dictionary</returns>
private List<Qualifier> ConstructQualifiers(Dictionary<int, List<List<string>>> rawData)
{
Dictionary<int, List<List<string>>> qualifiersRaw = DAL.GetAllQualifiers();
List<Qualifier> qualifiers = new List<Qualifier>();
List<Answer> answers = null;
Qualifier qualifier = null;
Answer answer = null;
bool exists = false;
int index = 0;
// iterate through each answer in the raw dictionary
foreach (KeyValuePair<int, List<List<string>>> kvp in qualifiersRaw) {
exists = false;
answers = new List<Answer>();
//iterate through each record in the raw qualifier
foreach (List<string> record in kvp.Value) {
for (int i = 0; i < qualifiers.Count; i++) {
if (qualifiers[i].QualID == Convert.ToInt32(record[0])) {
exists = true;
index = i;
break;
}
}
if (exists == false) {
qualifier = new Qualifier(Convert.ToInt32(record[0]), record[1], record[2], Convert.ToInt32(record[3]), new List<Answer>());
answer = new Answer(Convert.ToInt32(record[4]), record[5], Convert.ToInt32(record[6]), qualifier);
answers.Add(answer);
qualifier.Answers.Add(answer);
qualifiers.Add(qualifier);
}
else {
answer = new Answer(Convert.ToInt32(record[4]), record[5], Convert.ToInt32(record[6]), qualifiers[index]);
answers.Add(answer);
qualifiers[index].Answers.Add(answer);
}
}
}
return qualifiers;
}
private Boolean CreateDateQualifierAndReference(Statement statement, String propertyId, HistoryEntryBase entityHistory)
{
var result = false;
var startDateQualifier = statement.Qualifiers.FirstOrDefault(x => x.PropertyId.PrefixedId == propertyId);
if ( startDateQualifier == null )
{
startDateQualifier = new Qualifier(statement, SnakType.Value, new EntityId(propertyId), TimeValue.DateValue(entityHistory.effective));
result = true;
}
var gazetteReference = entityHistory.Items.FirstOrDefault(x => x is GazetteRelated) as GazetteRelated;
if ( gazetteReference != null )
{
GazetteEntry gazetteAnnouncement = GlobalData.AllGazetteAnnouncements.FindAnnouncement(gazetteReference);
if ( gazetteAnnouncement != null )
{
var snak = new Snak(SnakType.Value, new EntityId(WikiBase.PropertyIdReferenceUrl), new StringValue(gazetteAnnouncement.DownloadUrl.AbsoluteUri));
var startDateReference = statement.CreateReferenceForSnak(snak);
result = true;
}
}
return result;
}
public VagueDate(float startYear, float endYear, float fuzziness, Qualifier qualifier)
{
StartYear = startYear;
EndYear = endYear;
Fuzziness = fuzziness;
DateQualifier = qualifier;
}
