Ilka Guigova - Professional Profile

-- Consider a list of nodes grouped by DOMAIN_ID as stored in the following temporary table:
CREATE TABLE #NODE 
( 
    ID INT IDENTITY, 
    DOMAIN_ID INT,
    NAME VARCHAR(32)
)

-- Let DOMAIN_ID = 100 represent job nodes, DOMAIN_ID = 500 represent personnel nodes
INSERT INTO #NODE VALUES (100, 'Bloggers')
INSERT INTO #NODE VALUES (100, 'Vloggers')
INSERT INTO #NODE VALUES (500, 'Joe')
INSERT INTO #NODE VALUES (500, 'Jane')
INSERT INTO #NODE VALUES (500, 'Bob')

-- Consider a relationship between nodes of different domains as defined in the following temporary table:
CREATE TABLE #NODE_LINKS 
( 
    ID INT IDENTITY,
    RANK INT,  -- a placeholder for additional logic to rank links and a candidate for an auto-increment input
    LEFT_NODE_ID INT,
    RIGHT_NODE_ID INT
)

-- Let's link personnel to jobs:
-- Each person in personnel is assigned a position/rank within a job. The position / rank is reset for each job.
DECLARE @RANK_OFFSET INT
SELECT @RANK_OFFSET = COUNT(ID) FROM #NODE WHERE DOMAIN_ID = 500

INSERT INTO #NODE_LINKS (RANK, LEFT_NODE_ID, RIGHT_NODE_ID)
SELECT  (ROW_NUMBER() OVER (ORDER BY Jobs.ID) - 1) % @RANK_OFFSET, Jobs.ID, Personnel.ID
FROM	#NODE Jobs 
JOIN 	#NODE Personnel ON Personnel.DOMAIN_ID = 500
WHERE	Jobs.DOMAIN_ID = 100

-- Display the job-personnel links with a counter (a candidate for auto-increment output):
SELECT ROW_NUMBER() OVER (ORDER BY ID) AS COUNTER, * FROM #NODE_LINKS ORDER BY LEFT_NODE_ID

-- Cleanup
DROP TABLE #NODE_LINKS
DROP TABLE #NODE

/* Output:
COUNTER	ID	RANK	LEFT_NODE_ID	RIGHT_NODE_ID
1	1	0	1		3
2	2	1	1		4
3	3	2	1		5
4	4	0	2		3
5	5	1	2		4
6	6	2	2		5
*/

• Add re-parsing logic directly in the code - not smart enough as we do not know what input formats will need to be supported by Module 1 in the future
  
• Apply customizable xsl transformations - providing decoupled solution with a reliable techology
  

<?xml version='1.0' encoding="iso-8859-1"?>
<PRODUCTS>
	<DETAIL>
		<DESC>D1</DESC>
		<PRODUCT_NAME>APL</PRODUCT_NAME>
	</DETAIL>
	<DETAIL>	
		<DESC>D2</DESC>
		<PRODUCT_NAME>ANL</PRODUCT_NAME>
	</DETAIL>
	<DETAIL>
		<DESC>D3</DESC>
		<PRODUCT_NAME>APL</PRODUCT_NAME>
	</DETAIL>
</PRODUCTS> 

<?xml version='1.0' encoding="iso-8859-1"?>
<PRODUCTS>
	<PRODUCT>
		<PRODUCT_NAME>ANL</PRODUCT_NAME>
		<DETAIL>	
			<DESC>D2</DESC>
			<PRODUCT_NAME>ANL</PRODUCT_NAME>
		</DETAIL>
	</PRODUCT>
	<PRODUCT>
		<PRODUCT_NAME>APL</PRODUCT_NAME>
		<DETAIL>
			<DESC>D1</DESC>
			<PRODUCT_NAME>APL</PRODUCT_NAME>
		</DETAIL>
		<DETAIL>
			<DESC>D3</DESC>
			<PRODUCT_NAME>APL</PRODUCT_NAME>
		</DETAIL>
	</PRODUCT>
</PRODUCTS> 

