public static bool ValidateRenderArgValue(RenderArgDomainSchema renderArg, RenderArgDomainValue argValues, ref string msg)
{
//Return if template doesn't need argument value for rendering.
if (renderArg == null || renderArg.Parameters == null || renderArg.Parameters.Count == 0)
{
return(true);
}
if (argValues == null || argValues.Parameters == null || argValues.Parameters.Count == 0)
{
msg += "RenderArgument is null or empty.";
return(false);
}
if (renderArg.Parameters.Count > argValues.Parameters.Count)
{
msg += string.Format("Argument missing. This template needs value for {0} parameters.", renderArg.Parameters.Count);
return(false);
}
Dictionary <long, string> errors = new Dictionary <long, string>();
bool isValid = ValidateRenderArgType(renderArg, ref msg);
if (!isValid)
{
return(false);
}
for (int i = 0; i < renderArg.Parameters.Count; i++)
{
RenderParameterSchema paramInfo = renderArg.Parameters[i];
//Get corresponding param value base on Name
RenderParameterBase paramValueInfo = (from c in argValues.Parameters
where string.Compare(c.Name, paramInfo.Name, true) == 0
select c).FirstOrDefault();
//If needed parameter isn't found.
if (paramValueInfo == null || paramValueInfo.Value == null || paramValueInfo.Value.Count() == 0)
{
isValid = false;
msg += string.Format("Parameter value is not found: {0}.", paramInfo.Name);
continue;
}
object paramValue = paramInfo.DataType.IsArray ? paramValueInfo.Value : paramValueInfo.Value[0];
//Validate value and length
SQLTypeName dataType = SQLConvertTypeHelper.GetSqlTypeFromString(paramInfo.DataType.Name);
DataTypeLength length = CoreRenderHelper.GetDataTypeLengthFromSXLength(paramInfo.DataType.Length);
if (!SQLDBTypeValidator.ValidateValue(dataType, length, paramValue, paramInfo.DataType.IsArray))
{
isValid = false;
msg += string.Format("Type of parameter value is invalid: {0}.", paramInfo.Name);
}
}
return(isValid);
}
private string ProcessOsqlGetAppData(ChecksumInfoItem item, RenderArgDomainValue renderArgumentValue, string conn, OsqlXml osqlXml)
{
string osqlData = string.Empty;
foreach (var osqlItem in osqlXml.OsqlXmlItems)
{
if (string.Compare(osqlItem.DomainName, renderArgumentValue.Name, true) == 0)
{
osqlData = GetDataAgrumentValueWithDBType(item, osqlItem.Osql, renderArgumentValue, conn);
}
}
return(osqlData);
}
public Dictionary <string, string> GetOsqlDataFromAppDB(List <ChecksumInfoItem> checksumItems, RenderArgumentValue renderArgumentValue, MDB mdb, OsqlXml osqlXml, ref string msg)
{
Dictionary <string, string> dicOsqlResult = new Dictionary <string, string>();
Validator validator = new Validator();
bool isValid = true;
//Get list DBID , Connection string and validate DBID
Dictionary <string, string> lstAppDb = GetDBID(mdb.ListAppDB, ref msg);
//Validate DBID
List <string> lstDBID = lstAppDb.Keys.ToList();
isValid &= Validator.ValidateDBID(checksumItems, lstDBID, ref msg);
foreach (var appdb in lstAppDb)
{
List <ChecksumInfoItem> lstCheckSumItems = checksumItems.Where(x => string.Compare(x.DBID, appdb.Key, true) == 0).ToList();
if (lstCheckSumItems.Count() > 0)
{
//2. Execute all Osqls, get data for domains
foreach (ChecksumInfoItem item in lstCheckSumItems)
{
RenderArgDomainValue domainRenderArgValue = new RenderArgDomainValue();
try
{
domainRenderArgValue = renderArgumentValue.Domains.First(c => c.Name == item.DomainName);
}
catch (Exception)
{ msg += item.DomainName + " not match with input info !!! \n"; }
//Validate RenderArgumentDomainValue
isValid &= validator.ValidateRenderArgumentDomainValue(item, domainRenderArgValue, ref msg);
string result = ProcessOsqlGetAppData(item, domainRenderArgValue, appdb.Value, osqlXml);
string encodedDomainName = XmlHelper.Encode(item.DomainName);
dicOsqlResult.Add(encodedDomainName, result);
}
}
}
if (!isValid)
{
throw new Exception(msg);
}
//3. Return result of all Osql executed on a Database
return(dicOsqlResult);
}
private void AddParamRenderArgumentXY(ref SqlCommand command, RenderArgDomainValue renderArgumentValue, ChecksumInfoItem item)
{
if (item.RenderArgument.RenderArgumentX)
{
command.Parameters.Add(CoreRenderHelper.CreateAppSqlParam("@" + FrameworkConstants.RenderArgumentX,
string.Format("{0}", renderArgumentValue.RenderArgumentX),
SqlDbType.NVarChar));
}
if (item.RenderArgument.RenderArgumentY)
{
command.Parameters.Add(CoreRenderHelper.CreateAppSqlParam("@" + FrameworkConstants.RenderArgumentY,
string.Format("{0}", renderArgumentValue.RenderArgumentY),
SqlDbType.NVarChar));
}
}
public bool ValidateRenderArgumentDomainValue(ChecksumInfoItem csItem, RenderArgDomainValue domainRenderArgValue, ref string msg)
{
bool isValid = true;
if (domainRenderArgValue == null)
{
isValid = false;
msg += "RenderArgumentDomainValue is null or empty !!!";
}
//Validate RenderArgument value before render document
isValid &= ValidateRenderArgValue(csItem.RenderArgument, domainRenderArgValue, ref msg);
//Validate RenderArgumentX value, RenderArgumentY value before Render Document
isValid &= ValidateRenderArgumentXYValueBeforeRender(csItem.RenderArgument, domainRenderArgValue, ref msg);
return(isValid);
}
public static bool ValidateRenderArgumentXYValueBeforeRender(RenderArgDomainSchema renderArg, RenderArgDomainValue domainValue, ref string msg)
{
bool isValid = true;
if (renderArg.RenderArgumentX)
{
if (domainValue.RenderArgumentX == null)
{
msg += string.Format("Parameter value is not found: RenderArgumentX.");
isValid = false;
}
}
if (renderArg.RenderArgumentY)
{
if (domainValue.RenderArgumentY == null)
{
msg += string.Format("Parameter value is not found: {0}.", "RenderArgumentY");
isValid = false;
}
}
return(isValid);
}
private string GetDataAgrumentValueWithDBType(ChecksumInfoItem item, string osqlStr, RenderArgDomainValue renderArgumentValue, string conn)
{
DBType dbtype = (DBType)Utility.GetDBType(item.DBType);
switch (dbtype)
{
case DBType.Sql2008:
{
Sql08GetDataAgrumentDao dao = new Sql08GetDataAgrumentDao();
string osqlData = dao.GetDataAgrumentValueFromAppDB(item, osqlStr, renderArgumentValue, conn);
return(osqlData);
}
case DBType.Orc10g:
default:
throw new NotSupportedException();
}
}
public string GetDataAgrumentValueFromAppDB(ChecksumInfoItem item, string osql, RenderArgDomainValue renderArgumentValue, string conn)
{
string osqlData = string.Empty;
//Retrieve data from Application database
XmlReader xmlReader = null;
try
{
SqlCommand command = new SqlCommand();
command.CommandText = osql;//osqlQuery always not null or empty.
if (item.RenderArgument != null && renderArgumentValue != null)
{
for (int i = 0; i < item.RenderArgument.Parameters.Count; i++)
{
RenderParameterSchema sxParam = item.RenderArgument.Parameters[i];
SqlParameter sqlParameter = CoreRenderHelper.CreateSqlParamForAnArgument(sxParam, renderArgumentValue);
command.Parameters.Add(sqlParameter);
}
}
//Add System Supplier param
SystemParameter systemParameter = item.SystemParameter;
AddSystemSupplier(ref command, systemParameter);
//Add Watermark string
command.Parameters.Add(CoreRenderHelper.CreateAppSqlParam("@" + FrameworkConstants.PdwWatermark, "WaterMark", SqlDbType.NVarChar));
//Add param RenderArgumentX , RenderArgumentY
AddParamRenderArgumentXY(ref command, renderArgumentValue, item);
string connectionStr = base.GetConnectionString(conn.Trim());
xmlReader = ExecuteXmlReader(connectionStr, command);
}
catch (SqlException ex)
{
throw ex;
}
#region Transfer data to StringBuilder object
XmlDocument xDoc = new XmlDocument();
xDoc.Load(xmlReader);
xmlReader.Close();
osqlData = xDoc.InnerXml;
#endregion
return(osqlData);
}
