public static List <BSTerm> GetTerms(TermTypes termType, int iTermCount)
{
List <BSTerm> terms = new List <BSTerm>();
using (DataProcess dp = new DataProcess())
{
string top = iTermCount == 0 ? String.Empty : "TOP " + iTermCount;
if (termType != TermTypes.All)
{
dp.AddParameter("Type", termType.ToString().ToLowerInvariant());
dp.ExecuteReader(String.Format("SELECT {0} * FROM Terms WHERE [Type]=@Type ORDER BY [Name] ASC", top));
}
else
{
dp.ExecuteReader(String.Format("SELECT {0} * FROM Terms ORDER BY [Name] ASC", top));
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
terms.Add(bsTerm);
}
}
}
}
return(terms);
}
public static List <BSTerm> GetTermsByObjectID(int objectId, TermTypes termType)
{
List <BSTerm> terms = new List <BSTerm>();
using (DataProcess dp = new DataProcess())
{
dp.AddParameter("ObjectID", objectId);
if (termType != TermTypes.All)
{
dp.AddParameter("Type", termType.ToString().ToLowerInvariant());
dp.ExecuteReader("SELECT * FROM Terms WHERE [TermID] IN (SELECT TermID FROM TermsTo WHERE [ObjectID]=@ObjectID AND [Type]=@Type) ORDER BY Name");
}
else
{
dp.ExecuteReader("SELECT * FROM Terms WHERE [TermID] IN (SELECT TermID FROM TermsTo WHERE [ObjectID]=@ObjectID) ORDER BY Name");
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
terms.Add(bsTerm);
}
}
}
}
return(terms);
}
protected void gvItems_DataBinding(object sender, EventArgs e)
{
string type = Request["type"];
TermTypes termType = TermTypes.Category;
if (!String.IsNullOrEmpty(type))
{
termType = BSTerm.GetTermType(type);
}
List <BSTerm> categories = BSTerm.GetTermsBySubID(termType, 0);
List <string> lstNames = new List <string>();
for (int i = 0; i < categories.Count; i++)
{
string strParents = string.Empty;
BSTerm category = categories[i];
while (category.SubID != 0)
{
BSTerm subCategory = BSTerm.GetTerm(category.SubID);
strParents = subCategory.Name + " > " + strParents;
}
lstNames.Add(strParents + category.Name);
}
((GridView)sender).DataSource = categories;
if (!IsPostBack)
{
ddlParentCategory.Items.Insert(0, new ListItem(Language.Admin["None"], "0"));
}
}
public static string GetTermsByFormat(TermTypes termType, int objectId, int count, string format)
{
List <BSTerm> terms = objectId != 0 ? GetTermsByObjectID(objectId, termType) : GetTerms(termType, count);
string html = String.Empty;
if (terms.Count > 0)
{
foreach (BSTerm term in terms)
{
if (format.Contains("{2}"))
{
html += String.Format(format, BSHelper.GetPermalink("Tag", term.Code, Blogsa.UrlExtension), term.Name, term.Objects.Count);
}
else
{
html += String.Format(format, BSHelper.GetPermalink("Tag", term.Code, Blogsa.UrlExtension), term.Name);
}
}
}
else
{
html = Language.Get["NoTag"];
}
return(html);
}
public static List <BSTerm> GetTermsBySubID(TermTypes termType, int iSubID)
{
List <BSTerm> terms = new List <BSTerm>();
using (DataProcess dp = new DataProcess())
{
if (termType != TermTypes.All)
{
dp.AddParameter("Type", termType.ToString().ToLowerInvariant());
dp.AddParameter("SubID", iSubID);
dp.ExecuteReader("SELECT * FROM Terms WHERE [Type]=@Type AND [SubID]=@SubID ORDER BY [Name] ASC");
}
else
{
dp.AddParameter("SubID", iSubID);
dp.ExecuteReader("SELECT * FROM Terms WHERE [SubID]=@SubID ORDER BY [Name] ASC");
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
terms.Add(bsTerm);
}
}
}
}
return(terms);
}
public Term(String input, TermTypes type, bool autoTrim)
{
TermsAreParameters = false;
Text = autoTrim ? input.Trim() : input;
Type = type;
SubTerms = new List<Term>();
if (Type != TermTypes.SUFFIX && type != TermTypes.BOOLEAN_OPERATOR) processSymbols();
}
public Term(String input, TermTypes type, bool autoTrim)
{
TermsAreParameters = false;
Text = autoTrim ? input.Trim() : input;
Type = type;
SubTerms = new List <Term>();
if (Type != TermTypes.SUFFIX && type != TermTypes.BOOLEAN_OPERATOR)
{
processSymbols();
}
}
public static BSTerm GetTerm(int iTermID, int iSubID, TermTypes type)
{
using (DataProcess dp = new DataProcess())
{
if (iTermID > 0)
{
if (type == TermTypes.All)
{
dp.AddParameter("TermID", iTermID);
dp.ExecuteReader("SELECT * FROM Terms WHERE [TermID] = @TermID");
}
else
{
dp.AddParameter("TermID", iTermID);
dp.AddParameter("Type", type.ToString().ToLowerInvariant());
dp.ExecuteReader("SELECT * FROM Terms WHERE [TermID] = @TermID AND [Type]=@Type");
}
}
else
{
if (type == TermTypes.All)
{
dp.AddParameter("SubID", iSubID);
dp.ExecuteReader("SELECT * FROM Terms WHERE [SubID] = @SubID");
}
else
{
dp.AddParameter("SubID", iSubID);
dp.AddParameter("Type", type.ToString().ToLowerInvariant());
dp.ExecuteReader("SELECT * FROM Terms WHERE [SubID] = @SubID AND [Type]=@Type");
}
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
if (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
return(bsTerm);
}
}
}
}
return(null);
}
public static List <BSPost> GetPostsByTerm(int termId, string code, TermTypes termType, PostTypes postType, PostStates postState)
{
List <BSPost> posts = new List <BSPost>();
using (DataProcess dp = new DataProcess())
{
BSTerm bsTerm = null;
bsTerm = termId != 0 ? BSTerm.GetTerm(termId) : BSTerm.GetTerm(code, termType);
if (bsTerm != null)
{
dp.AddParameter("TermID", bsTerm.TermID);
if (postState != PostStates.All)
{
dp.AddParameter("State", (short)postState);
dp.ExecuteReader("SELECT * FROM Posts WHERE [PostID] IN (SELECT [ObjectID] FROM TermsTo WHERE [TermID]=@TermID) AND [State]=@State ORDER By [CreateDate] DESC");
}
else
{
dp.ExecuteReader("SELECT * FROM Posts WHERE [PostID] IN (SELECT [ObjectID] FROM TermsTo WHERE [TermID]=@TermID) AND [Type]=@Type ORDER By [CreateDate] DESC");
}
}
else
{
return(posts);
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSPost bsPost = new BSPost();
FillPost(dr, bsPost);
posts.Add(bsPost);
}
}
}
}
return(posts);
}
public static TermTypes GetTermType(string termType)
{
TermTypes type = TermTypes.All;
switch (termType)
{
case "tag":
type = TermTypes.Tag;
break;
case "category":
type = TermTypes.Category;
break;
case "linkcategory":
type = TermTypes.LinkCategory;
break;
}
return(type);
}
public static List <BSTerm> GetTermsByContainsName(string name, TermTypes termType, int iTermCount)
{
List <BSTerm> terms = new List <BSTerm>();
using (DataProcess dp = new DataProcess())
{
string top = iTermCount == 0 ? String.Empty : "TOP " + iTermCount;
if (termType != TermTypes.All)
{
string type = termType == TermTypes.Category ? "category" : "tag";
dp.AddParameter("Type", type);
dp.AddParameter("Name", name);
dp.ExecuteReader(String.Format("SELECT {0} * FROM Terms WHERE [Type]=@Type AND [Name] LIKE '%' + @Name + '%' ORDER BY [Name] ASC", top));
}
else
{
dp.AddParameter("Name", name);
dp.ExecuteReader(String.Format("SELECT {0} * FROM Terms WHERE [Name] LIKE '%' + @Name + '%' ORDER BY [Name] ASC", top));
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
terms.Add(bsTerm);
}
}
}
}
return(terms);
}
public static bool RemoveTo(TermTypes termType, int iObjectID)
{
using (DataProcess dp = new DataProcess())
{
if (termType == TermTypes.All)
{
dp.AddParameter("ObjectID", iObjectID);
dp.ExecuteNonQuery("DELETE FROM TermsTo WHERE [ObjectID]=@ObjectID");
}
else
{
dp.AddParameter("Type", termType == TermTypes.Category ? "category" : "tag");
dp.AddParameter("ObjectID", iObjectID);
dp.ExecuteNonQuery("DELETE FROM TermsTo WHERE [Type]=@Type AND [ObjectID]=@ObjectID");
}
if (dp.Return.Status == DataProcessState.Success)
{
return(true);
}
}
return(false);
}
public static BSTerm GetTerm(string code, TermTypes type)
{
using (DataProcess dp = new DataProcess())
{
dp.AddParameter("Code", code);
dp.AddParameter("Type", type.ToString().ToLowerInvariant());
dp.ExecuteReader("SELECT * FROM Terms WHERE [Code] = @Code AND [Type]=@Type");
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
if (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
return(bsTerm);
}
}
}
}
return(null);
}
public DefaultTermValue(object value, double boostValue, TermTypes type)
{
Value = value;
BoostValue = boostValue;
TermType = type;
}
public DefaultTermValue(object value, TermTypes type)
{
Value = value;
TermType = type;
}
public static bool RemoveTo(TermTypes termType, int iObjectID)
{
using (DataProcess dp = new DataProcess())
{
if (termType == TermTypes.All)
{
dp.AddParameter("ObjectID", iObjectID);
dp.ExecuteNonQuery("DELETE FROM TermsTo WHERE [ObjectID]=@ObjectID");
}
else
{
dp.AddParameter("Type", termType == TermTypes.Category ? "category" : "tag");
dp.AddParameter("ObjectID", iObjectID);
dp.ExecuteNonQuery("DELETE FROM TermsTo WHERE [Type]=@Type AND [ObjectID]=@ObjectID");
}
if (dp.Return.Status == DataProcessState.Success)
{
return true;
}
}
return false;
}
// This function pretty much does all the work
private void processSymbols()
{
// Is the input empty?
if (String.IsNullOrEmpty(Text)) return;
// HEADING.. BY is now deprecated in favor of HEADING(x,y), but here it is if you're using it still
Text = Regex.Replace(Text, "HEADING ([ :@A-Za-z0-9\\.\\-\\+\\*/]+) BY ([ :@A-Za-z0-9\\.\\-\\+\\*/]+)", "HEADING($2,$1)", RegexOptions.IgnoreCase);
// Resource tags are now deprecated in favor of SHIP:ResourceName
Text = Regex.Replace(Text, "(\\s|^)<([a-zA-Z]+)>(\\s|$)", " SHIP:$2 ", RegexOptions.IgnoreCase);
// Is this JUST a matched symbol?
String s = matchAt(ref Text, 0, ref allSymbols);
if (s != null && Text.Length == s.Length)
{
if (mathSymbols.Contains(s)) Type = TermTypes.MATH_OPERATOR;
else if (comparisonSymbols.Contains(s)) Type = TermTypes.COMPARISON_OPERATOR;
else if (booleanSymbols.Contains(s)) Type = TermTypes.BOOLEAN_OPERATOR;
return;
}
SubTerms = new List<Term>();
// If this is a parameter list, grab the parameters
if (Type == TermTypes.PARAMETER_LIST)
{
var parameterList = parseParameters(Text);
if (parameterList != null)
{
foreach (String param in parameterList)
{
SubTerms.Add(new Term(param));
}
}
return;
}
// Does this thing contain a boolean operation?
var booleanElements = splitByListIgnoreBracket(Text, ref booleanSymbols);
if (booleanElements != null)
{
Type = TermTypes.BOOLEAN;
foreach (String element in booleanElements)
{
if (booleanSymbols.Contains(element))
{
SubTerms.Add(new Term(element, TermTypes.BOOLEAN_OPERATOR));
}
else
{
SubTerms.Add(new Term(element));
}
}
return;
}
// Does this thing contain a comparison?
var comparisonElements = splitByListIgnoreBracket(Text, ref comparisonSymbols);
if (comparisonElements != null)
{
Type = TermTypes.COMPARISON;
foreach (String element in comparisonElements)
{
SubTerms.Add(new Term(element));
}
return;
}
// Parse this as a normal term
String buffer = "";
for (int i = 0; i < Text.Length; i++)
{
s = matchAt(ref Text, i, ref allSymbols);
if (s == null)
{
buffer += Text[i];
}
else if (s == "(")
{
int startI = i;
Utils.Balance(ref Text, ref i, ')');
if (buffer.Trim() != "")
{
string functionName = buffer.Trim();
buffer = "";
Term bracketTerm = new Term(Text.Substring(startI + 1, i - startI - 1), TermTypes.PARAMETER_LIST);
Term functionTerm = Merge(new Term(functionName), bracketTerm);
functionTerm.Type = TermTypes.FUNCTION;
SubTerms.Add(functionTerm);
}
else
{
SubTerms.Add(new Term(Text.Substring(startI + 1, i - startI - 1)));
}
}
else if (s == "\"")
{
int startI = i;
i = Utils.FindEndOfString(Text, i + 1);
buffer += Text.Substring(startI, i - startI + 1);
}
else if (s == ":")
{
int end = findEndOfSuffix(Text, i + 1);
String suffixName = Text.Substring(i + 1, end - i);
i += end - i;
if (buffer.Trim() != "")
{
SubTerms.Add(new Term(buffer.Trim()));
buffer = "";
}
if (SubTerms.Count > 0)
{
Term last = SubTerms.Last();
SubTerms.Remove(last);
Term structureTerm = Merge(last, new Term(suffixName, TermTypes.SUFFIX));
structureTerm.Type = TermTypes.STRUCTURE;
SubTerms.Add(structureTerm);
}
}
else if (s == "-")
{
if (buffer.Trim() != "" ||
(SubTerms.Count > 0 && SubTerms.Last().Type != TermTypes.MATH_OPERATOR
&& SubTerms.Last().Type != TermTypes.COMPARISON_OPERATOR))
{
// Not a sign, treat as operator
if (buffer.Trim() != "") SubTerms.Add(new Term(buffer.Trim()));
SubTerms.Add(new Term(s));
buffer = "";
i += s.Length - 1;
}
else
{
buffer += Text[i];
}
}
else
{
if (buffer.Trim() != "") SubTerms.Add(new Term(buffer.Trim()));
SubTerms.Add(new Term(s));
buffer = "";
i += s.Length - 1;
}
}
// If there's only one term, we're done!
if (SubTerms.Count == 0)
{
Type = TermTypes.FINAL;
return;
}
if (buffer.Trim() != "") SubTerms.Add(new Term(buffer));
// If I end up with exactly one subTerm, then I AM that subterm. Exception: If I already have a special type
if (SubTerms.Count == 1 && this.Type == TermTypes.REGULAR)
{
Term child = SubTerms[0];
SubTerms.Clear();
CopyFrom(ref child);
}
}
public static BSTerm GetTerm(string code, TermTypes type)
{
using (DataProcess dp = new DataProcess())
{
dp.AddParameter("Code", code);
dp.AddParameter("Type", type.ToString().ToLowerInvariant());
dp.ExecuteReader("SELECT * FROM Terms WHERE [Code] = @Code AND [Type]=@Type");
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
if (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
return bsTerm;
}
}
}
}
return null;
}
public static List<BSTerm> GetTerms(TermTypes termType)
{
return GetTerms(termType, 0);
}
private void processSymbols()
{
// Is the input empty?
if (String.IsNullOrEmpty(Text))
{
return;
}
// HEADING.. BY is now deprecated in favor of HEADING(x,y), but here it is if you're using it still
Text = Regex.Replace(Text, "HEADING ([ :@A-Za-z0-9\\.\\-\\+\\*/]+) BY ([ :@A-Za-z0-9\\.\\-\\+\\*/]+)", "HEADING($2,$1)", RegexOptions.IgnoreCase);
//enables scientific notation eg 6.6E-11 -> 6.6*10^-11
Text = Regex.Replace(Text, "(\\d)E([-+]{1}[0-9]+)", "$1*10^$2");
// Resource tags are now deprecated in favor of SHIP:ResourceName
Text = Regex.Replace(Text, "(\\s|^)<([a-zA-Z]+)>(\\s|$)", " SHIP:$2 ", RegexOptions.IgnoreCase);
// Is this JUST a matched symbol?
String s = MatchAt(ref Text, 0, allSymbols);
if (s != null && Text.Length == s.Length)
{
if (mathSymbols.Contains(s))
{
Type = TermTypes.MATH_OPERATOR;
}
else if (comparisonSymbols.Contains(s))
{
Type = TermTypes.COMPARISON_OPERATOR;
}
else if (booleanSymbols.Contains(s))
{
Type = TermTypes.BOOLEAN_OPERATOR;
}
return;
}
SubTerms = new List <Term>();
// If this is a parameter list, grab the parameters
if (Type == TermTypes.PARAMETER_LIST)
{
var parameterList = parseParameters(Text);
if (parameterList != null)
{
foreach (String param in parameterList)
{
SubTerms.Add(new Term(param));
}
}
return;
}
// Does this thing contain a boolean operation?
var booleanElements = splitByListIgnoreBracket(Text, ref booleanSymbols);
if (booleanElements != null)
{
Type = TermTypes.BOOLEAN;
foreach (String element in booleanElements)
{
if (booleanSymbols.Contains(element))
{
SubTerms.Add(new Term(element, TermTypes.BOOLEAN_OPERATOR));
}
else
{
SubTerms.Add(new Term(element));
}
}
return;
}
// Does this thing contain a comparison?
var comparisonElements = splitByListIgnoreBracket(Text, ref comparisonSymbols);
if (comparisonElements != null)
{
Type = TermTypes.COMPARISON;
foreach (String element in comparisonElements)
{
SubTerms.Add(new Term(element));
}
return;
}
// Does this thing contain an Index?
var listElements = splitByListIgnoreBracket(Text, ref listaccessSymbols);
if (listElements != null)
{
Type = TermTypes.INDEX;
foreach (var element in listElements)
{
if (listaccessSymbols.Contains(element))
{
SubTerms.Add(new Term(element, TermTypes.INDEX_OPERATOR));
}
else
{
SubTerms.Add(new Term(element));
}
}
return;
}
// Parse this as a normal term
String buffer = "";
for (int i = 0; i < Text.Length; i++)
{
s = MatchAt(ref Text, i, allSymbols);
if (s == null)
{
buffer += Text[i];
}
else if (s == "(")
{
int startI = i;
Utils.Balance(ref Text, ref i, ')');
if (buffer.Trim() != "")
{
string functionName = buffer.Trim();
buffer = "";
Term bracketTerm = new Term(Text.Substring(startI + 1, i - startI - 1), TermTypes.PARAMETER_LIST);
Term functionTerm = Merge(new Term(functionName), bracketTerm);
functionTerm.Type = TermTypes.FUNCTION;
SubTerms.Add(functionTerm);
}
else
{
SubTerms.Add(new Term(Text.Substring(startI + 1, i - startI - 1)));
}
}
else if (s == "\"")
{
int startI = i;
i = Utils.FindEndOfString(Text, i + 1);
buffer += Text.Substring(startI, i - startI + 1);
}
else if (s == ":")
{
int end = findEndOfSuffix(Text, i + 1);
String suffixName = Text.Substring(i + 1, end - i);
i += end - i;
if (buffer.Trim() != "")
{
SubTerms.Add(new Term(buffer.Trim()));
buffer = "";
}
if (SubTerms.Count > 0)
{
Term last = SubTerms.Last();
SubTerms.Remove(last);
Term structureTerm = Merge(last, new Term(suffixName, TermTypes.SUFFIX));
structureTerm.Type = TermTypes.STRUCTURE;
SubTerms.Add(structureTerm);
}
}
else if (s == "-")
{
if (buffer.Trim() != "" ||
(SubTerms.Count > 0 && SubTerms.Last().Type != TermTypes.MATH_OPERATOR &&
SubTerms.Last().Type != TermTypes.COMPARISON_OPERATOR))
{
// Not a sign, treat as operator
if (buffer.Trim() != "")
{
SubTerms.Add(new Term(buffer.Trim()));
}
SubTerms.Add(new Term(s));
buffer = "";
i += s.Length - 1;
}
else
{
buffer += Text[i];
}
}
else
{
if (buffer.Trim() != "")
{
SubTerms.Add(new Term(buffer.Trim()));
}
SubTerms.Add(new Term(s));
buffer = "";
i += s.Length - 1;
}
}
// If there's only one term, we're done!
if (SubTerms.Count == 0)
{
Type = TermTypes.FINAL;
return;
}
if (buffer.Trim() != "")
{
SubTerms.Add(new Term(buffer));
}
// If I end up with exactly one subTerm, then I AM that subterm. Exception: If I already have a special type
if (SubTerms.Count == 1 && this.Type == TermTypes.REGULAR)
{
Term child = SubTerms[0];
SubTerms.Clear();
CopyFrom(ref child);
}
}
public static List<BSTerm> GetTermsByContainsName(string name, TermTypes termType, int iTermCount)
{
List<BSTerm> terms = new List<BSTerm>();
using (DataProcess dp = new DataProcess())
{
string top = iTermCount == 0 ? String.Empty : "TOP " + iTermCount;
if (termType != TermTypes.All)
{
string type = termType == TermTypes.Category ? "category" : "tag";
dp.AddParameter("Type", type);
dp.AddParameter("Name", name);
dp.ExecuteReader(String.Format("SELECT {0} * FROM Terms WHERE [Type]=@Type AND [Name] LIKE '%' + @Name + '%' ORDER BY [Name] ASC", top));
}
else
{
dp.AddParameter("Name", name);
dp.ExecuteReader(String.Format("SELECT {0} * FROM Terms WHERE [Name] LIKE '%' + @Name + '%' ORDER BY [Name] ASC", top));
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
terms.Add(bsTerm);
}
}
}
}
return terms;
}
public static string GetTermsByFormat(TermTypes termType, int objectId, int count, string format)
{
List<BSTerm> terms = objectId != 0 ? GetTermsByObjectID(objectId, termType) : GetTerms(termType, count);
string html = String.Empty;
if (terms.Count > 0)
{
foreach (BSTerm term in terms)
{
if (format.Contains("{2}"))
html += String.Format(format, BSHelper.GetPermalink("Tag", term.Code, Blogsa.UrlExtension), term.Name, term.Objects.Count);
else
html += String.Format(format, BSHelper.GetPermalink("Tag", term.Code, Blogsa.UrlExtension), term.Name);
}
}
else
{
html = Language.Get["NoTag"];
}
return html;
}
public static List<BSTerm> GetTermsByObjectID(int objectId, TermTypes termType)
{
List<BSTerm> terms = new List<BSTerm>();
using (DataProcess dp = new DataProcess())
{
dp.AddParameter("ObjectID", objectId);
if (termType != TermTypes.All)
{
dp.AddParameter("Type", termType.ToString().ToLowerInvariant());
dp.ExecuteReader("SELECT * FROM Terms WHERE [TermID] IN (SELECT TermID FROM TermsTo WHERE [ObjectID]=@ObjectID AND [Type]=@Type) ORDER BY Name");
}
else
{
dp.ExecuteReader("SELECT * FROM Terms WHERE [TermID] IN (SELECT TermID FROM TermsTo WHERE [ObjectID]=@ObjectID) ORDER BY Name");
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
terms.Add(bsTerm);
}
}
}
}
return terms;
}
public static List<BSTerm> GetTermsBySubID(TermTypes termType, int iSubID)
{
List<BSTerm> terms = new List<BSTerm>();
using (DataProcess dp = new DataProcess())
{
if (termType != TermTypes.All)
{
dp.AddParameter("Type", termType.ToString().ToLowerInvariant());
dp.AddParameter("SubID", iSubID);
dp.ExecuteReader("SELECT * FROM Terms WHERE [Type]=@Type AND [SubID]=@SubID ORDER BY [Name] ASC");
}
else
{
dp.AddParameter("SubID", iSubID);
dp.ExecuteReader("SELECT * FROM Terms WHERE [SubID]=@SubID ORDER BY [Name] ASC");
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
terms.Add(bsTerm);
}
}
}
}
return terms;
}
public static List <BSTerm> GetTerms(TermTypes termType)
{
return(GetTerms(termType, 0));
}
//public static abstract TermAbsClass getFromString(string input);
//public abstract TermAbsClass GetResult(TermAbsClass TermA, TermAbsClass TermB);
public TermAbsClass()
{
TermType = TermTypes.ERR; val = new int[1]; val[0] = (int)ERRType.ERR_NOT_DEFINED;
}
public TermAbsClass(ERRType err)
{
TermType = TermTypes.ERR; val = new int[1]; val[0] = (int)err;
}
public static BSTerm GetTerm(int iTermID, int iSubID, TermTypes type)
{
using (DataProcess dp = new DataProcess())
{
if (iTermID > 0)
{
if (type == TermTypes.All)
{
dp.AddParameter("TermID", iTermID);
dp.ExecuteReader("SELECT * FROM Terms WHERE [TermID] = @TermID");
}
else
{
dp.AddParameter("TermID", iTermID);
dp.AddParameter("Type", type.ToString().ToLowerInvariant());
dp.ExecuteReader("SELECT * FROM Terms WHERE [TermID] = @TermID AND [Type]=@Type");
}
}
else
{
if (type == TermTypes.All)
{
dp.AddParameter("SubID", iSubID);
dp.ExecuteReader("SELECT * FROM Terms WHERE [SubID] = @SubID");
}
else
{
dp.AddParameter("SubID", iSubID);
dp.AddParameter("Type", type.ToString().ToLowerInvariant());
dp.ExecuteReader("SELECT * FROM Terms WHERE [SubID] = @SubID AND [Type]=@Type");
}
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
if (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
return bsTerm;
}
}
}
}
return null;
}
public Term(String input, TermTypes type) : this(input, type, true)
{
}
public static List<BSTerm> GetTerms(TermTypes termType, int iTermCount)
{
List<BSTerm> terms = new List<BSTerm>();
using (DataProcess dp = new DataProcess())
{
string top = iTermCount == 0 ? String.Empty : "TOP " + iTermCount;
if (termType != TermTypes.All)
{
dp.AddParameter("Type", termType.ToString().ToLowerInvariant());
dp.ExecuteReader(String.Format("SELECT {0} * FROM Terms WHERE [Type]=@Type ORDER BY [Name] ASC", top));
}
else
{
dp.ExecuteReader(String.Format("SELECT {0} * FROM Terms ORDER BY [Name] ASC", top));
}
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSTerm bsTerm = new BSTerm();
FillTerm(dr, bsTerm);
terms.Add(bsTerm);
}
}
}
}
return terms;
}
public void CopyFrom(ref Term from)
{
this.Text = from.Text;
this.SubTerms = from.SubTerms;
this.Type = from.Type;
}
public static StickerTerm GetOngoingTerm(TermTypes termType)
{
return(stickerTerms.FirstOrDefault(s => s.Type == termType));
}
public StringSplitter()
{
currentPosition = 0; currentTermStartPosition = 0;
currentTermType = TermTypes.NUL;
}
public void CopyFrom(ref Term from)
{
Text = from.Text;
SubTerms = from.SubTerms;
Type = from.Type;
}
public Term(String input, TermTypes type)
: this(input, type, true)
{
}
public static List<BSPost> GetPostsByTerm(int termId, string code, TermTypes termType, PostTypes postType, PostStates postState)
{
List<BSPost> posts = new List<BSPost>();
using (DataProcess dp = new DataProcess())
{
BSTerm bsTerm = null;
bsTerm = termId != 0 ? BSTerm.GetTerm(termId) : BSTerm.GetTerm(code, termType);
if (bsTerm != null)
{
dp.AddParameter("TermID", bsTerm.TermID);
if (postState != PostStates.All)
{
dp.AddParameter("State", (short)postState);
dp.ExecuteReader("SELECT * FROM Posts WHERE [PostID] IN (SELECT [ObjectID] FROM TermsTo WHERE [TermID]=@TermID) AND [State]=@State ORDER By [CreateDate] DESC");
}
else
{
dp.ExecuteReader("SELECT * FROM Posts WHERE [PostID] IN (SELECT [ObjectID] FROM TermsTo WHERE [TermID]=@TermID) AND [Type]=@Type ORDER By [CreateDate] DESC");
}
}
else
return posts;
if (dp.Return.Status == DataProcessState.Success)
{
using (IDataReader dr = dp.Return.Value as IDataReader)
{
while (dr != null && dr.Read())
{
BSPost bsPost = new BSPost();
FillPost(dr, bsPost);
posts.Add(bsPost);
}
}
}
}
return posts;
}
// Makes a copy of another term
public void CopyFrom(ref Term from)
{
this.Text = from.Text;
this.SubTerms = from.SubTerms;
this.Type = from.Type;
}
public void CopyFrom(ref Term from)
{
Text = from.Text;
SubTerms = from.SubTerms;
Type = from.Type;
}