<!-- GROUPING USING THE MUENCHIAN METHOD: http://www.jenitennison.com/xslt/grouping/muenchian.html -->
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" indent="yes" encoding="iso-8859-1"/>

	<xsl:key name="details-by-product" match="DETAIL" use="PRODUCT_NAME" />

	<xsl:template match="PRODUCTS">
		<PRODUCTS>
		<xsl:for-each select="DETAIL[count(. | key('details-by-product', PRODUCT_NAME)[1]) = 1]">
			<xsl:sort select="PRODUCT_NAME" />
			<PRODUCT>
				<PRODUCT_NAME><xsl:value-of select="PRODUCT_NAME"/></PRODUCT_NAME>
				<xsl:for-each select="key('details-by-product', PRODUCT_NAME)">
					<DETAIL>
					<xsl:apply-templates/>
					</DETAIL>
				</xsl:for-each>
			</PRODUCT>
		</xsl:for-each>
		</PRODUCTS>
	</xsl:template>

	<xsl:template match="@*|node()">
	  <xsl:copy>
		<xsl:apply-templates select="@*|node()"/>
	  </xsl:copy>
	</xsl:template>
</xsl:stylesheet>

//Initiate XSLT in a script: http://msdn.microsoft.com/en-us/library/ms762796(VS.85).aspx
var oArgs = WScript.Arguments;

if (oArgs.length == 0)
{
    WScript.Echo ("Usage : cscript xslt.js xml xsl");
    WScript.Quit();
}
xmlFile = oArgs(0) + ".xml";
xslFile = oArgs(1) + ".xsl";

var xsl = new ActiveXObject("MSXML2.DOMDOCUMENT.6.0");
var xml = new ActiveXObject("MSXML2.DOMDocument.6.0");
xml.validateOnParse = false;
xml.async = false;
xml.load(xmlFile);

if (xml.parseError.errorCode != 0)
    WScript.Echo ("XML Parse Error : " + xml.parseError.reason);

xsl.async = false;
xsl.load(xslFile);

if (xsl.parseError.errorCode != 0)
    WScript.Echo ("XSL Parse Error : " + xsl.parseError.reason);

try
{
    WScript.Echo (xml.transformNode(xsl.documentElement));
}
catch(err)
{
    WScript.Echo ("Transformation Error : " + err.number + "*" + err.description);
}

// XslCompiledTransform: http://msdn.microsoft.com/en-us/library/system.xml.xsl.xslcompiledtransform_members.aspx
// Note: Exception handling is outside of the scope of this tip
// Note: Xml results are loaded into memory and do not have to be written into the file system, if there is no need for it.
private string ApplyStylesheet(string xml, string stylesheet)
{
	if (!string.IsNullOrEmpty(stylesheet))
	{
		//Configure the reader to skip all forms of validation
		XmlReaderSettings settingsReader = new XmlReaderSettings();
		settingsReader.ValidationType = ValidationType.None;
		settingsReader.ProhibitDtd = false;
		settingsReader.XmlResolver = null;

		StringReader strReader = new StringReader(xml);
		XmlReader xmlReader = XmlReader.Create(strReader, settingsReader);
		// use XmlNodeReader xmlReader = new XmlNodeReader(xml); if xml is XmlNode (not a string)

		StringWriter stringWriter = new StringWriter();
		XmlTextWriter xmlWriter = new XmlTextWriter(stringWriter);

		XslCompiledTransform xslt = new XslCompiledTransform();
		xslt.Load(stylesheet);
		xslt.Transform(xmlReader, xmlWriter);

		xmlWriter.Close();
		xmlReader.Close();

		return stringWriter.ToString();
	}
	return xml;
}

/*
CREATE TABLE Tasks
(
	ID INT IDENTITY PRIMARY KEY,
	START_TIME DATETIME NOT NULL,
	END_TIME DATETIME NOT NULL
)
GO
INSERT INTO Tasks (START_TIME, END_TIME)
SELECT '2007-01-01 6:34:12 AM', '2007-01-01 12:45:34 PM' UNION ALL
SELECT '2007-01-02 9:23:08 AM', '2007-01-02 5:05:37 PM' UNION ALL
SELECT '2007-01-03 4:34:12 PM', '2007-01-03 4:55:18 PM' UNION ALL
SELECT '2007-01-04 11:02:00 AM', '2007-01-05 2:53:21 PM' UNION ALL
SELECT '2007-01-05 7:52:55 AM', '2007-07-05 9:08:48 AM' UNION ALL
SELECT '2007-01-06 7:59:11 PM', '2010-01-07 1:23:11 AM' UNION ALL
SELECT '2008-12-31 18:20', '2009-01-01 17:20'
GO
*/
-- DURATIONS http://www.sqlteam.com/article/working-with-time-spans-and-durations-in-sql-server
SELECT *,
       (TOTAL_SS) / 31536000 AS YY,
       DATEDIFF(MONTH, 0, END_TIME - START_TIME) % 12 AS MM,
       (TOTAL_SS % 31536000) / 604800 AS WW,  -- 604800 = 7 * 24 * 60 * 60
       (TOTAL_SS % 31536000) / 86400 AS DD,   -- 3153600 = 365 * 24 * 60 * 60
       (TOTAL_SS % 86400) / 3600 AS HH,       -- 86400 = 24 * 60 * 60
       (TOTAL_SS % 3600)/60 AS MI,            -- 3600 = 60 * 60
       (TOTAL_SS % 60) AS SS
