Project

Glimpse List is a silverlight application I was in charge of developing at Beaumont that can be hosted on a SharePoint site to provide a quick “glimpse” of SharePoint lists. I wrote the entire application in less than sixth months without any additional developmental resources other than feedback on usability.

Icons and custom calculations make Glimpse List capable of translating the data in a SharePoint list into information relevant to the user in a quick and efficient way.

Note: The site example contains only random information and does not contain information about real individuals or organizations. The format was configured to closely resemble the environment it was used for. This format is configured per implementation by config.xml. This example interfaces with MySQL, instead of SharePoint REST.

Site Example

Created:
Platform:
Size:
Features:

2013
Silverlight C#
10,000 Lines

.NET, WPF, XAML, Recursive Descent Parser, Cache System

UML

Sample Code: ConditionInstance.cs

ď»ż//------------------------------------------------------------------------------------//
//	ConditionInstance.cs	10-15-13
//  Created by Steven Gorsline
//	Description: Parses and computes formulas
//------------------------------------------------------------------------------------//

using System;
using System.Text;
using System.Collections.Generic;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Silverlight4Test2
{
    public class ConditionInstance
    {
        private const int MAX_CONDITION_CALCULATION_ITERATIONS = 100;

private int JOIN_AND = 0;
        private int JOIN_OR = 1;
        private List<string> joiners = new List<string> { "AND", "OR" };

private int GROUPER_LEFT_PARAN = 0;
        private int GROUPER_RIGHT_PARAN = 1;
        private List<char> groupers = new List<char> { '(', ')' };

private int COMPARATOR_EQUALS = 3;
        private int COMPARATOR_GREATER_THAN = 4;
        private int COMPARATOR_GREATER_THAN_OR_EQUALS = 1;
        private int COMPARATOR_LESS_THAN = 5;
        private int COMPARATOR_LESS_THAN_OR_EQUALS = 2;
        private int COMPARATOR_NOT_EQUALS = 0;
        private int COMPARATOR_CONTAINS = 6;
        //Order combinations first
        private List<string> comparators = new List<string> { "!=", "GTE", "LTE", "=", "GT", "LT", "CONTAINS" };

private int OPERATOR_MULTIPLY = 0;
        private int OPERATOR_DIVIDE = 2;
        private int OPERATOR_IF = 1;
        private List<string> operatorsMajor = new List<string> { "*", "IF", "/", "+", "-" };

private int OPERATOR_ADD = 3;
        private int OPERATOR_SUBTRACT = 4;
        private List<string> operatorsMinor = new List<string> { "", "", "", "+", "-" };

private List<string> keywords = new List<string> { "null", "false", "true" };

private int DECLARATOR_SQUARE_BRACE_LEFT = 0;
        private int DECLARATOR_SQUARE_BRACE_RIGHT = 1;
        private int DECLARATOR_CURLY_BRACE_LEFT = 2;
        private int DECLARATOR_CURLY_BRACE_RIGHT = 3;
        private List<char> declarators = new List<char> { '[', ']', '{', '}' };

private int MODIFIER_TOTAL = 0;
        private int MODIFIER_COUNT = 1;
        private int MODIFIER_AVERAGE = 2;
        private int MODIFIER_MEDIAN = 3;
        private int MODIFIER_MIN = 4;
        private int MODIFIER_MAX = 5;
        
        private List<string> modifiers = new List<string> { "TOTAL", "COUNT", "AVERAGE", "MEDIAN", "MIN", "MAX" };

public bool isNumber = true;
        public string formula = "_NO_FORMULA_";
        public double calculatedValue;
        public int listNum;
        public int attributeReference = -1;
        public List<int> linkReference = new List<int>();
        public int modifier = -1;

class Join
        {
            public ConditionInstance leftCondition;
            public ConditionInstance rightCondition;
            public int type;
        }

class Compare
        {
            public ConditionInstance leftCondition;
            public ConditionInstance rightCondition;
            public int type;
        }

class Operation
        {
            public ConditionInstance leftCondition;
            public ConditionInstance rightCondition;
            public int type;
        }

class Modification
        {
            public ConditionInstance condition;
            public int type;
        }

List<Join> joins;
        List<Compare> compares;
        List<Operation> operations;
        List<Modification> modifications;

public ConditionInstance(string _formula, int _listNum)
        {
            //Set constructor values
            formula = _formula;
            calculatedValue = 0;
            listNum = _listNum;

//Create lists
            joins = new List<Join>();
            compares = new List<Compare>();
            operations = new List<Operation>();
            modifications = new List<Modification>();

parse();
        }

private int skipInnerGroupers(string formula, int start, char beginChar, char endChar)
        {
            int endPos = start;
            int currentLevel = 0;
            if (formula[start] == beginChar)
            {
                currentLevel = -1;
                endPos++;
                bool foundEnd = false;
                while (!foundEnd && endPos < formula.Length)
                {
                    if (formula[endPos] == beginChar)
                        currentLevel--;

if (formula[endPos] == endChar)
                        currentLevel++;

if (currentLevel == 0)
                        foundEnd = true;

endPos++;
                }
            }

return endPos;
        }

private string removeOuterGroupers(string formula, char beginGroupSymbol, char endGroupSymbol)
        {
            int endPos = 0;
            int currentLevel = 1;
            int beginGrouperPos = 0;
            int endGrouperPos = 0;
            int beginGrouperCount = 0;
            bool foundBeginning = false;
            bool foundEnd = false;
            StringBuilder formulaBuilder = new StringBuilder(formula);
            while (endPos < formula.Length)
            {
                if (currentLevel == 1 && formula[endPos] == beginGroupSymbol)
                {
                    beginGrouperPos = endPos;
                    foundBeginning = true;
                    beginGrouperCount++;
                }

//Invalidate conditions to remove grouper symbols
                // if they are not outside
                if (formula[endPos] != beginGroupSymbol && formula[endPos] != ' ' && !foundBeginning)
                    beginGrouperCount = 3;

if (formula[endPos] == beginGroupSymbol)
                    currentLevel--;

if (formula[endPos] == endGroupSymbol)
                {
                    currentLevel++;
                    if (currentLevel == 1)
                    {
                        endGrouperPos = endPos;
                        foundEnd = true;
                    }
                }
                else if (formula[endPos] != ' ')
                    foundEnd = false;

endPos++;
            }

if (foundEnd && beginGrouperCount == 1)
            {
                formulaBuilder[beginGrouperPos] = ' ';
                formulaBuilder[endGrouperPos] = ' ';
            }

return formulaBuilder.ToString();
        }

public void parse()
        {
            //Find comparators
            List<int> comparatorPositions = new List<int>();
            List<int> comparatorTypes = new List<int>();
            if (formula.Length > 0)
            {
                //Remove outer groupers
                if (formula[0] == '(')
                    formula = removeOuterGroupers(formula, groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);

//Copy formula so inner groups can be removed
                string formulaCopy = formula;
                StringBuilder formulaCopyBuilder = new StringBuilder(formulaCopy);

//Remove inner groups
                int removePos = 0;
                while (removePos < formulaCopy.Length)
                {
                    //For parenthesis
                    if (formulaCopy[removePos] == groupers[GROUPER_LEFT_PARAN])
                    {
                        int groupEndPos = skipInnerGroupers(formulaCopy, removePos, groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);
                        if (groupEndPos != removePos)
                        {
                            for (int i = 0; i < groupEndPos - removePos; i++)
                            {
                                formulaCopyBuilder[i + removePos] = ' ';
                            }
                        }
                    }

//For square brackets
                    if (formulaCopy[removePos] == declarators[DECLARATOR_SQUARE_BRACE_LEFT])
                    {
                        int groupEndPos = skipInnerGroupers(formulaCopy, removePos, declarators[DECLARATOR_SQUARE_BRACE_LEFT], declarators[DECLARATOR_SQUARE_BRACE_RIGHT]);
                        if (groupEndPos != removePos)
                        {
                            for (int i = 0; i < groupEndPos - removePos; i++)
                            {
                                formulaCopyBuilder[i + removePos] = ' ';
                            }
                        }
                    }

//For curly brackets
                    if (formulaCopy[removePos] == declarators[DECLARATOR_CURLY_BRACE_LEFT])
                    {
                        int groupEndPos = skipInnerGroupers(formulaCopy, removePos, declarators[DECLARATOR_CURLY_BRACE_LEFT], declarators[DECLARATOR_CURLY_BRACE_RIGHT]);
                        if (groupEndPos != removePos)
                        {
                            for (int i = 0; i < groupEndPos - removePos; i++)
                            {
                                formulaCopyBuilder[i + removePos] = ' ';
                            }
                        }
                    }

removePos++;
                }

formulaCopy = formulaCopyBuilder.ToString();

//Copy formula so found comparators can be removed
                string formulaWithoutComparators = formulaCopy;

//Check for comparators
                for (int i = 0; i < comparators.Count; i++)
                {
                    int comparatorPos = 0;
                    bool foundComparator = true;
                    while (foundComparator)
                    {
                        //Check if there is a comparator
                        int newComparatorPos = formulaWithoutComparators.IndexOf(comparators[i], comparatorPos + 1);
                        if (newComparatorPos != -1)
                        {
                            //Store position and type of comparator
                            comparatorPos = newComparatorPos;
                            comparatorPositions.Add(comparatorPos);
                            comparatorTypes.Add(i);
                            foundComparator = true;
                        }
                        else
                        {
                            foundComparator = false;
                        }
                    }

//Remove comparators of this type from list being checked
                    // in order to prevent problems with symbol collisions
                    if (comparators[i].Length == 1)
                        formulaWithoutComparators = formulaWithoutComparators.Replace(comparators[i], " ");
                    if (comparators[i].Length == 2)
                        formulaWithoutComparators = formulaWithoutComparators.Replace(comparators[i], "  ");
                    if (comparators[i].Length == 3)
                        formulaWithoutComparators = formulaWithoutComparators.Replace(comparators[i], "   ");

}

//Find major operators
                List<int> operatorMajorPositions = new List<int>();
                List<int> operatorMajorTypes = new List<int>();
                for (int i = 0; i < operatorsMajor.Count; i++)
                {
                    int operatorMajorPos = 0;
                    bool foundMajorOperator = true;
                    while (foundMajorOperator)
                    {
                        //Check if there is a operator
                        int newMajorOperatorPos = formulaCopy.IndexOf(operatorsMajor[i], operatorMajorPos + 1);
                        if (newMajorOperatorPos != -1)
                        {
                            //Store position and type of operator
                            operatorMajorPos = newMajorOperatorPos;
                            operatorMajorPositions.Add(operatorMajorPos);
                            operatorMajorTypes.Add(i);
                            foundMajorOperator = true;
                        }
                        else
                        {
                            foundMajorOperator = false;
                        }
                    }
                }

//Find minor operators
                List<int> operatorMinorPositions = new List<int>();
                List<int> operatorMinorTypes = new List<int>();
                for (int i = 0; i < operatorsMinor.Count; i++)
                {
                    if (operatorsMinor[i] != "")
                    {
                        int operatorMinorPos = 0;
                        bool foundMinorOperator = true;
                        while (foundMinorOperator)
                        {
                            //Check if there is an operator
                            int newMinorOperatorPos = formulaCopy.IndexOf(operatorsMinor[i], operatorMinorPos + 1);
                            if (newMinorOperatorPos != -1)
                            {
                                //Store position and type of operator
                                operatorMinorPos = newMinorOperatorPos;
                                operatorMinorPositions.Add(operatorMinorPos);
                                operatorMinorTypes.Add(i);
                                foundMinorOperator = true;
                            }
                            else
                            {
                                foundMinorOperator = false;
                            }
                        }
                    }
                }

//Find joiners
                List<int> joinerPositions = new List<int>();
                List<int> joinerTypes = new List<int>();
                for (int i = 0; i < joiners.Count; i++)
                {
                    int joinerPos = 0;
                    bool foundJoiner = true;
                    while (foundJoiner)
                    {
                        //Check if there is a joiner
                        int newJoinerPos = formulaCopy.IndexOf(joiners[i], joinerPos + 1);
                        if (newJoinerPos != -1)
                        {
                            //Store position and type of joiner
                            joinerPos = newJoinerPos;
                            joinerPositions.Add(joinerPos);
                            joinerTypes.Add(i);
                            foundJoiner = true;
                        }
                        else
                        {
                            foundJoiner = false;
                        }
                    }
                }

//If there are joiners then subdivide formula by them
                //Else subdivide formula by lower order level symbols
                if (joinerPositions.Count > 0)
                {
                    //Split formula string by joiner symbols
                    string[] splitFormula = formulaCopy.Split(joiners.ToArray(), StringSplitOptions.None);
                    string[] newSplitFormula = new string[splitFormula.Length];
                    int splitPos = 0;
                    for (int i = 0; i < splitFormula.Length - 1; i++)
                    {
                        newSplitFormula[i] = removeOuterGroupers(formula.Substring(splitPos, splitFormula[i].Length),
                            groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);
                        splitPos += splitFormula[i].Length + joiners[joinerTypes[i]].Length;
                    }
                    newSplitFormula[splitFormula.Length - 1] = removeOuterGroupers(formula.Substring(splitPos, splitFormula[splitFormula.Length - 1].Length),
                        groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);

if (newSplitFormula.Length > 1)
                    {
                        //Create subconditions for each split part
                        List<ConditionInstance> joinerConditions = new List<ConditionInstance>();
                        for (int i = 0; i < newSplitFormula.Length; i++)
                        {
                            joinerConditions.Add(new ConditionInstance(newSplitFormula[i], listNum));
                        }

//Create new operator position list sorted by position
                        // and keep old one for index lookup
                        List<int> sortedJoinerPositions = new List<int>();
                        for (int i = 0; i < joinerPositions.Count; i++)
                            sortedJoinerPositions.Add(joinerPositions[i]);
                        sortedJoinerPositions.Sort();

//Create joiner objects for each joiner
                        for (int i = 0; i < sortedJoinerPositions.Count; i++)
                        {
                            Join newJoin = new Join();
                            int leftJoinIndex = i;
                            int rightJoinIndex = i + 1;
                            newJoin.leftCondition = joinerConditions[leftJoinIndex];
                            newJoin.rightCondition = joinerConditions[rightJoinIndex];
                            newJoin.type = joinerTypes[joinerPositions.IndexOf(sortedJoinerPositions[i])];
                            joins.Add(newJoin);
                        }
                    }
                }

//Else check for comparators and operations
                else
                {
                    //If there are comparators then subdivide formula by them
                    if (comparatorPositions.Count > 0)
                    {
                        //Split formula string by comparator symbols
                        string[] splitFormula = formulaCopy.Split(comparators.ToArray(), StringSplitOptions.None);
                        string[] newSplitFormula = new string[splitFormula.Length];
                        int splitPos = 0;
                        for (int i = 0; i < splitFormula.Length - 1; i++)
                        {
                            newSplitFormula[i] = removeOuterGroupers(formula.Substring(splitPos, splitFormula[i].Length),
                                groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);
                            splitPos += splitFormula[i].Length + comparators[comparatorTypes[i]].Length;
                        }
                        newSplitFormula[splitFormula.Length - 1] = removeOuterGroupers(formula.Substring(splitPos, splitFormula[splitFormula.Length - 1].Length),
                            groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);

if (newSplitFormula.Length > 1)
                        {
                            //Create subconditions for each split part
                            List<ConditionInstance> comparatorConditions = new List<ConditionInstance>();
                            for (int i = 0; i < newSplitFormula.Length; i++)
                            {
                                comparatorConditions.Add(new ConditionInstance(newSplitFormula[i], listNum));
                            }

//Create new comparator position list sorted by position
                            // and keep old one for index lookup
                            List<int> sortedComparatorPositions = new List<int>();
                            for (int i = 0; i < comparatorPositions.Count; i++)
                                sortedComparatorPositions.Add(comparatorPositions[i]);
                            sortedComparatorPositions.Sort();

//Create comparator objects for each comparator
                            for (int i = 0; i < sortedComparatorPositions.Count; i++)
                            {
                                Compare newCompare = new Compare();
                                int leftConditionIndex = i;
                                int rightConditionIndex = i + 1;
                                newCompare.leftCondition = comparatorConditions[leftConditionIndex];
                                newCompare.rightCondition = comparatorConditions[rightConditionIndex];
                                newCompare.type = comparatorTypes[comparatorPositions.IndexOf(sortedComparatorPositions[i])];
                                compares.Add(newCompare);
                            }
                        }
                    }
                    //Else subdivide formula by major operators
                    else
                    {
                        if (operatorMinorPositions.Count > 0)
                        {
                            //Split formula string by major operator symbols
                            string[] splitFormula = formulaCopy.Split(operatorsMinor.ToArray(), StringSplitOptions.None);
                            string[] newSplitFormula = new string[splitFormula.Length];
                            int splitPos = 0;
                            for (int i = 0; i < splitFormula.Length - 1; i++)
                            {
                                newSplitFormula[i] = removeOuterGroupers(formula.Substring(splitPos, splitFormula[i].Length),
                                    groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);
                                splitPos += splitFormula[i].Length + operatorsMinor[operatorMinorTypes[i]].Length;
                            }
                            newSplitFormula[splitFormula.Length - 1] = removeOuterGroupers(formula.Substring(splitPos, splitFormula[splitFormula.Length - 1].Length),
                                groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);

if (newSplitFormula.Length > 1)
                            {
                                //Create subconditions for each split part
                                List<ConditionInstance> operatorConditions = new List<ConditionInstance>();
                                for (int i = 0; i < newSplitFormula.Length; i++)
                                {
                                    operatorConditions.Add(new ConditionInstance(newSplitFormula[i], listNum));
                                }

//Create new operator position list sorted by position
                                // and keep old one for index lookup
                                List<int> sortedOperatorPositions = new List<int>();
                                for (int i = 0; i < operatorMinorPositions.Count; i++)
                                    sortedOperatorPositions.Add(operatorMinorPositions[i]);
                                sortedOperatorPositions.Sort();

//Create operator objects for each operator
                                for (int i = 0; i < sortedOperatorPositions.Count; i++)
                                {
                                    Operation newOperation = new Operation();
                                    int leftOperationIndex = i;
                                    int rightOperationIndex = i + 1;
                                    newOperation.leftCondition = operatorConditions[leftOperationIndex];
                                    newOperation.rightCondition = operatorConditions[rightOperationIndex];
                                    newOperation.type = operatorMinorTypes[operatorMinorPositions.IndexOf(sortedOperatorPositions[i])];
                                    operations.Add(newOperation);
                                }
                            }
                        }

//Else subdivide formula by minor operations
                        else
                        {
                            if (operatorMajorPositions.Count > 0)
                            {
                                //Split formula string by major operator symbols
                                string[] splitFormula = formulaCopy.Split(operatorsMajor.ToArray(), StringSplitOptions.None);
                                string[] newSplitFormula = new string[splitFormula.Length];
                                int splitPos = 0;
                                for (int i = 0; i < splitFormula.Length - 1; i++)
                                {
                                    newSplitFormula[i] = removeOuterGroupers(formula.Substring(splitPos, splitFormula[i].Length),
                                        groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);
                                    splitPos += splitFormula[i].Length + operatorsMajor[operatorMajorTypes[i]].Length;
                                }
                                newSplitFormula[splitFormula.Length - 1] = removeOuterGroupers(formula.Substring(splitPos, splitFormula[splitFormula.Length - 1].Length),
                                    groupers[GROUPER_LEFT_PARAN], groupers[GROUPER_RIGHT_PARAN]);

if (newSplitFormula.Length > 1)
                                {
                                    //Create subconditions for each split part
                                    List<ConditionInstance> operatorConditions = new List<ConditionInstance>();
                                    for (int i = 0; i < newSplitFormula.Length; i++)
                                    {
                                        operatorConditions.Add(new ConditionInstance(newSplitFormula[i], listNum));
                                    }

//Create new operator position list sorted by position
                                    // and keep old one for index lookup
                                    List<int> sortedOperatorPositions = new List<int>();
                                    for (int i = 0; i < operatorMajorPositions.Count; i++)
                                        sortedOperatorPositions.Add(operatorMajorPositions[i]);
                                    sortedOperatorPositions.Sort();

//Create operator objects for each operator
                                    for (int i = 0; i < sortedOperatorPositions.Count; i++)
                                    {
                                        Operation newOperation = new Operation();
                                        int leftOperationIndex = i;
                                        int rightOperationIndex = i + 1;
                                        newOperation.leftCondition = operatorConditions[leftOperationIndex];
                                        newOperation.rightCondition = operatorConditions[rightOperationIndex];
                                        newOperation.type = operatorMajorTypes[operatorMajorPositions.IndexOf(sortedOperatorPositions[i])];
                                        operations.Add(newOperation);
                                    }
                                }
                            }
                            //else if there is nothing to subdivide
                            else
                            {
                                //Check if value is a number, text, or attribute reference

//if value is an attribute reference
                                if (formula.Contains(declarators[DECLARATOR_SQUARE_BRACE_LEFT].ToString()))
                                {
                                    //remove brackets
                                    //int beginBracketPos = formula.IndexOf(declarators[DECLARATOR_SQUARE_BRACE_LEFT]);
                                    //int endBracketPos = formula.IndexOf(declarators[DECLARATOR_SQUARE_BRACE_RIGHT]);
                                    //formula = formula.Substring(beginBracketPos + 1, endBracketPos - (beginBracketPos + 1));
                                    formula = formula.Replace("[","");
                                    formula = formula.Replace("]", "");
                                    formula = formula.Trim();

//Check list of attributes for the index
                                    List<string> attributeList = new List<string>();
                                    for (int i = 0; i < DataManager.listAttributes[listNum].GetLength(0); i++)
                                        attributeList.Add(DataManager.listAttributes[listNum][i, LayoutManager.ATTRIBUTE_NAME]);

//Check if there is a link reference
                                    if (formula.Contains("."))
                                    {
                                        //Linked calculations only used for numbers
                                        isNumber = true;

string[] attributeSplit = formula.Split(new char[] { '.' });
                                        formula = attributeSplit[0];
                                        attributeReference = attributeList.IndexOf(formula);
                                        int followList = listNum;
                                        int followAttribute = attributeReference;
                                        for (int i = 1; i < attributeSplit.Length; i++)
                                        {
                                            //Check lists for link reference
                                            List<string> listNames = new List<string>();
                                            for (int j = 0; j < DataManager.lists.GetLength(0); j++)
                                                listNames.Add(DataManager.lists[j, LayoutManager.LIST_NAME]);

int listLinkNum = listNames.IndexOf(DataManager.listAttributes[followList][followAttribute, LayoutManager.ATTRIBUTE_LINK_SOURCE]);
                                            int attributeLinkIndex = -1;

if (listLinkNum != -1)
                                            {
                                                //Check lists for attribute link reference
                                                List<string> linkAttributeList = new List<string>();
                                                for (int j = 0; j < DataManager.listAttributes[listLinkNum].GetLength(0); j++)
                                                    linkAttributeList.Add(DataManager.listAttributes[listLinkNum][j, LayoutManager.ATTRIBUTE_NAME]);

attributeLinkIndex = linkAttributeList.IndexOf(attributeSplit[i]);
                                            }

if (attributeLinkIndex != -1)
                                            {
                                                linkReference.Add(attributeLinkIndex);

//Update list and attribute following up the chain of links
                                                followList = listLinkNum;
                                                followAttribute = attributeLinkIndex;
                                            }
                                            else
                                            //Check if this is a condition
                                            {
                                                if (listLinkNum != -1)
                                                {
                                                    //Check lists for attribute link reference
                                                    List<string> linkConditionList = new List<string>();
                                                    for (int j = 0; j < DataManager.listConditions[listLinkNum].GetLength(0); j++)
                                                        linkConditionList.Add(DataManager.listConditions[listLinkNum][j, LayoutManager.CONDITION_NAME]);

attributeLinkIndex = linkConditionList.IndexOf(attributeSplit[i]);
                                                }

if (attributeLinkIndex != -1)
                                                {
                                                    attributeLinkIndex = (attributeLinkIndex * -1) - 2;
                                                    linkReference.Add(attributeLinkIndex);
                                                }
                                                else
                                                //Check if this is a modifier
                                                {
                                                    modifier = modifiers.IndexOf(attributeSplit[i]);
                                                }
                                            }
                                        }
                                    }

attributeReference = attributeList.IndexOf(formula);

//Check if this attribute is a number or text
                                    if (attributeReference != -1 && DataManager.listAttributes[listNum][attributeReference, LayoutManager.ATTRIBUTE_LINK_SOURCE] == "_NO_LINK_SOURCE_")
                                        isNumber = (DataManager.listAttributes[listNum][attributeReference, LayoutManager.ATTRIBUTE_TYPE] == LayoutManager.attributeTypes[LayoutManager.ATTRIBUTE_NUMBER_TYPE])
                                            || (DataManager.listAttributes[listNum][attributeReference, LayoutManager.ATTRIBUTE_TYPE] == LayoutManager.attributeTypes[LayoutManager.ATTRIBUTE_DATE_TYPE]);
                                    else
                                    {
                                        //Check if this is a condition,
                                        //  check list of conditions for the index
                                        int foundConditionIndex = 0;
                                        List<string> conditionList = new List<string>();
                                        for (int i = 0; i < DataManager.listConditions[listNum].GetLength(0); i++)
                                            conditionList.Add(DataManager.listConditions[listNum][i, LayoutManager.CONDITION_NAME]);

foundConditionIndex = conditionList.IndexOf(formula);
                                        //If condition was found
                                        if (foundConditionIndex != -1)
                                        {
                                            //All conditions evaluate to numbers
                                            isNumber = true;

//Inverse map to negatives below -1,
                                            //  so there are no collisions with attribute indices and null
                                            attributeReference = (foundConditionIndex * -1) - 2;
                                        }
                                    }
                                }

//if value is text
                                if (formula.Contains(declarators[DECLARATOR_CURLY_BRACE_LEFT].ToString()))
                                {
                                    //remove brackets
                                    isNumber = false;
                                    int beginBracketPos = formula.IndexOf(declarators[DECLARATOR_CURLY_BRACE_LEFT]);
                                    int endBracketPos = formula.IndexOf(declarators[DECLARATOR_CURLY_BRACE_RIGHT]);
                                    formula = formula.Substring(beginBracketPos + 1, endBracketPos - (beginBracketPos + 1));
                                }
                            }
                        }
                    }
                }
            }
        }

public double calculate(int itemIndex, int iteration)
        {
            double newCalcValue = 1;
            int iterationPlus = ++iteration;

//If iteration is below max limit,
            //  safeguard against circular references
            if (iteration < MAX_CONDITION_CALCULATION_ITERATIONS)
            {

//If there are joins
                if (joins.Count > 0)
                {
                    if (joins[0].type == JOIN_OR)
                        newCalcValue = 0;

for (int i = 0; i < joins.Count; i++)
                    {
                        //if join is of type AND
                        if (joins[i].type == JOIN_AND)
                            newCalcValue *= (joins[i].leftCondition.calculate(itemIndex, iterationPlus) == 1 && joins[i].rightCondition.calculate(itemIndex, iterationPlus) == 1) ? 1 : 0;

//if join is of type OR
                        if (joins[i].type == JOIN_OR)
                            newCalcValue += (joins[i].leftCondition.calculate(itemIndex, iterationPlus) == 1 || joins[i].rightCondition.calculate(itemIndex, iterationPlus) == 1) ? 1 : 0;
                    }
                    if (newCalcValue > 1)
                        newCalcValue = 1;
                    calculatedValue = newCalcValue;
                    return calculatedValue;
                }
                else
                {
                    if (compares.Count > 0)
                    {
                        for (int i = 0; i < compares.Count; i++)
                        {
                            //if comparing two numbers
                            if (compares[i].leftCondition.isNumber && compares[i].rightCondition.isNumber)
                            {
                                double leftConditionCalculation = 0;
                                double rightConditionCalculation = 0;

//if left condition is an attribute reference, convert reference to number
                                leftConditionCalculation = compares[i].leftCondition.calculate(itemIndex, iterationPlus);

//if right condition is an attribute reference, convert reference to number
                                rightConditionCalculation = compares[i].rightCondition.calculate(itemIndex, iterationPlus);

//if boolean is of type equals
                                if (compares[i].type == COMPARATOR_EQUALS)
                                    newCalcValue *= leftConditionCalculation == rightConditionCalculation ? 1 : 0;

//if boolean is of type not equals
                                if (compares[i].type == COMPARATOR_NOT_EQUALS)
                                    newCalcValue *= leftConditionCalculation != rightConditionCalculation ? 1 : 0;

//if boolean is of type less than
                                if (compares[i].type == COMPARATOR_LESS_THAN)
                                    newCalcValue *= leftConditionCalculation < rightConditionCalculation ? 1 : 0;

//if boolean is of type less than or equals
                                if (compares[i].type == COMPARATOR_LESS_THAN_OR_EQUALS)
                                    newCalcValue *= leftConditionCalculation <= rightConditionCalculation ? 1 : 0;

//if boolean is of type greater than
                                if (compares[i].type == COMPARATOR_GREATER_THAN)
                                    newCalcValue *= leftConditionCalculation > rightConditionCalculation ? 1 : 0;

//if boolean is of type greater than or equals
                                if (compares[i].type == COMPARATOR_GREATER_THAN_OR_EQUALS)
                                    newCalcValue *= leftConditionCalculation >= rightConditionCalculation ? 1 : 0;

}
                            //else one isn't a number, convert all to text
                            else
                            {
                                string leftConditionCalculation = "";
                                string rightConditionCalculation = "";

//if left condition is an attribute reference, convert reference to string
                                if (compares[i].leftCondition.attributeReference != -1)
                                {
                                    if (compares[i].leftCondition.attributeReference > -1)
                                        leftConditionCalculation = DataManager.listValues[listNum][itemIndex, compares[i].leftCondition.attributeReference];
                                    else
                                        leftConditionCalculation = DataManager.listConditionInstances[listNum][(compares[i].leftCondition.attributeReference * -1) - 2].calculate(itemIndex, iterationPlus).ToString();
                                }
                                else
                                {
                                    if (compares[i].leftCondition.isNumber)
                                        leftConditionCalculation = compares[i].leftCondition.calculate(itemIndex, iterationPlus).ToString();
                                    else
                                        leftConditionCalculation = compares[i].leftCondition.formula;
                                }

//if right condition is an attribute reference, convert reference to string
                                if (compares[i].rightCondition.attributeReference != -1)
                                {
                                    if (compares[i].rightCondition.attributeReference > -1)
                                        rightConditionCalculation = DataManager.listValues[listNum][itemIndex, compares[i].rightCondition.attributeReference];
                                    else
                                        rightConditionCalculation = DataManager.listConditionInstances[listNum][(compares[i].rightCondition.attributeReference * -1) - 2].calculate(itemIndex, iterationPlus).ToString();
                                }
                                else
                                {
                                    if (compares[i].rightCondition.isNumber)
                                        rightConditionCalculation = compares[i].rightCondition.calculate(itemIndex, iterationPlus).ToString();
                                    else
                                        rightConditionCalculation = compares[i].rightCondition.formula;
                                }

//if boolean is of type contains
                                if (compares[i].type == COMPARATOR_CONTAINS)
                                    newCalcValue *= leftConditionCalculation.ToLower().Contains(rightConditionCalculation.ToLower()) ? 1 : 0;
                            }
                        }
                        calculatedValue = newCalcValue;
                        return calculatedValue;
                    }
                    else
                    {
                        //base case if formula is a single number
                        if (operations.Count == 0 && compares.Count == 0)
                        {
                            if (formula.Length > 0)
                            {
                                if (isNumber)
                                {
                                    if (attributeReference == -1)
                                    {
                                        calculatedValue = 0;
                                        DateTime parsedDateTime = new DateTime();

//Convert Relative Date/Time
                                        DateTime result = DateTime.MinValue;
                                        int minutesMultiplier = 0;

if (formula.Contains("minute"))
                                            minutesMultiplier = 1;
                                        else
                                            if (formula.Contains("hour"))
                                                minutesMultiplier = 60;
                                            else
                                                if (formula.Contains("day"))
                                                    minutesMultiplier = 1440;
                                                else
                                                    if (formula.Contains("month"))
                                                        minutesMultiplier = 57600;
                                                    else
                                                        if (formula.Contains("year"))
                                                            minutesMultiplier = 525600;

if (minutesMultiplier != 0)
                                        {
                                            string cleanFormula = formula.Trim();
                                            string numberStr = cleanFormula.Split(' ')[0];
                                            long number;
                                            if (long.TryParse(numberStr, out number))
                                                result = DateTime.Now.AddMinutes(-number * minutesMultiplier);

parsedDateTime = result;

calculatedValue = (double)((double)parsedDateTime.Ticks);
                                        }
                                        else
                                        {

if (DateTime.TryParse(formula, out parsedDateTime))
                                            {
                                                calculatedValue = (double)((double)parsedDateTime.Ticks);
                                            }
                                            else
                                            {
                                                double calculatedDouble = 0;
                                                if (Double.TryParse(formula, out calculatedDouble))
                                                {
                                                    calculatedValue = Double.Parse(formula);
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        calculatedValue = 0;

//Check how many links will be calculated
                                        int[] linkSet = new int[0];

//Get calculation from an attribute
                                        if (attributeReference > -1)
                                        {
                                            int followedList = listNum;
                                            int followedAttribute = attributeReference;
                                            int followedItemIndex = itemIndex;
                                            bool linkFailed = false;

//If there are link references and lists were loaded
                                            if (DataManager.allQueriesCompleted && linkReference.Count > 0)
                                            {

for (int i = -1; i < linkReference.Count; i++)
                                                {
                                                    int linkRef = -1;
                                                    if (i == -1)
                                                        linkRef = attributeReference;
                                                    else
                                                        linkRef = linkReference[i];
                                                    //For forward links
                                                    if (linkRef > -1 && !linkFailed && DataManager.listAttributes[followedList][linkRef, LayoutManager.ATTRIBUTE_REVERSE_LINK] != "true")
                                                    {
                                                        int linkNum = DataManager.listLinksNames[followedList].IndexOf(DataManager.listAttributes[followedList][linkRef, LayoutManager.ATTRIBUTE_NAME]);

if (linkNum != -1)
                                                        {
                                                            int linkIndex = DataManager.listLinksSet[followedList].links[linkNum][followedItemIndex][0];
                                                            
                                                            if (linkIndex != -1)
                                                            {
                                                                int listLinkIndex = DataManager.listLinksSet[followedList].listIndices[linkNum];
                                                                if (listLinkIndex != -1 && i != linkReference.Count - 1)
                                                                {
                                                                    int _linkIndex = DataManager.listLinksSet[followedList].links[linkNum][followedItemIndex][0];
                                                                    linkSet = DataManager.listLinksSet[followedList].links[linkNum][followedItemIndex];
                                                                    followedItemIndex = _linkIndex;

followedList = listLinkIndex;
                                                                    followedAttribute = linkRef;
                                                                }
                                                            }
                                                            else
                                                            {
                                                                linkFailed = true;
                                                            }

}
                                                        else
                                                        {
                                                            if (!linkFailed)
                                                                followedAttribute = linkRef;
                                                        }

}
                                                    //For backward links
                                                    else if (linkRef > -1 && !linkFailed)
                                                    {
                                                        List<string> listNames = new List<string>();
                                                        for (int j = 0; j < DataManager.lists.GetLength(0); j++)
                                                            listNames.Add(DataManager.lists[j, LayoutManager.LIST_NAME]);

int listLink = listNames.IndexOf(DataManager.listAttributes[followedList][linkRef, LayoutManager.ATTRIBUTE_LINK_SOURCE]);

List<string> attNames = new List<string>();
                                                        for (int j = 0; j < DataManager.listAttributes[listLink].GetLength(0); j++)
                                                            attNames.Add(DataManager.listAttributes[listLink][j, LayoutManager.ATTRIBUTE_NAME]);
                                                        int sourceReferenceIndex = attNames.IndexOf(DataManager.listAttributes[followedList][linkRef, LayoutManager.ATTRIBUTE_LINK_ATTRIBUTE_SOURCE]);

int linkNum = DataManager.listLinksNames[listLink].IndexOf(DataManager.listAttributes[listLink][sourceReferenceIndex, LayoutManager.ATTRIBUTE_NAME]);

if (linkNum != -1)
                                                        {
                                                            int linkIndex = -1;
                                                            if (DataManager.reverseListLinksSet[listLink].links[linkNum][followedItemIndex].Length > 0)
                                                                linkIndex = DataManager.reverseListLinksSet[listLink].links[linkNum][followedItemIndex][0];

if (linkIndex != -1)
                                                            {
                                                                int listLinkIndex = DataManager.listLinksSet[listLink].listIndices[linkNum];
                                                                if (listLinkIndex != -1 && i != linkReference.Count - 1)
                                                                {
                                                                    int _linkIndex = DataManager.reverseListLinksSet[listLink].links[linkNum][followedItemIndex][0];
                                                                    linkSet = DataManager.reverseListLinksSet[listLink].links[linkNum][followedItemIndex];
                                                                    followedItemIndex = _linkIndex;

followedList = listLink;
                                                                    followedAttribute = sourceReferenceIndex;
                                                                }
                                                            }
                                                            else
                                                            {
                                                                linkFailed = true;
                                                            }

}
                                                        else
                                                        {
                                                            if (!linkFailed)
                                                                followedAttribute = linkRef;
                                                        }
                                                    }
                                                    if (linkRef < -1)
                                                        followedAttribute = linkRef;
                                                }

}
                                            //If reference is an attribute
                                            if (followedAttribute > -1)
                                            {
                                                string typeStr = DataManager.listAttributes[followedList][followedAttribute, LayoutManager.ATTRIBUTE_TYPE];
                                                if (DataManager.listAttributes[followedList][followedAttribute, LayoutManager.ATTRIBUTE_TYPE] == LayoutManager.attributeTypes[LayoutManager.ATTRIBUTE_NUMBER_TYPE])
                                                    if (DataManager.listValues[followedList][followedItemIndex, followedAttribute] != " ")
                                                    {
                                                        if (modifier == -1)
                                                            calculatedValue = Double.Parse(DataManager.listValues[followedList][followedItemIndex, followedAttribute]);
                                                        
                                                        //Calculate modifier
                                                        if (modifier != -1 && linkSet.Length > 0)
                                                        {
                                                            calculatedValue = 0;

if(modifier == MODIFIER_MIN)
                                                                calculatedValue = double.MaxValue;

if(modifier == MODIFIER_MAX)
                                                                calculatedValue = double.MinValue;

List<double> medianList = new List<double>();
                                                            for (int i = 0; i < linkSet.Length; i++)
                                                            {
                                                                if (modifier == MODIFIER_TOTAL)
                                                                    calculatedValue += Double.Parse(DataManager.listValues[followedList][linkSet[i], followedAttribute]);

if (modifier == MODIFIER_COUNT)
                                                                    calculatedValue++;

if (modifier == MODIFIER_AVERAGE)
                                                                    calculatedValue += Double.Parse(DataManager.listValues[followedList][linkSet[i], followedAttribute]);

if (modifier == MODIFIER_MEDIAN)
                                                                    medianList.Add(Double.Parse(DataManager.listValues[followedList][linkSet[i], followedAttribute]));

if (modifier == MODIFIER_MIN && Double.Parse(DataManager.listValues[followedList][linkSet[i], followedAttribute]) < calculatedValue)
                                                                    calculatedValue = Double.Parse(DataManager.listValues[followedList][linkSet[i], followedAttribute]);

if (modifier == MODIFIER_MAX && Double.Parse(DataManager.listValues[followedList][linkSet[i], followedAttribute]) > calculatedValue)
                                                                    calculatedValue = Double.Parse(DataManager.listValues[followedList][linkSet[i], followedAttribute]);
                                                            }

if (modifier == MODIFIER_MEDIAN)
                                                            {
                                                                medianList.Sort();
                                                                for (int i = 0; i < medianList.Count; i++)
                                                                {
                                                                    if ((double)medianList.Count % 2 == 0)
                                                                    {
                                                                        if ((int)(((double)medianList.Count / 2) - 1) == i || (int)(((double)medianList.Count / 2)) == i)
                                                                            calculatedValue += medianList[i];
                                                                    }
                                                                    else
                                                                    {
                                                                        if ((int)(((double)medianList.Count / 2) - 0.5) == i)
                                                                            calculatedValue = medianList[i];
                                                                    }
                                                                }

if ((double)medianList.Count % 2 == 0)
                                                                    calculatedValue /= 2;
                                                            }

if (modifier == MODIFIER_AVERAGE)
                                                                calculatedValue /= linkSet.Length;
                                                        }
                                                    }

//If reference is a date type
                                                if (DataManager.listAttributes[followedList][followedAttribute, LayoutManager.ATTRIBUTE_TYPE] == LayoutManager.attributeTypes[LayoutManager.ATTRIBUTE_DATE_TYPE])
                                                {
                                                    if (DataManager.listValues[followedList][followedItemIndex, followedAttribute] != " ")
                                                    {
                                                        string dateStr = DataManager.listValues[followedList][followedItemIndex, followedAttribute];
                                                        if (dateStr.Contains("T"))
                                                        {
                                                            dateStr = dateStr.Remove(dateStr.IndexOf('T'));
                                                            dateStr = dateStr.Replace('-', '/');
                                                            string yearStr = dateStr.Remove(dateStr.IndexOf('/'));
                                                            dateStr = dateStr.Substring(dateStr.IndexOf('/') + 1);
                                                            dateStr += "/" + yearStr;
                                                        }
                                                        calculatedValue = (double)((double)DateTime.Parse(dateStr).Ticks);
                                                    }
                                                }
                                            }
                                            //If reference is a condition
                                            if (!linkFailed && followedAttribute < -1)
                                            {
                                                //Calculate modifier
                                                if (modifier != -1 && linkSet.Length > 0)
                                                {
                                                    calculatedValue = 0;

if (modifier == MODIFIER_MIN)
                                                        calculatedValue = double.MaxValue;

if (modifier == MODIFIER_MAX)
                                                        calculatedValue = double.MinValue;

List<double> medianList = new List<double>();
                                                    for (int i = 0; i < linkSet.Length; i++)
                                                    {
                                                        if (modifier == MODIFIER_TOTAL)
                                                            calculatedValue += DataManager.listConditionInstances[followedList][(followedAttribute * -1) - 2].calculate(linkSet[i], iterationPlus);

if (modifier == MODIFIER_COUNT)
                                                            calculatedValue++;

if (modifier == MODIFIER_AVERAGE)
                                                            calculatedValue += DataManager.listConditionInstances[followedList][(followedAttribute * -1) - 2].calculate(linkSet[i], iterationPlus);

if (modifier == MODIFIER_MEDIAN)
                                                            medianList.Add(DataManager.listConditionInstances[followedList][(followedAttribute * -1) - 2].calculate(linkSet[i], iterationPlus));

if (modifier == MODIFIER_MIN && DataManager.listConditionInstances[followedList][(followedAttribute * -1) - 2].calculate(linkSet[i], iterationPlus) < calculatedValue)
                                                            calculatedValue = DataManager.listConditionInstances[followedList][(followedAttribute * -1) - 2].calculate(linkSet[i], iterationPlus);

if (modifier == MODIFIER_MAX && DataManager.listConditionInstances[followedList][(followedAttribute * -1) - 2].calculate(linkSet[i], iterationPlus) > calculatedValue)
                                                            calculatedValue = DataManager.listConditionInstances[followedList][(followedAttribute * -1) - 2].calculate(linkSet[i], iterationPlus);
                                                    }

if (modifier == MODIFIER_MEDIAN)
                                                    {
                                                        medianList.Sort();
                                                        for (int i = 0; i < medianList.Count; i++)
                                                        {
                                                            if ((double)medianList.Count % 2 == 0)
                                                            {
                                                                if ((int)(((double)medianList.Count / 2) - 1) == i || (int)(((double)medianList.Count / 2)) == i)
                                                                    calculatedValue += medianList[i];
                                                            }
                                                            else
                                                            {
                                                                if ((int)(((double)medianList.Count / 2) - 0.5) == i)
                                                                    calculatedValue = medianList[i];
                                                            }
                                                        }

if ((double)medianList.Count % 2 == 0)
                                                            calculatedValue /= 2;
                                                    }

if (modifier == MODIFIER_AVERAGE)
                                                        calculatedValue /= linkSet.Length;
                                                }
                                                else
                                                    calculatedValue = DataManager.listConditionInstances[followedList][(followedAttribute * -1) - 2].calculate(followedItemIndex, iterationPlus);
                                            }
                                        }

//Get calculation from a condition
                                        else if (attributeReference < -1)
                                        {
                                            calculatedValue = DataManager.listConditionInstances[listNum][(attributeReference * -1) - 2].calculate(itemIndex, iterationPlus);
                                        }

}
                                }
                                else
                                {
                                    calculatedValue = 0;
                                }
                            }
                            return calculatedValue;
                        }

//First add left most condition
                        if (operations.Count > 0)
                            newCalcValue = operations[0].leftCondition.calculate(itemIndex, iterationPlus);

//Add rest of the condition values
                        for (int i = 0; i < operations.Count; i++)
                        {
                            //if adding
                            if (operations[i].type == OPERATOR_ADD)
                                newCalcValue += operations[i].rightCondition.calculate(itemIndex, iterationPlus);

//if subtracting
                            if (operations[i].type == OPERATOR_SUBTRACT)
                                newCalcValue -= operations[i].rightCondition.calculate(itemIndex, iterationPlus);

//if multiplying
                            if (operations[i].type == OPERATOR_MULTIPLY)
                                newCalcValue *= operations[i].rightCondition.calculate(itemIndex, iterationPlus);

//if dividing
                            if (operations[i].type == OPERATOR_DIVIDE)
                                newCalcValue /= operations[i].rightCondition.calculate(itemIndex, iterationPlus);

//if conditional if (acts same as multiply) for intuitiveness
                            if (operations[i].type == OPERATOR_IF)
                                newCalcValue *= operations[i].rightCondition.calculate(itemIndex, iterationPlus);
                        }

calculatedValue = newCalcValue;
                        return calculatedValue;
                    }
                }
            }
            else
                return 0;
        }
    }
}

Click to Expand

The application uses a markup style configuration file to define elements and formulas used in each list. Users can quickly update the list viewer to their needs by making changes to the configuration without intervention from a developer.

This is the user manual with information about installing, configuring, and using the application.

Back