/// <summary>
/// Convert database types to C# types
/// </summary>
/// <param name="field">Column or parameter</param>
/// <returns>The C# (rough) equivalent of the field's data type</returns>
public string GetCSType(DataObjectBase field)
{
if ( field.NativeType.ToLower() == "real" )
return "System.Single" + ( field.AllowDBNull?"?":"" );
else if ( field.NativeType.ToLower() == "xml" )
return "string";
//else if (field.NativeType.ToLower() == "xml")
// return "System.Xml.XmlNode";
else if ( !IsCSReferenceDataType( field ) && field.AllowDBNull )
return field.SystemType.ToString() + "?";
else
return field.SystemType.ToString();
//return GetCSType(field.DataType);
}
/// <summary>
/// Crea rappresentazione Xml
/// </summary>
/// <param name="xw"></param>
/// <param name="obj"></param>
/// <param name="depth"></param>
public override void WriteXml(XmlWrite xw, DataObjectBase obj, int depth)
{
//Scrive proprietà base
object oValue = this.GetValueForDb(obj);
if (!this.IsMapped)
{
if (oValue != null)
{
xw.WriteElementString(this.Column.Name, oValue.ToString());
}
else
{
xw.WriteElementString(this.Column.Name, string.Empty);
}
}
//Include oggetto mappato se profondita' prevista e campio non null
if (depth > 0 && (this.IsMapped || oValue != null))
{
var oTemp = this.GetValue(obj);
if (oTemp != null)
{
//Include oggetto
xw.WriteStartElement(this.Name);
try
{
xw.WriteRaw(((DataObjectBase)oTemp).ToXml(depth - 1));
}
finally
{
xw.WriteEndElement();
}
}
}
}
public string GetDeleteSQL(DataObjectBase BO)
{
string BOName = BO.BO_Name;
string PKName = BO.PK_Name;
string sql = "Delete from {0} where {1}";
string filter = PKName + "=";
Type botype = BO.GetType();
PropertyInfo[] infos = botype.GetProperties();
foreach (PropertyInfo info in infos)
{
string ColName = info.Name;
if (ColName.ToLower().Trim() == PKName.ToLower().Trim())
{
object pkid = info.GetValue(BO, null);
filter += pkid.ToString();
break;
}
}
sql = string.Format(sql, BOName, filter);
return(sql);
}
public bool Update(DataObjectBase BO, SqlCommand cmd, string Filter)
{
//string sql = GetUpdateSQL(BO);
string sql = GetUpdateAllPropertySQL(BO);
int Index = sql.ToUpper().IndexOf("WHERE");
if (Index > 0)
{
sql = sql.Remove(Index);
}
sql = sql + " WHERE " + Filter;
try
{
this.Execute(sql);
//cmd.CommandText = sql;
//cmd.ExecuteNonQuery();
return(true);
}
catch (Exception ex)
{
throw ex;
//return false;
}
}
/// <summary>
/// 复制值
/// </summary>
/// <param name="source">复制的源字段</param>
protected override void CopyValueInner(DataObjectBase source)
{
var sourceEntity = source as RoleData;
if (sourceEntity == null)
{
return;
}
this._id = sourceEntity._id;
this._role = sourceEntity._role;
this._caption = sourceEntity._caption;
this._memo = sourceEntity._memo;
this._datastate = sourceEntity._datastate;
this._isfreeze = sourceEntity._isfreeze;
this._authorid = sourceEntity._authorid;
this._adddate = sourceEntity._adddate;
this._lastreviserid = sourceEntity._lastreviserid;
this._lastmodifydate = sourceEntity._lastmodifydate;
this._auditstate = sourceEntity._auditstate;
this._auditorid = sourceEntity._auditorid;
this._auditdate = sourceEntity._auditdate;
CopyExtendValue(sourceEntity);
this.__EntityStatus.SetModified();
}
public static string GetDefaultValue(DataObjectBase col)
{
switch (col.DataType)
{
case DbType.Guid: return "Guid.Empty";
case DbType.AnsiString: return "string.Empty";
case DbType.AnsiStringFixedLength: return "string.Empty";
case DbType.String: return "string.Empty";
case DbType.StringFixedLength: return "string.Empty";
case DbType.Boolean: return "false";
case DbType.Date:
case DbType.DateTime:
if (col.AllowDBNull)
{
string colName = col.Name.ToLower();
if (colName.IndexOf("end") >= 0) return "new SmartDate(SmartDate.EmptyValue.MaxDate)";
if (colName.IndexOf("inactive") >= 0) return "new SmartDate(SmartDate.EmptyValue.MaxDate)";
if (colName.IndexOf("finish") >= 0) return "new SmartDate(SmartDate.EmptyValue.MaxDate)";
return "new SmartDate(SmartDate.EmptyValue.MinDate)";
}
else
{
if (col.Name.ToLower().IndexOf("timestamp") >= 0)
return "new SmartDate(DateTime.Now)";
else
return "new SmartDate(DateTime.Today)";
}
case DbType.VarNumeric: return "0";
case DbType.Currency: return "0";
case DbType.Decimal: return "0";
case DbType.Double: return "0";
case DbType.Int16: return "0";
case DbType.Int32: return "0";
case DbType.Int64: return "0";
case DbType.Single: return "0";
case DbType.Byte: return "0";
case DbType.UInt16: return "0";
case DbType.UInt32: return "0";
case DbType.UInt64: return "0";
default: return "";
}
}
private void Load(DataObjectBase col)
{
_dbColumnName = col.Name;
_name = CsHelper.GetPropertyName(col);
_type = CsHelper.GetVariableType(col);
_nativeType = _type == "SmartDate" ? "DateTime" : _type;
if (col.AllowDBNull && _type != "string") _nativeType += "?"; //nullable when value types
_defaultValue = CsHelper.GetDefaultValue(col);
_isIdentity = CsHelper.IsIdentity(col);
ColumnSchema column = col as ColumnSchema;
if (column != null)
{
_isPrimaryKey = column.IsPrimaryKeyMember;
_isFilterKey = column.IsForeignKeyMember;
}
_allowDbNull = col.AllowDBNull;
_isComputed = CsHelper.IsComputed(col);
_isTimestamp = CsHelper.IsTimestamp(col);
//required string
if (_allowDbNull == false && _type == "string")
_validationRules.Add(new RuleInfo(this, CommonRuleHandler.StringRequired, string.Empty, 0));
//fixsize string is <= 8000, add max length rule
if (_type == "string" && col.Size > 0 && col.Size <= 8000 && col.NativeType != "text" && col.NativeType != "ntext")
_validationRules.Add(new RuleInfo(this, CommonRuleHandler.StringMaxLength, col.Size.ToString(), 0));
//email
if (_type == "string" && _name.ToLower().IndexOf("email")>=0)
_validationRules.Add(new RuleInfo(this, CommonRuleHandler.RegExMatch, "Email", 0));
//ssn
if (_type == "string" && _name.ToLower().IndexOf("ssn") >= 0)
_validationRules.Add(new RuleInfo(this, CommonRuleHandler.RegExMatch, "SSN", 0));
}
/// <summary>
/// Returns true if the column is represented as a reference data type
/// rather than a value type. In other words, the C# code can set a
/// column of this data type to 'null'
/// </summary>
public bool IsCSReferenceDataType(DataObjectBase column)
{
if (column.NativeType.ToLower() == "real")
return false;
else if (column.NativeType.ToLower() == "xml")
return true;
else
{
DbType dataType = column.DataType;
switch (dataType)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.String:
case DbType.StringFixedLength:
case DbType.Binary:
return true;
case DbType.Boolean:
case DbType.Guid:
case DbType.Byte:
case DbType.Currency:
case DbType.Date:
case DbType.DateTime:
case DbType.Decimal:
case DbType.Double:
case DbType.Int16:
case DbType.Int32:
case DbType.Int64:
case DbType.Object:
case DbType.Single:
case DbType.Time:
case DbType.VarNumeric:
return false;
default:
return false;
}
}
}
public JsonResult <SceneRecordDataObject> GetSceneRecord(DataObjectBase obj)
{
return(Json(this.sceneRecordService.GetRecord(obj.ID)));
}
private static bool IsRowVersion(DataObjectBase column)
{
bool isTimeStamp = column.NativeType.Equals(
"timestamp", StringComparison.OrdinalIgnoreCase);
bool isRowVersion = column.NativeType.Equals(
"rowversion", StringComparison.OrdinalIgnoreCase);
return (isTimeStamp || isRowVersion);
}
private static string GetDbType(DataObjectBase column)
{
if (column.Database.Provider.Name != "SqlSchemaProvider")
return column.NativeType;
return GetSqlTypeDeclaration(
column.NativeType,
column.Size,
column.Precision,
column.Scale,
!column.AllowDBNull,
IsIdentity(column));
}
private bool IsEnumAssociation(DataObjectBase columnSchema, out string typeName)
{
bool isEnum, wasEnum;
typeName = IsOrWasEnumAssociation(columnSchema, out isEnum, out wasEnum);
return isEnum;
}
public JsonResult <CaseHandlingDataObject> GetCaseHandling(DataObjectBase obj)
{
return(Json(this.caseHandlingService.GetCaseHandling(obj.ID)));
}
public EnumSettings GetSettings(DataObjectBase dataObjectBase)
{
return(this.FirstOrDefault(t => t.FullName == dataObjectBase.FullName));
}
/// <summary>
/// This will look up and see if a column name should be escaped with delimited identifiers '[]'.
/// http://msdn.microsoft.com/en-us/library/aa224033(SQL.80).aspx
/// </summary>
/// <param name="column">The source.</param>
/// <returns></returns>
protected static string GetDelimitedIdentifier(DataObjectBase column)
{
return(GetDelimitedIdentifier(column.Name, false));
}
/// <summary>
/// Returns a C# member variable declaration statement.
/// </summary>
/// <param name="protectionLevel"></param>
/// <param name="column"></param>
/// <returns></returns>
protected virtual string GetMemberVariableDeclarationStatement(string protectionLevel, DataObjectBase column)
{
string statement = String.Format("{0} ", protectionLevel);
statement += String.Format("{0} {1}", GetCSharpVariableType(column), GetMemberVariableName(column.Name));
string defaultValue = GetMemberVariableDefaultValue(column);
if (defaultValue != "")
{
statement += String.Format(" = {0}", defaultValue);
}
statement += ";";
return(statement);
}
/// <summary>
/// Scrive DTO
/// </summary>
/// <param name="dto"></param>
/// <param name="obj"></param>
/// <param name="depth"></param>
public override void WriteDTO(Dictionary <string, object> dto, DataObjectBase obj, int depth)
{
dto.Add(this.Name, this.GetValue(obj));
}
public JsonResult <AskRecordDataObject> GetAskRecord(DataObjectBase obj)
{
return(Json(this.askRecordService.GetAskRecord(obj.ID)));
}
// SUMMARY: only this is in use! TIMELINE
public TimelineTable LoadTimeline(EntranceTableData data)
{
string command = "";
#region # prepare reference days #
DateTime startingDate = DateTime.Parse(data.From),
endingDate = DateTime.Parse(data.To),
referenceStartDate = DateTime.Now,
referenceEndDate = DateTime.Now;
switch (data.StatisticGroupBy)
{
case "HOUR":
referenceStartDate = new DateTime(startingDate.Year, startingDate.Month, startingDate.Day, 0, 0, 0);
startingDate = startingDate.AddDays(1);
referenceEndDate = new DateTime(startingDate.Year, startingDate.Month, startingDate.Day, 0, 0, 0);
break;
case "WEEK":
startingDate = startingDate.AddDays(1 - (int)startingDate.DayOfWeek);
referenceStartDate = new DateTime(startingDate.Year, startingDate.Month, startingDate.Day, 0, 0, 0);
startingDate = startingDate.AddDays(7);
referenceEndDate = new DateTime(startingDate.Year, startingDate.Month, startingDate.Day, 0, 0, 0);
data.StatisticGroupBy = "DAY";
break;
case "MONTH":
referenceStartDate = new DateTime(startingDate.Year, startingDate.Month, 1, 0, 0, 0);
startingDate = startingDate.AddMonths(1);
referenceEndDate = new DateTime(startingDate.Year, startingDate.Month, 1, 0, 0, 0);
data.StatisticGroupBy = "DAY";
break;
case "YEAR":
referenceStartDate = new DateTime(startingDate.Year, 1, 1, 0, 0, 0);
startingDate = startingDate.AddYears(1);
referenceEndDate = new DateTime(startingDate.Year, 1, 1, 0, 0, 0);
data.StatisticGroupBy = "MONTH";
break;
}
#endregion
string startDate = data.ConvertDate(referenceStartDate),
endDate = data.ConvertDate(referenceEndDate);
#region # sql command #
command = " SELECT us._time, us.num AS 'us_num', pr.num AS 'pr_num', t.num AS 't_num', st.num AS 'st_num' " +
" FROM " +
" ( " +
" SELECT COUNT(*) AS num, DATEPART("+ data.StatisticGroupBy + ", us.Created) AS _time FROM MobilePaywall.core.UserSession AS us, " +
//" LEFT OUTER JOIN MobilePaywall.core.Service AS s ON us.ServiceID=s.ServiceID " +
//" WHERE us.Created >= '" + startDate + "' AND us.Created <= '" + endDate + "' " +
" ( SELECT UserSessionGuid FROM MobilePaywall.core.UserSession AS us WHERE us.Created >= '" + startDate + "' AND us.Created <= '" + endDate + "' GROUP BY us.UserSessionGuid ) AS us1, " +
" ( SELECT ServiceID, Name, Description FROM MobilePaywall.core.Service AS s ) AS s " +
" WHERE us1.UserSessionGuid=us.UserSessionGuid AND us.ServiceID=s.ServiceID AND us.Created >= '" + startDate + "' AND us.Created <= '" + endDate + "' " +
" AND ( '" + data.Service + "' = '' " + DataObjectBase.PrepareList("s.Name LIKE '%{0}%'", data.Services) + " ) " +
" AND ( '" + data.MobileOperator + "' = -1 OR us.MobileOperatorID = '" + data.MobileOperator + "' ) " +
" AND ( '" + data.Country + "' = '' " + DataObjectBase.PrepareList("s.Description LIKE UPPER('{0}') + '%' ", data.Countries) + " ) " +
" GROUP BY DATEPART("+ data.StatisticGroupBy + ", us.Created) " +
" ) AS us " +
" LEFT OUTER JOIN " +
" ( " +
" SELECT COUNT(*) AS num, DATEPART("+ data.StatisticGroupBy + ", pr.Created) AS _time FROM MobilePaywall.core.PaymentRequest AS pr " +
" LEFT OUTER JOIN MobilePaywall.core.UserSession AS us ON pr.UserSessionID=us.UserSessionID "+
" LEFT OUTER JOIN MobilePaywall.core.Service AS s ON us.ServiceID=s.ServiceID "+
" WHERE pr.Created >= '"+ startDate + "' AND pr.Created <= '" + endDate + "' " +
" AND ( '" + data.Service + "' = '' " + DataObjectBase.PrepareList("s.Name LIKE '%{0}%'", data.Services) + " ) " +
" AND ( '" + data.MobileOperator + "' = -1 OR us.MobileOperatorID = '" + data.MobileOperator + "' ) " +
" AND ( '" + data.Country + "' = '' " + DataObjectBase.PrepareList("s.Description LIKE UPPER('{0}') + '%' ", data.Countries) + " ) " +
" GROUP BY DATEPART("+ data.StatisticGroupBy + ", pr.Created) " +
" ) AS pr ON us._time=pr._time " +
" LEFT OUTER JOIN " +
" ( " +
" SELECT COUNT(*) AS num, DATEPART("+ data.StatisticGroupBy + ", t.Created) AS _time FROM MobilePaywall.core.[Transaction] AS t " +
" LEFT OUTER JOIN MobilePaywall.core.Payment AS p ON t.PaymentID=p.PaymentID "+
" LEFT OUTER JOIN MobilePaywall.core.PaymentRequest AS pr ON p.PaymentRequestID=pr.PaymentRequestID "+
" LEFT OUTER JOIN MobilePaywall.core.UserSession AS us ON pr.UserSessionID=us.UserSessionID "+
" LEFT OUTER JOIN MobilePaywall.core.Service AS s ON us.ServiceID=s.ServiceID "+
" WHERE t.Created >= '"+ startDate + "' AND t.Created <= '" + endDate + "' AND t.TransactionStatusID=5 " +
" AND ( '" + data.Service + "' = '' " + DataObjectBase.PrepareList("s.Name LIKE '%{0}%'", data.Services) + " ) " +
" AND ( '" + data.MobileOperator + "' = -1 OR us.MobileOperatorID = '" + data.MobileOperator + "' ) " +
" AND ( '" + data.Country + "' = '' " + DataObjectBase.PrepareList("s.Description LIKE UPPER('{0}') + '%' ", data.Countries) + " ) " +
" AND (SELECT COUNT(*) FROM MobilePaywall.core.[Transaction] WHERE PaymentID=p.PaymentID)=1 "+
" GROUP BY DATEPART("+ data.StatisticGroupBy + ", t.Created) "+
" ) AS t ON t._time=us._time " +
" LEFT OUTER JOIN " +
" ( " +
" SELECT COUNT(*) AS num, DATEPART("+ data.StatisticGroupBy + ", t.Created) AS _time FROM MobilePaywall.core.[Transaction] AS t " +
" LEFT OUTER JOIN MobilePaywall.core.Payment AS p ON t.PaymentID=p.PaymentID "+
" LEFT OUTER JOIN MobilePaywall.core.PaymentRequest AS pr ON p.PaymentRequestID=pr.PaymentRequestID "+
" LEFT OUTER JOIN MobilePaywall.core.UserSession AS us ON pr.UserSessionID=us.UserSessionID "+
" LEFT OUTER JOIN MobilePaywall.core.Service AS s ON us.ServiceID=s.ServiceID "+
" WHERE t.Created >= '"+ startDate + "' AND t.Created <= '" + endDate + "' AND t.TransactionStatusID=5 " +
" AND ( '" + data.Service + "' = '' " + DataObjectBase.PrepareList("s.Name LIKE '%{0}%'", data.Services) + " ) " +
" AND ( '" + data.MobileOperator + "' = -1 OR us.MobileOperatorID = '" + data.MobileOperator + "' ) " +
" AND ( '" + data.Country + "' = '' " + DataObjectBase.PrepareList("s.Description LIKE UPPER('{0}') + '%' ", data.Countries) + " ) " +
" AND (SELECT COUNT(*) FROM MobilePaywall.core.[Transaction] WHERE PaymentID=p.PaymentID)>1 "+
" GROUP BY DATEPART("+ data.StatisticGroupBy + ", t.Created) "+
" ) AS st ON st._time=us._time " +
" ORDER BY us._time ASC ";
#endregion
TimelineTable returnTable = new TimelineTable();
returnTable.Title = string.Format("Group by {0} in time of {1} - {2}", data.StatisticGroupBy, referenceStartDate.ToString(), referenceEndDate.ToString());
DataTable table = this.Load(command);
if (table == null)
{
return(returnTable);
}
foreach (DataRow row in table.Rows)
{
returnTable.Time.Add(string.IsNullOrEmpty(row[(int)TimelineTable.Columns.Time].ToString()) ? "0" : row[(int)TimelineTable.Columns.Time].ToString());
returnTable.UserSession.Add(string.IsNullOrEmpty(row[(int)TimelineTable.Columns.UserSession].ToString()) ? "0" : row[(int)TimelineTable.Columns.UserSession].ToString());
returnTable.Identification.Add(string.IsNullOrEmpty(row[(int)TimelineTable.Columns.Identification].ToString()) ? "0" : row[(int)TimelineTable.Columns.Identification].ToString());
returnTable.Transaction.Add(string.IsNullOrEmpty(row[(int)TimelineTable.Columns.Transaction].ToString()) ? "0" : row[(int)TimelineTable.Columns.Transaction].ToString());
returnTable.Subsequent.Add(string.IsNullOrEmpty(row[(int)TimelineTable.Columns.Subsequent].ToString()) ? "0" : row[(int)TimelineTable.Columns.Subsequent].ToString());
}
return(returnTable);
}
public static bool IsComputed(DataObjectBase col)
{
if (col.ExtendedProperties["CS_IsComputed"] == null) return false;
return (bool)col.ExtendedProperties["CS_IsComputed"].Value;
}
private static string GetDefaultValue(DataObjectBase column)
{
try
{
if (!column.ExtendedProperties.Contains(ExtendedPropertyNames.DefaultValue))
return null;
string value = column.ExtendedProperties[ExtendedPropertyNames.DefaultValue].Value.ToString();
return value;
}
catch (Exception ex)
{
Debug.WriteLine("Error: " + ex.Message);
}
return null;
}
public string GetCSDefaultByType(DataObjectBase column)
{
if (column.AllowDBNull || (column is ColumnSchema && (column as ColumnSchema).IsPrimaryKeyMember && IsDefaultSet(column as ColumnSchema)))
return "(" + GetCSType(column) + ")null";
if (column.NativeType.ToLower() == "real")
return "0F";
else
{
DbType dataType = column.DataType;
switch (dataType)
{
case DbType.AnsiString:
return "String.Empty";
case DbType.AnsiStringFixedLength:
return "String.Empty";
case DbType.String:
return "String.Empty";
case DbType.Boolean:
return "false";
case DbType.StringFixedLength:
return "String.Empty";
case DbType.Guid:
return "Guid.Empty";
case DbType.Binary:
return "new byte[] {}";
case DbType.Byte:
return "(byte)0";
case DbType.Currency:
return "0M";
case DbType.Date:
return "(DateTime)SqlDateTime.MinValue";
case DbType.DateTime:
return "(DateTime)SqlDateTime.MinValue";
case DbType.Decimal:
return "0M";
case DbType.Double:
return "0D";
case DbType.Int16:
return "(short)0";
case DbType.Int32:
return "0";
case DbType.Int64:
return "(long)0";
case DbType.Object:
return "null";
case DbType.Single:
return "0F";
case DbType.Time:
return "(DateTime)SqlDateTime.MinValue";
case DbType.VarNumeric:
return "0";
default:
return "null";
}
}
}
private string IsOrWasEnumAssociation(DataObjectBase dataObject, out bool isEnum, out bool wasEnum)
{
string name = String.Empty;
ColumnSchema columnSchema = dataObject as ColumnSchema;
isEnum = false;
wasEnum = false;
if (columnSchema == null || !columnSchema.IsForeignKeyMember)
return name;
foreach (TableKeySchema tableKeySchema in columnSchema.Table.ForeignKeys)
{
// find columns ...
ColumnSchema primaryColumn = null;
for (int i = 0; i < tableKeySchema.ForeignKeyMemberColumns.Count; i++)
{
if (tableKeySchema.ForeignKeyMemberColumns[i].Column != columnSchema)
continue;
primaryColumn = tableKeySchema.PrimaryKeyMemberColumns[i].Column;
break;
}
if (primaryColumn == null)
continue;
// Is Enum
TableSchema primaryKeyTable = tableKeySchema.PrimaryKeyTable;
if (Settings.IsEnum(primaryKeyTable))
{
name = GetEnum(primaryKeyTable).Name;
isEnum = true;
}
// Was Enum
DbmlEnum.Enum existingEnum = _existingEnumDatabase.Enums
.Where(e => e.Table == primaryKeyTable.FullName)
.FirstOrDefault();
if (existingEnum != null)
{
if (String.IsNullOrEmpty(name))
name = existingEnum.Name;
wasEnum = true;
}
if (isEnum || wasEnum)
break;
// find column in pktable, if that is fkey too, check that parent.
if (primaryColumn.IsForeignKeyMember && primaryColumn != dataObject)
return IsOrWasEnumAssociation(primaryColumn, out isEnum, out wasEnum);
}
return name;
}
/// <summary>
/// Convert database types to C# types
/// </summary>
/// <param name="field">Column or parameter</param>
/// <returns>The C# (rough) equivalent of the field's data type</returns>
public string GetCSType(DataObjectBase field)
{
//return field.NativeType;
if (field.NativeType.ToLower() == "real")
return "System.Single";
else
return field.SystemType.ToString();
//return GetCSType(field.DataType);
}
private static bool IsDbGenerated(DataObjectBase column)
{
if (IsRowVersion(column))
return true;
if (IsIdentity(column))
return true;
bool isComputed = false;
string value;
try
{
if (column.ExtendedProperties.Contains("CS_IsComputed"))
{
value = column.ExtendedProperties["CS_IsComputed"].Value.ToString();
bool.TryParse(value, out isComputed);
}
}
catch (Exception ex)
{
Debug.WriteLine("Error: " + ex.Message);
}
return isComputed;
}
/// <summary>
/// Imposta i parametri da utilizzare nella where utilizzando quanto gia' presente nell'oggetto di input
/// </summary>
/// <param name="dbIn"></param>
/// <param name="objIn"></param>
/// <returns>L'array contente i valori della key utilizzati</returns>
public object[] FillKeyQueryWhereParams(IDataBase dbIn, DataObjectBase objIn)
{
return(this.FillKeyQueryWhereParams(dbIn, this.GetValuesForDb(objIn)));
}
public JsonResult <InvolvedDataObject> GetInvolved(DataObjectBase involved)
{
return(Json(this.involvedService.GetByID(involved.ID)));
}
public PropertyInfo(DataObjectBase column, ObjectInfo parent)
{
_parent = parent;
Load(column);
}
/// <summary>
/// Convert database types to C# types
/// </summary>
/// <param name="field">Column or parameter</param>
/// <returns>The C# (rough) equivalent of the field's data type</returns>
public string GetCSType(DataObjectBase column)
{
bool setNullable = column.AllowDBNull || (column is ColumnSchema && (column as ColumnSchema).IsPrimaryKeyMember && IsDefaultSet(column as ColumnSchema));
if (column.NativeType.ToLower() == "real")
return "decimal" + (column.AllowDBNull ? "?" : "");
else
{
DbType dataType = column.DataType;
switch (dataType)
{
case DbType.AnsiString:
return "string";
case DbType.AnsiStringFixedLength:
return "string";
case DbType.String:
return "string";
case DbType.Boolean:
return "bool" + (setNullable ? "?" : "");
case DbType.StringFixedLength:
return "string";
case DbType.Guid:
return "Guid" + (setNullable ? "?" : "");
case DbType.Binary:
return "byte[]";
case DbType.Byte:
return "byte" + (setNullable ? "?" : "");
case DbType.Currency:
return "decimal" + (setNullable ? "?" : "");
case DbType.Date:
return "DateTime" + (setNullable ? "?" : "");
case DbType.DateTime:
return "DateTime" + (setNullable ? "?" : "");
case DbType.Decimal:
return "decimal" + (setNullable ? "?" : "");
case DbType.Double:
return "double" + (setNullable ? "?" : "");
case DbType.Int16:
return "short" + (setNullable ? "?" : "");
case DbType.Int32:
return "int" + (setNullable ? "?" : "");
case DbType.Int64:
return "long" + (setNullable ? "?" : "");
case DbType.Object:
return "object";
case DbType.Single:
return "float" + (setNullable ? "?" : "");
case DbType.Time:
return "DateTime" + (setNullable ? "?" : "");
case DbType.VarNumeric:
return "int" + (setNullable ? "?" : "");
default:
return "object";
}
}
}
public int GetDataTypeSize(DataObjectBase column)
{
int size = 1;
switch (column.DataType)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.String:
case DbType.StringFixedLength:
{
if (column.NativeType != "text" && column.NativeType != "ntext")
{
if (column.Size > 0)
{
size = column.Size;
}
}
else
{
size = 3888;
}
break;
}
}
return size;
}
public void Upsert(DataObjectBase obj)
{
}
/// <summary>
/// Get the member variable styled version of a name
/// </summary>
/// <param name="column">The ColumnSchema with the name to be cleaned</param>
/// <returns>the cleaned, camelcased name with a _ prefix</returns>
public string GetMemberVariableName(DataObjectBase column)
{
return "_" + GetCleanParName(column.Name);
}
/// <summary>
/// Esegue test di confronto su oggetto
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public virtual bool PropertyTest(DataObjectBase obj)
{
bool bTest = false;
Property oProp = obj.mClassSchema.Properties.GetPropertyByName(this.mName);
object[] values;
//Gestione dati interni (solo al primo ciclo di test)
if (!this.mIsValueChecked)
{
if (oProp is PropertySimple)
{
//Converte il valore (se trattasi di valore standard)
if (this.mValue != null && !this.mValue.GetType().IsArray)
{
this.mValue = Convert.ChangeType(this.mValue, oProp.Type);
}
}
else if (oProp is PropertyObject)
{
if (this.mValue != null)
{
if (this.mValue is DataObjectBase)
{
DataObjectBase o = (DataObjectBase)this.mValue;
if (!o.mClassSchema.OriginalType.Equals(oProp.Type))
{
throw new Bdo.Objects.ObjectException("{0}.{1} - Errore nella verifica del filtro: la proprieta' e' di tipo {2}, il valore del filtro e' di tipo {3}", oProp.Schema.ClassName, oProp.Name, oProp.Type.Name, o.mClassSchema.OriginalType.Name);
}
}
else
{ //NON E' UN DATAOBJECT: lo creo solo se non trattasi di una IN
if (this.mOperator != EOperator.In)
{
//Se pk e' array allora esegue il cast e lo passa cosi
object[] pk = this.mValue as object[];
if (pk == null)
{
pk = new object[] { this.mValue }
}
; //Crea array PK
//Passato valore PK: crea relativo dataobject
this.mValue = obj.GetSlot().LoadObjectInternalByKEY(ClassSchema.PRIMARY_KEY, oProp.Type, true, pk);
}
}
}
}
this.mIsValueChecked = true;
}
//Prende il valore della property
object oValue = oProp.GetValue(obj);
switch (this.mOperator)
{
case EOperator.Equal:
bTest = object.Equals(this.mValue, oValue);
break;
case EOperator.Differs:
bTest = !object.Equals(this.mValue, oValue);
break;
case EOperator.GreaterThan: //Attenzione gli operatori di confronto sono invertiti poiche' il termine che esegue il confronto e' quello che dobbiamo verificare
bTest = (((IComparable)this.mValue).CompareTo(oValue) < 0);
break;
case EOperator.GreaterEquals:
bTest = (((IComparable)this.mValue).CompareTo(oValue) <= 0);
break;
case EOperator.LessThan:
bTest = (((IComparable)this.mValue).CompareTo(oValue) > 0);
break;
case EOperator.LessEquals:
bTest = (((IComparable)this.mValue).CompareTo(oValue) >= 0);
break;
case EOperator.Like:
bTest = System.Text.RegularExpressions.Regex.IsMatch(this.mValue.ToString(), oValue.ToString());
break;
case EOperator.NotLike:
bTest = !System.Text.RegularExpressions.Regex.IsMatch(this.mValue.ToString(), oValue.ToString());
break;
case EOperator.Between:
values = this.mValue as object[];
bTest = (((IComparable)values[0]).CompareTo(oValue) <= 0) &&
(((IComparable)values[1]).CompareTo(oValue) >= 0);
break;
case EOperator.IsNull:
bTest = (oValue == null);
break;
case EOperator.IsNotNull:
bTest = (oValue != null);
break;
case EOperator.In:
values = this.mValue as object[];
for (int i = 0; i < values.Length; i++)
{
//Esegue la conversione di ciascun tipo
var oFilt = new FilterEQUAL(this.Name, values[i]);
if (oFilt.PropertyTest(obj))
{
bTest = true;
break;
}
}
break;
default:
throw new ArgumentException(Resources.ObjectMessages.Base_OperatorUnknown);
}
//Verifica chain
if (this.mChain != null)
{
for (int i = 0; i < this.mChain.Count; i++)
{
if (this.mChain[i].IsAnd)
{
bTest &= this.mChain[i].Filter.PropertyTest(obj);
}
else
{
bTest |= this.mChain[i].Filter.PropertyTest(obj);
}
}
}
//Ritorna esito
return(bTest);
}
public string GetReaderMethodByType(DataObjectBase column)
{
if (column.NativeType.ToLower() == "real")
return "GetDecimal";
else
{
DbType dataType = column.DataType;
switch (dataType)
{
case DbType.AnsiString:
return "GetString";
case DbType.AnsiStringFixedLength:
return "GetString";
case DbType.String:
return "GetString";
case DbType.Boolean:
return "GetBoolean";
case DbType.StringFixedLength:
return "GetString";
case DbType.Guid:
return "GetGuid";
case DbType.Binary:
return "__UNKNOWN__";
case DbType.Byte:
return "GetByte";
case DbType.Currency:
return "GetDecimal";
case DbType.Date:
return "GetDateTime";
case DbType.DateTime:
return "GetDateTime";
case DbType.Decimal:
return "GetDecimal";
case DbType.Double:
return "GetDouble";
case DbType.Int16:
return "GetInt16";
case DbType.Int32:
return "GetInt32";
case DbType.Int64:
return "GetInt64";
case DbType.Object:
return "GetValue";
case DbType.Single:
return "GetSingle";
case DbType.Time:
return "GetDateTime";
case DbType.VarNumeric:
return "GetInt32";
default:
return "GetValue";
}
}
}
public PropertyInfo(DataObjectBase column, ObjectInfo parent, bool isPrimaryKey, bool isFilterKey)
{
_parent = parent;
Load(column);
_isPrimaryKey = isPrimaryKey;
_isFilterKey = isFilterKey;
}
/// <summary>
/// Get the Sql Data type of a column
/// </summary>
/// <param name="column">Column for which to get the type</param>
/// <returns>String representing the SQL data type</returns>
public string GetSqlDbType(DataObjectBase column)
{
switch (column.NativeType)
{
case "bigint": return "BigInt";
case "binary": return "Binary";
case "bit": return "Bit";
case "char": return "Char";
case "datetime": return "DateTime";
case "decimal": return "Decimal";
case "float": return "Float";
case "image": return "Image";
case "int": return "Int";
case "money": return "Money";
case "nchar": return "NChar";
case "ntext": return "NText";
case "numeric": return "Decimal";
case "nvarchar": return "NVarChar";
case "real": return "Real";
case "smalldatetime": return "SmallDateTime";
case "smallint": return "SmallInt";
case "smallmoney": return "SmallMoney";
case "sql_variant": return "Variant";
case "sysname": return "NChar";
case "text": return "Text";
case "timestamp": return "Timestamp";
case "tinyint": return "TinyInt";
case "uniqueidentifier": return "UniqueIdentifier";
case "varbinary": return "VarBinary";
case "varchar": return "VarChar";
default: return "__UNKNOWN__" + column.NativeType;
}
}
public static string GetPropertyName(DataObjectBase col)
{
string name = col.Name;
//ensure first character is capital letter
name = name.Substring(0, 1).ToUpper() + name.Substring(1);
//convert ex:START_DATE or Start Date to StartDate
if (name.IndexOf('_') >= 0 || name.IndexOf(' ') >= 0 || name == name.ToUpper())
name = CsHelper.MakeProper(name);
//fix name that contain table prefix
//ex table:Project column:ProjectName, ProjectDescription
if(col is ColumnSchema)
name = name.Replace(((ColumnSchema)col).Table.Name, "");
if (name.EndsWith("TypeCode"))
name = name.Substring(0, name.Length - 4);
if(name.Length == 0)
throw new Exception("Column " + col.Name + " has resulted blank property name");
return name;
}
/// <summary>
/// Returns the C# variable type based on the given column.
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
private string GetVBVariableType(DataObjectBase column)
{
return(DbTypeToVB[column.DataType.ToString(), column.SystemType.Name]);
}
public static string GetVariableType(DataObjectBase col)
{
switch (col.DataType)
{
case DbType.AnsiString: return "string";
case DbType.AnsiStringFixedLength: return "string";
case DbType.String: return "string";
case DbType.StringFixedLength: return "string";
case DbType.Binary: return "byte[]";
case DbType.Boolean: return "bool";
case DbType.Byte: return "byte";
case DbType.Currency: return "decimal";
case DbType.Date: return "SmartDate";
case DbType.DateTime: return "SmartDate";
case DbType.VarNumeric: return "decimal";
case DbType.Decimal: return "decimal";
case DbType.Double: return "double";
case DbType.Guid: return "Guid";
case DbType.Int16: return "short";
case DbType.Int32: return "int";
case DbType.Int64: return "long";
case DbType.Object: return "object";
case DbType.SByte: return "sbyte";
case DbType.Single: return "float";
case DbType.Time: return "TimeSpan";
case DbType.UInt16: return "ushort";
case DbType.UInt32: return "uint";
case DbType.UInt64: return "ulong";
default: return "__UNKNOWN__" + col.NativeType;
}
}
/// <summary>
/// Returns a VB.Net member variable declaration statement.
/// </summary>
/// <param name="protectionLevel"></param>
/// <param name="column"></param>
/// <returns></returns>
protected override string GetMemberVariableDeclarationStatement(string protectionLevel, DataObjectBase column)
{
string statement = protectionLevel + " ";
statement += GetMemberVariableName(column.Name) + " As " + GetVBVariableType(column);
string defaultValue = GetMemberVariableDefaultValue(column);
if (defaultValue != "")
{
statement += " = " + defaultValue;
}
return(statement);
}
public static bool IsTimestamp(DataObjectBase col)
{
bool var = false;
if (col.NativeType.ToLower() == "timestamp")
var = true;
else if (col.Name.ToLower().IndexOf("timestamp") >= 0)
var = true;
return var;
}
public abstract void SetValue(DataObjectBase obj, object value);
private static bool HasDefaultValue(DataObjectBase column)
{
try
{
if (!column.ExtendedProperties.Contains(ExtendedPropertyNames.DefaultValue))
return false;
string value = column.ExtendedProperties[ExtendedPropertyNames.DefaultValue].Value.ToString();
return !string.IsNullOrEmpty(value);
}
catch (Exception ex)
{
Debug.WriteLine("Error: " + ex.Message);
}
return false;
}
public abstract void WriteXml(XmlWrite xw, DataObjectBase obj, int depth);
private bool IsOrWasEnumAssociation(DataObjectBase dataObject)
{
bool isEnum, wasEnum;
IsOrWasEnumAssociation(dataObject, out isEnum, out wasEnum);
return (isEnum || wasEnum);
}
public abstract void WriteDTO(Dictionary <string, object> dto, DataObjectBase obj, int depth);
private void PopulateColumn(Column column, DataObjectBase columnSchema, string className)
{
bool canUpdateType = string.IsNullOrEmpty(column.Type)
|| column.Type.StartsWith("System.")
|| IsOrWasEnumAssociation(columnSchema);
if (canUpdateType)
column.Type = GetColumnType(columnSchema);
if (!PropertyNames.ContainsKey(className))
PropertyNames.Add(className, new List<string>());
//Column/@Member is edit safe if it is NullOrEmpty.
// However, if the column starts with a digit, then we ARE going to update it.
if (string.IsNullOrEmpty(column.Member) || CleanNumberPrefix.IsMatch(column.Member))
{
column.Member = ToPropertyName(className, columnSchema.Name);
column.Storage = CommonUtility.GetFieldName(column.Member);
}
else
{
PropertyNames[className].Add(column.Member);
}
if (columnSchema.NativeType.Equals("text", StringComparison.OrdinalIgnoreCase)
|| columnSchema.NativeType.Equals("ntext", StringComparison.OrdinalIgnoreCase)
|| columnSchema.NativeType.Equals("xml", StringComparison.OrdinalIgnoreCase)
|| columnSchema.NativeType.Equals("binary", StringComparison.OrdinalIgnoreCase)
|| columnSchema.NativeType.Equals("image", StringComparison.OrdinalIgnoreCase))
column.UpdateCheck = UpdateCheck.Never;
column.DbType = GetDbType(columnSchema);
column.CanBeNull = columnSchema.AllowDBNull;
column.IsVersion = IsRowVersion(columnSchema);
if (!column.IsDbGenerated.HasValue)
column.IsDbGenerated = IsDbGenerated(columnSchema);
column.IsProcessed = true;
}
public abstract void ReadDTO(Dictionary <string, object> dto, DataObjectBase obj);
private static string GetSystemType(DataObjectBase d)
{
if (d.SystemType == typeof(XmlDocument))
return "System.Xml.Linq.XElement";
if (d.SystemType == typeof(byte[]))
return "System.Data.Linq.Binary";
return d.SystemType.ToString();
}
public abstract void SetValueFromReader(DataObjectBase obj, IDataReader dr);
private static bool IsIdentity(DataObjectBase column)
{
string temp;
bool isIdentity = false;
try
{
if (column.ExtendedProperties.Contains("CS_IsIdentity"))
{
temp = column.ExtendedProperties["CS_IsIdentity"].Value.ToString();
bool.TryParse(temp, out isIdentity);
}
}
catch (Exception ex)
{
Debug.WriteLine("Error: " + ex.Message);
}
return isIdentity;
}
/// <summary>
/// Metodo privato di impostazione proprietà
/// </summary>
/// <param name="obj"></param>
/// <param name="value"></param>
public override void SetValue(DataObjectBase obj, object value)
{
throw new NotImplementedException();
}
private string GetColumnType(DataObjectBase columnSchema)
{
string typeName;
return IsEnumAssociation(columnSchema as ColumnSchema, out typeName)
? typeName
: GetSystemType(columnSchema);
}
/// <summary>
/// Legge DTO
/// </summary>
/// <param name="dto"></param>
/// <param name="obj"></param>
public override void ReadDTO(Dictionary <string, object> dto, DataObjectBase obj)
{
throw new NotImplementedException();
}
private string IsOrWasEnumAssociation(DataObjectBase dataObject, out bool isEnum, out bool wasEnum)
{
string name = String.Empty;
ColumnSchema columnSchema = dataObject as ColumnSchema;
isEnum = false;
wasEnum = false;
if (columnSchema == null || !columnSchema.IsForeignKeyMember)
{
return(name);
}
foreach (TableKeySchema tableKeySchema in columnSchema.Table.ForeignKeys)
{
// find columns ...
ColumnSchema primaryColumn = null;
for (int i = 0; i < tableKeySchema.ForeignKeyMemberColumns.Count; i++)
{
if (tableKeySchema.ForeignKeyMemberColumns[i].Column != columnSchema)
{
continue;
}
primaryColumn = tableKeySchema.PrimaryKeyMemberColumns[i].Column;
break;
}
if (primaryColumn == null)
{
continue;
}
// Is Enum
TableSchema primaryKeyTable = tableKeySchema.PrimaryKeyTable;
if (Settings.IsEnum(primaryKeyTable))
{
name = GetEnum(primaryKeyTable).Name;
isEnum = true;
}
// Was Enum
DbmlEnum.Enum existingEnum = _existingEnumDatabase.Enums
.Where(e => e.Table == primaryKeyTable.FullName)
.FirstOrDefault();
if (existingEnum != null)
{
if (String.IsNullOrEmpty(name))
{
name = existingEnum.Name;
}
wasEnum = true;
}
if (isEnum || wasEnum)
{
break;
}
// find column in pktable, if that is fkey too, check that parent.
if (primaryColumn.IsForeignKeyMember && primaryColumn != dataObject)
{
return(IsOrWasEnumAssociation(primaryColumn, out isEnum, out wasEnum));
}
}
return(name);
}
/// <summary>
/// Carica valori proprieta' da datareader
/// </summary>
/// <param name="obj"></param>
/// <param name="dr"></param>
public override void SetValueFromReader(DataObjectBase obj, IDataReader dr)
{
throw new NotImplementedException();
}
public JsonResult <FilingDataObject> GetFiling(DataObjectBase obj)
{
return(Json(this.filingService.GetFiling(obj.ID)));
}
public abstract BusinessObjectBase Create(DataObjectBase dalObj);
public void Patch(DataObjectBase obj, Func <DataObjectBase, DataObjectBase> applyPatch)
{
}
/*
/// <summary>
/// Get a default value for a given data type
/// </summary>
/// <param name="dataType">Data type for which to get the default value<</param>
/// <returns>A string representation of the default value</returns>
public string GetCSDefaultByType(DbType dataType)
{
}
*/
/// <summary>
/// Get a mock value for a given data type. Used by the unit test classes.
/// </summary>
/// <param name="column">Data type for which to get the default value.</param>
/// <param name="stringValue">a mock string value.</param>
/// <param name="bValue">a mock boolean value.</param>
/// <param name="guidValue">a mock Guid value.</param>
/// <param name="numValue">a mock numeric value.</param>
/// <param name="dtValue">a mock datetime value.</param>
/// <returns>A string representation of the default value.</returns>
public string GetCSMockValueByType(DataObjectBase column, string stringValue, bool bValue, Guid guidValue, int numValue, DateTime dtValue)
{
if (column.NativeType.ToLower() == "real")
return numValue.ToString() + "F";
else
{
switch (column.DataType)
{
case DbType.AnsiString:
return "\"" + stringValue + "\"";
case DbType.AnsiStringFixedLength:
return "\"" + stringValue + "\"";
case DbType.String:
return "\"" + stringValue + "\"";
case DbType.Boolean:
return bValue.ToString().ToLower();
case DbType.StringFixedLength:
return "\"" + stringValue + "\"";
case DbType.Guid:
return "new Guid(\"" + guidValue.ToString() + "\")";
//Answer modified was just 0
case DbType.Binary:
return "new byte[] {" + numValue.ToString() + "}";
//Answer modified was just 0
case DbType.Byte:
return "(byte)" + numValue.ToString() + "";
//return "{ 0 }";
case DbType.Currency:
return numValue.ToString();
case DbType.Date:
return string.Format("new DateTime({0}, {1}, {2}, 0, 0, 0, 0)", dtValue.Date.Year, dtValue.Date.Month, dtValue.Date.Day);
case DbType.DateTime:
return string.Format("new DateTime({0}, {1}, {2}, {3}, {4}, {5}, {6})", dtValue.Year, dtValue.Month, dtValue.Day, dtValue.Hour, dtValue.Minute, dtValue.Second, dtValue.Millisecond);
case DbType.Decimal:
return numValue.ToString() + "m";
//return "0M";
//return "0.0M";
case DbType.Double:
return numValue.ToString() + ".0f";
case DbType.Int16:
return "(short)" + numValue.ToString();
case DbType.Int32:
return "(int)" + numValue.ToString();
case DbType.Int64:
return "(long)" + numValue.ToString();
case DbType.Object:
return "null";
case DbType.Single:
return numValue.ToString() + "F";
//case DbType.Time: return "DateTime.MaxValue";
case DbType.Time:
return string.Format("new DateTime({0}, {1}, {2}, {3}, {4}, {5}, {6})", dtValue.Year, dtValue.Month, dtValue.Day, dtValue.Hour, dtValue.Minute, dtValue.Second, dtValue.Millisecond);
case DbType.VarNumeric:
return numValue.ToString();
//the following won't be used
// case DbType.SByte: return "0";
// case DbType.UInt16: return "0";
// case DbType.UInt32: return "0";
// case DbType.UInt64: return "0";
default: return "null";
}
}
}