FROM   ( -- DATEDIFF (Transact-SQL) / see the comment at the bottom of the page: http://msdn.microsoft.com/en-us/library/ms189794.aspx
         SELECT   START_TIME,
                  END_TIME,
                  END_TIME - START_TIME AS TOTAL,
                  DATEDIFF(ss, 0, END_TIME - START_TIME) AS TOTAL_SS
            FROM  Tasks
            WHERE END_TIME >= START_TIME
        ) AS Q1

-- PADDING http://sqlblogcasts.com/blogs/tonyrogerson/archive/2006/05/29/765.aspx
DECLARE @CH CHAR(1) = '0', 
        @LEN INT = 2, 
        @N INT = 1
SELECT CASE WHEN @LEN > LEN(@N) THEN REPLICATE(@CH, @LEN - LEN(@N)) ELSE '' END + CAST(@N AS VARCHAR) AS PADDED_NUMBER 

-- DATE ONLY http://www.bennadel.com/blog/122-Getting-Only-the-Date-Part-of-a-Date-Time-Stamp-in-SQL-Server.htm 
SELECT CAST (FLOOR(CAST (GETDATE() AS FLOAT)) AS DATETIME) AS DATE_ONLY

public static void BuildQuery(out string sql_cmd, out OleDbParameter[] sql_params, int mode, string tbl, string input, __arglist)
{         
    sql_params = null;
    sql_cmd = String.Empty;
    try
    {
        string[] rcrd_params = input.Split(new Char[] { ',' });

        ArgIterator param_iter = new ArgIterator(__arglist);
        int param_count = param_iter.GetRemainingCount();

        if (param_count != rcrd_params.Length)
        {
            ErrorLogDataSource.LogError(String.Format(
                "Failed to build query with {1}/{2} parameters", 
                param_count, rcrd_params.Length));
            return; 
        }
     
        sql_params = new OleDbParameter[param_count];
        sql_cmd = String.Empty;
        for (int i = 0; i < param_count; i++)
        {
            Object param = TypedReference.ToObject(param_iter.GetNextArg());
            sql_params[i] = new OleDbParameter(rcrd_params[i], param);

            // Logic to append to sql_cmd goes here...

        }
    } catch (Exception ex)
    {
        sql_cmd = String.Empty;
        sql_params = null;

        ErrorLogDataSource.LogException(new Exception(
            String.Format("Failed to build query for {1} with {2} in {3} mode - {0}", 
            ex.Message, tbl, input, mode), 
            ex));
    }
}

public static List<Object> GetStatusTypes(int ID, string Name, string Description, bool Reload, int UserID)
{            
    if ((!isCached) || (Reload))
    {
        DataSourceAdapter.BuildQuery(out sql_cmd, out sql_params, 3, tbl_name, "Name,Description,ID,ID", __arglist("%", "%", -1, -1));
        cache = DataSourceAdapter.ExecQuery(typeof(StatusType), sql_cmd, sql_params);
        isCached = true;
        listFilter = null;
    }
    // ....
}

DESCRIPTION:
        SC is a command line program used for communicating with the
        NT Service Controller and services.
USAGE:
        sc <server> [command] [service name] <option1> <option2>...

        The option <server> has the form "\\ServerName"
        Further help on commands can be obtained by typing: "sc [command]"
        Commands:
          query-----------Queries the status for a service, or
                          enumerates the status for types of services.
          queryex---------Queries the extended status for a service, or
                          enumerates the status for types of services.
          start-----------Starts a service.
          pause-----------Sends a PAUSE control request to a service.
          interrogate-----Sends an INTERROGATE control request to a service.
          continue--------Sends a CONTINUE control request to a service.
          stop------------Sends a STOP request to a service.
          config----------Changes the configuration of a service (persistant).
          description-----Changes the description of a service.
          failure---------Changes the actions taken by a service upon failure.
          qc--------------Queries the configuration information for a service.
          qdescription----Queries the description for a service.
          qfailure--------Queries the actions taken by a service upon failure.
          delete----------Deletes a service (from the registry).
          create----------Creates a service. (adds it to the registry).
          control---------Sends a control to a service.
          sdshow----------Displays a service's security descriptor.
          sdset-----------Sets a service's security descriptor.
          GetDisplayName--Gets the DisplayName for a service.
          GetKeyName------Gets the ServiceKeyName for a service.
          EnumDepend------Enumerates Service Dependencies.

        The following commands do not require a service name:
        sc <server> <command> <option>
          boot------------(ok | bad) Indicates whether the last boot should
                          be saved as the last-known-good boot configuration
          Lock------------Locks the Service Database
          QueryLock-------Queries the LockStatus for the SCManager Database
EXAMPLE:
        sc start MyService

QUERY SESSION [sessionname | username | sessionid]
              [/SERVER:servername] [/MODE] [/FLOW] [/CONNECT] [/COUNTER]

  sessionname         Identifies the session named sessionname.
  username            Identifies the session with user username.
  sessionid           Identifies the session with ID sessionid.
  /SERVER:servername  The server to be queried (default is current).
  /MODE               Display current line settings.
  /FLOW               Display current flow control settings.
  /CONNECT            Display current connect settings.
  /COUNTER            Display current Terminal Services counters information.

RESET SESSION {sessionname | sessionid} [/SERVER:servername] [/V]

  sessionname         Identifies the session with name sessionname.
  sessionid           Identifies the session with ID sessionid.
  /SERVER:servername  The server containing the session (default is current).
  /V                  Display additional information.

<style type='text/css'>
.TableContainer div { 
 width:900px;
 padding-bottom: 20px;
 overflow-x:auto;
 overflow-y:hidden; 
}
.locked {
 position: relative; 
}
</style>

<style type='text/css'>

/* HORIZONTAL SCROLLING */
.TableContainer div{
 width:800px;
 padding-bottom: 20px;
 overflow-x:auto;
 overflow-y:hidden;
}
.locked {
 position: relative; 
}

/* VERTICAL SCROLLING */
.TableContainer tbody{
 height:300px;
 overflow-x:hidden;
 overflow-y:auto;
 padding-right: 20px;
 /*direction:rtl; // Use to place the scroll bar on the left side */
}
/* Prevent IE from using the TBODY height for all the TR's */
.TableContainer tbody tr {
 height: auto;
 white-space: nowrap;
}
</style>

private void MakeAccessible(GridView grid)
        {
            // complements of 
            // http://blog.madskristensen.dk/post/Make-the-GridView-control-accessible.aspx
            if (grid.Rows.Count > 0)
            {
                //This replaces <td> with <th> and adds the scope attribute
                grid.UseAccessibleHeader = true;

                //This will add the <thead> and <tbody> elements
                grid.HeaderRow.TableSection = TableRowSection.TableHeader;

                //This adds the <tfoot> element. Remove if you don't have a footer row
                grid.FooterRow.TableSection = TableRowSection.TableFooter;

                // To avoid out of order Pager rows: The table  must contain row sections in order of header, body, then footer
                // http://msnetprogrammer.net/blog/archive/2007/02/02/5.aspx
                if (grid.TopPagerRow != null)
                {
                    grid.TopPagerRow.TableSection = TableRowSection.TableHeader;
                }
                if (grid.BottomPagerRow != null)
                {
                    grid.BottomPagerRow.TableSection = TableRowSection.TableFooter;
                }

            }
        }

<script type="text/javascript">
/* compliments to http://www.robertnyman.com/index.php?p=256 */
function getElementsByClassName(oElm, strTagName, oClassNames){
	var arrElements = (strTagName == "*" && oElm.all)? oElm.all : oElm.getElementsByTagName(strTagName);
	var arrReturnElements = new Array();
	var arrRegExpClassNames = new Array();
	if(typeof oClassNames == "object"){
		for(var i=0; i<oClassNames.length; i++){
			arrRegExpClassNames.push(new RegExp("(^|\s)" + oClassNames[i].replace(/-/g, "\-") + "(\s|$)"));
		}
	}
	else{
		arrRegExpClassNames.push(new RegExp("(^|\s)" + oClassNames.replace(/-/g, "\-") + "(\s|$)"));
	}
	var oElement;
	var bMatchesAll;
	for(var j=0; j<arrElements.length; j++){
		oElement = arrElements[j];
		bMatchesAll = true;
		for(var k=0; k<arrRegExpClassNames.length; k++){
			if(!arrRegExpClassNames[k].test(oElement.className)){
				bMatchesAll = false;
				break;
			}
		}
		if(bMatchesAll){
			arrReturnElements.push(oElement);
		}
	}
	return (arrReturnElements)
}

function OnScroll(){
    // alert("Scrolling...");    
    var cells = getElementsByClassName(document.getElementByID("div_OLMGridView"), "td", "locked"); 
    for (var i = 0; i < cells.length; i++){
        cells[i].style.left = cells[i].offsetParent.scrollLeft;
    }
}

function GetScroller(){
    var scroller = null; 
    var divs=document.getElementsByTagName('div');
	for (var i = 0; i < divs.length; i++) {
	    if (divs[i].parentNode.getAttribute('class') == "TableContainer"){
	        scroller = divs[i];
	        break;
	    }
	}
	return (scroller);
}

function AddScrollListener(){	
    var scroller = GetScroller();
    // alert(scroller);
    if (scroller != null){
	if (scroller.addEventListener){
            scroller.addEventListener('scroll', OnScroll, false);
        } else if (scroller.attachEvent){
            scroller.attachEvent('scroll', OnScroll);
        }
    }
}// run it on load, or just call the function when you startup.
window.onload = function(){AddScrollListener();}
</script>

<DIV STYLE="background-color: #CFCFCF; position: absolute; 
         left:expression(document.body.clientWidth/2-oDiv.offsetWidth/2);
         top:expression(document.body.clientHeight/2-oDiv.offsetHeight/2)"></DIV>

unit uUPOSFactory;

interface
uses
  uUPOSDeviceControl,
  uUPOSDeviceService;

const
  POSDEVICESINIFILE = 'C:\Program Files\Vivonet\iPOS\Client\PosDevices.ini';

function CreateDeviceService(DeviceName: string): TUPOSDeviceService;
function CreateDeviceControl(DeviceName: string): TUPOSDeviceControl;

implementation

uses
  IniFiles,
  Classes;

function GetClassName(DeviceName: string; DeviceObject: string):string;
var
  iniFile: TIniFile;
begin
  iniFile := TIniFile.Create(POSDEVICESINIFILE);
  Result := iniFile.ReadString(DeviceName, DeviceObject, 'T' + DeviceName + DeviceObject);
  iniFile.Free;
end;

function CreateDeviceService(DeviceName: string): TUPOSDeviceService;
var
  DeviceClass: TPersistentClass;
begin
  try
    DeviceClass := GetClass(GetClassName(DeviceName, 'Service'));
    Result := TUPOSDeviceService(DeviceClass.Create);
  except
    Result := nil;
  end;
end;

function CreateDeviceControl(DeviceName: string): TUPOSDeviceControl;
var
  DeviceClass: TPersistentClass;
begin
  try
    DeviceClass := GetClass(GetClassName(DeviceName, 'Control'));
    Result := TUPOSDeviceControl(DeviceClass.Create);
  except
    Result := nil;
  end;
end;
end.

CURRENCY Currency_Amount;
CString Currency_Text = "";
Currency_Text.Format("%.2f", (float)(Currency_Amount.int64) / 10000);

CURRENCY Currency_Amount; 
COleCurrency COleCurr_Amount;
MSXML::IXMLDOMNodePtr pNode;
pNode = pDOMDoc->selectSingleNode("//Amount/Authorize");
if(pNode)
{
   COleCurr_Amount.ParseCurrency(W2T(pNode->Gettext()));
   Currency_Amount = COleCurr_Amount.m_cur;
}

while PeekMessage(Msg, 0, 0, 0, PM_REMOVE) do begin
  TranslateMessage(Msg);
  DispatchMessage(Msg);
end;

function TApplication.ProcessMessage(var Msg: TMsg): Boolean;
var
  Handled: Boolean;
begin
  Result := False;
  if PeekMessage(Msg, 0, 0, 0, PM_REMOVE) then
  begin
    Result := True;
    if Msg.Message <> WM_QUIT then
    begin
      Handled := False;
      if Assigned(FOnMessage) then FOnMessage(Msg, Handled);
      if not IsHintMsg(Msg) and not Handled and not IsMDIMsg(Msg) and
        not IsKeyMsg(Msg) and not IsDlgMsg(Msg) then
      begin
        TranslateMessage(Msg);
        DispatchMessage(Msg);
      end;
    end
    else
      FTerminate := True;
  end;
end;