/// <summary>
/// Add field to meta class
/// </summary>
/// <param name="mdContext"></param>
/// <param name="field"></param>
/// <param name="metaClassName"></param>
private void JoinField(MetaDataContext mdContext, MetaField field, string metaClassName)
{
var cls = MetaClass.Load(mdContext, metaClassName);
if (MetaFieldIsNotConnected(field, cls))
{
cls.AddField(field);
}
}
public MetaClass(Mediachase.MetaDataPlus.Configurator.MetaClass metaClass)
{
Id = metaClass.Id;
IsSystem = metaClass.IsSystem;
Name = metaClass.Name;
Description = metaClass.Description;
FriendlyName = metaClass.FriendlyName;
IsAbstract = metaClass.IsAbstract;
IsUser = metaClass.IsUser;
MetaClassType = metaClass.MetaClassType;
MetaClassTypeName = metaClass.MetaClassType.ToString();
Namespace = metaClass.Namespace;
TableName = metaClass.TableName;
Tag = metaClass.Tag;
}
private void TryAddStringMetaField(MetaDataContext context, Mediachase.MetaDataPlus.Configurator.MetaClass metaClass, string name)
{
var metaField = Mediachase.MetaDataPlus.Configurator.MetaField.Load(context, name) ?? Mediachase.MetaDataPlus.Configurator.MetaField.Create(
context: context,
metaNamespace: metaClass.Namespace,
name: name,
friendlyName: name,
description: name,
dataType: MetaDataType.NVarChar,
length: 4000,
allowNulls: true,
multiLanguageValue: false,
allowSearch: false,
isEncrypted: false);
if (metaClass.MetaFields.All(x => x.Id != metaField.Id))
{
metaClass.AddField(metaField);
}
}
public DibsPayment(MetaClass metaClass)
: base(metaClass)
{
this.PaymentType = PaymentType.CreditCard;
}
private static void RebuildProjectsSearch(MetaClass mc)
{
string ProjectSearch = @"if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[ProjectsSearch]') and " +
@"OBJECTPROPERTY(id, N'IsProcedure') = 1)" + "\r\n" +
@"drop procedure [dbo].[ProjectsSearch]" + "\r\n" +
@"GO" + "\r\n" +
"\r\n" +
@"SET QUOTED_IDENTIFIER OFF " + "\r\n" +
@"GO" + "\r\n" +
@"SET ANSI_NULLS ON " + "\r\n" +
@"GO" + "\r\n" +
"\r\n" +
@"CREATE PROCEDURE [dbo].[ProjectsSearch]" + Environment.NewLine +
@" @UserId as int," + Environment.NewLine +
@" @Keyword as nvarchar(100)" + Environment.NewLine +
@"as " + Environment.NewLine +
@"DECLARE @IsPPM_Exec bit" + Environment.NewLine +
@"SET @IsPPM_Exec = 0" + Environment.NewLine +
@"IF EXISTS(SELECT * FROM USER_GROUP WHERE UserId = @UserId AND (GroupId = 4 OR GroupId = 7)) -- PPM " +
@"or Exec" + Environment.NewLine +
@" SET @IsPPM_Exec = 1" + Environment.NewLine +
@"SET @Keyword = '%' + @Keyword + '%'" + Environment.NewLine +
@"SELECT P.ProjectId, P.ManagerId, P.Title, P.[Description], P.StatusId, P.PercentCompleted, " + Environment.NewLine +
@" P.StartDate, P.FinishDate, P.TargetStartDate, P.TargetFinishDate, P.ActualStartDate, " +
@"P.ActualFinishDate, ISNULL(P.ProjectCode, '') AS ProjectCode" + Environment.NewLine +
@" FROM PROJECTS P " + Environment.NewLine +
@" LEFT JOIN PROJECT_SECURITY_ALL PS ON (P.ProjectId = PS.ProjectId AND PS.PrincipalId = @UserId)" + Environment.NewLine +
@" -- Auto-Generate Code" + Environment.NewLine +
@" [%=ForEach(""SELECT MC.MetaClassId, MC.TableName FROM MetaClass MC JOIN MetaClass PMC ON " +
@"MC.ParentClassId=PMC.MetaClassId WHERE PMC.Name = 'Projects'"","" "",""LEFT JOIN {1} AS MDPO{0} " +
@"ON P.ProjectId = MDPO{0}.ObjectId"")=%]" + Environment.NewLine +
@" -- End Auto-Generate Code" + Environment.NewLine +
@" WHERE (@IsPPM_Exec = 1 OR PS.IsManager = 1 OR PS.IsExecutiveManager = 1 OR PS.IsTeamMember = 1 OR " +
@"PS.IsSponsor = 1 OR PS.IsStakeHolder = 1)" + Environment.NewLine +
@" AND " + Environment.NewLine +
@" (" + Environment.NewLine +
@" P.Title LIKE @Keyword OR " + Environment.NewLine +
@" P.[Description] LIKE @Keyword OR " + Environment.NewLine +
@" P.ProjectCode LIKE @Keyword OR " + Environment.NewLine +
@" CAST(P.ProjectId AS nvarchar(10)) LIKE @Keyword " + Environment.NewLine +
@" OR" + Environment.NewLine +
@" -- Auto-Generate Code" + Environment.NewLine +
@" [%=ForEach(""SELECT MC.MetaClassId, MC.Name FROM MetaClass MC JOIN MetaClass PMC ON " +
@"MC.ParentClassId=PMC.MetaClassId WHERE PMC.Name = " +
@"'Projects'"",""OR"",""[%=SearchByKeyword(MDPO{0},@Keyword,{1})=%]"")=%] " + Environment.NewLine +
@" -- End Auto-Generate Code" + Environment.NewLine +
@" )" + Environment.NewLine+
@"GO" + "\r\n" +
"\r\n" +
@"SET QUOTED_IDENTIFIER OFF " + "\r\n" +
@"GO" + "\r\n" +
@"SET ANSI_NULLS ON " + "\r\n" +
@"GO" + "\r\n" +
"\r\n" +
@"";;
mc.FieldListChangedSqlScript = ProjectSearch;
}
public static MetaObject[] GetList(MetaClass type)
{
if (type == null)
throw new ArgumentNullException("type");
ArrayList retVal = new ArrayList();
using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.Text, string.Format(AsyncResources.GetConstantValue("SPAT_TABLE_List"), type.TableName)))
{
while (reader.Read())
{
retVal.Add(MetaObject.Load(type, reader));
}
reader.Close();
}
foreach (MetaObject obj in retVal)
{
obj.LoadMetaFields2();
}
return (MetaObject[])retVal.ToArray(typeof(MetaObject));
}
public PayExPayment(MetaClass metaClass)
: base(metaClass)
{
PaymentType = PaymentType.Other;
ImplementationClass = GetType().AssemblyQualifiedName;
}
/// <summary>
/// Sets the owner meta class.
/// </summary>
/// <param name="OwnerMetaClass">The owner meta class.</param>
internal void SetOwnerMetaClass(MetaClass OwnerMetaClass)
{
_ownerMetaClass = OwnerMetaClass;
}
public static MetaObject NewObject(int objectId, MetaClass type, int creatorId, DateTime created)
{
MetaObject retVal = new MetaObject();
retVal._objectId = objectId;
retVal._metaClass = type;
retVal._creatorId = creatorId;
retVal._created = created;
retVal._modifierId = creatorId;
retVal._modified = created;
retVal.LoadMetaFields();
return retVal;
}
/// <summary>
/// Gets the data reader.
/// </summary>
/// <param name="metaClass">The meta class.</param>
/// <returns></returns>
public static IDataReader GetDataReader(MetaClass metaClass)
{
#region ArgumentNullExceptions
if (metaClass == null)
throw new ArgumentNullException("metaClass", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
#endregion
return GetDataReader(metaClass.Id);
}
public static MetaObject NewObject(int objectId, MetaClass type)
{
return MetaObject.NewObject(objectId, type, -1, DateTime.Now);
}
public static MetaObject NewObject(int objectId, MetaClass type, int creatorId)
{
return MetaObject.NewObject(objectId, type, creatorId, DateTime.Now);
}
public static MetaObject Load(int objectId, MetaClass type, int modifierId, DateTime modified)
{
MetaObject retVal = null;
retVal = MetaObject.Load(objectId, type);
if (retVal != null)
{
retVal.ModifierId = modifierId;
retVal.Modified = modified;
}
return retVal;
}
public static MetaObject Load(int objectId, MetaClass type)
{
if (type == null)
throw new ArgumentNullException("type");
MetaObject retVal = null;
using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, string.Format(AsyncResources.GetConstantValue("SPAT_TABLE_Get"), type.TableName),
new SqlParameter("@ObjectId", objectId)/*,
new SqlParameter("@Language", MetaDataContext.Current.Language)*/
))
{
if (reader.Read())
{
retVal = MetaObject.Load(type, reader);
}
reader.Close();
}
if(retVal!=null)
retVal.LoadMetaFields2();
return retVal;
}
public static MetaObject[] GetList(MetaClass type, int modifierId, DateTime modified)
{
MetaObject[] retVal = null;
retVal = MetaObject.GetList(type);
if (retVal != null)
{
foreach (MetaObject item in retVal)
{
item.ModifierId = modifierId;
item.Modified = modified;
}
}
return retVal;
}
/// <summary>
/// Adds the specified new item.
/// </summary>
/// <param name="newItem">The new item.</param>
internal void Add(MetaClass newItem)
{
this.InnerList.Add(newItem);
}
/// <summary>
/// Loads the specified parent meta class.
/// </summary>
/// <param name="parentMetaClass">The parent meta class.</param>
/// <param name="reader">The reader.</param>
/// <returns></returns>
internal static MetaClass Load(MetaClass parentMetaClass, IDataReader reader)
{
MetaClass retVal = new MetaClass();
// Load MetaClass Information [11/18/2004]
retVal._id = (int)reader["MetaClassId"];
retVal._namespace = (string)reader["Namespace"];
retVal._name = (string)reader["Name"];
retVal._friendlyName = (string)reader["FriendlyName"];
if (reader["Description"] != DBNull.Value)
retVal._description = (string)reader["Description"];
retVal._tableName = (string)reader["TableName"];
retVal._isSystem = (bool)reader["IsSystem"];
if (reader["IsAbstract"] != DBNull.Value)
retVal._isAbstract = (bool)reader["IsAbstract"];
retVal._parentMetaClass = parentMetaClass;
retVal._parentMetaClassId = (int)SqlHelper.DBNull2Null(reader["ParentClassId"], (object)0);
retVal._fieldListChangedSqlScript = (string)SqlHelper.DBNull2Null(reader["FieldListChangedSqlScript"]);
retVal._tag = SqlHelper.DBNull2Null(reader["Tag"]);
return retVal;
}
public static void LoadMetaField(QObject qObject, MetaClass currentClass)
{
foreach (MetaField field in currentClass.UserMetaFields)
{
if (qObject.Fields[string.Format("{1}", qObject.OwnerTable, field.Name)] != null)
continue;
switch (field.DataType)
{
case MetaDataType.DictionaryMultivalue:
case MetaDataType.EnumMultivalue:
QField MFieldValue = new QField(string.Format("{1}", qObject.OwnerTable, field.Name),
field.FriendlyName,
"Value",
DbType.String,
QFieldUsingType.Field | QFieldUsingType.Grouping | QFieldUsingType.Filter,
new QFieldJoinRelation[]{
new QFieldJoinRelation(qObject.OwnerTable,currentClass.TableName,qObject.KeyField.DBName,"ObjectId"),
new QFieldJoinRelation(currentClass.TableName,"MetaMultivalueDictionary",field.Name,"MetaKey"),
new QFieldJoinRelation("MetaMultivalueDictionary","MetaDictionary","MetaDictionaryId","MetaDictionaryId",new SimpleFilterCondition(new QField("MetaFieldId"),field.Id.ToString(),SimpleFilterType.Equal))
}
);
QField MFieldId = new QField(string.Format("{1}Id", qObject.OwnerTable, field.Name),
field.FriendlyName,
"MetaDictionaryId",
DbType.String,
QFieldUsingType.Abstract,
new QFieldJoinRelation[]{
new QFieldJoinRelation(qObject.OwnerTable,currentClass.TableName,qObject.KeyField.DBName,"ObjectId"),
new QFieldJoinRelation(currentClass.TableName,"MetaMultivalueDictionary",field.Name,"MetaKey"),
new QFieldJoinRelation("MetaMultivalueDictionary","MetaDictionary","MetaDictionaryId","MetaDictionaryId",new SimpleFilterCondition(new QField("MetaFieldId"),field.Id.ToString(),SimpleFilterType.Equal))
}
);
qObject.Fields.Add(MFieldValue);
qObject.Fields.Add(MFieldId);
qObject.Dictionary.Add(new QDictionary(MFieldId, MFieldValue, string.Format("SELECT MetaDictionaryId as Id, Value FROM MetaDictionary WHERE MetaFieldId = {0}", field.Id)));
break;
case MetaDataType.DictionarySingleValue:
case MetaDataType.EnumSingleValue:
QField SFieldValue = new QField(string.Format("{1}", qObject.OwnerTable, field.Name),
field.FriendlyName,
"Value",
DbType.String,
QFieldUsingType.Field | QFieldUsingType.Grouping | QFieldUsingType.Filter | QFieldUsingType.Sort,
new QFieldJoinRelation[]{
new QFieldJoinRelation(qObject.OwnerTable,currentClass.TableName,qObject.KeyField.DBName,"ObjectId"),
new QFieldJoinRelation(currentClass.TableName,"MetaDictionary",field.Name,"MetaDictionaryId",new SimpleFilterCondition(new QField("MetaFieldId"),field.Id.ToString(),SimpleFilterType.Equal) )
}
);
QField SFieldId = new QField(string.Format("{1}Id", qObject.OwnerTable, field.Name),
field.FriendlyName,
"MetaDictionaryId",
DbType.String,
QFieldUsingType.Abstract,
new QFieldJoinRelation[]{
new QFieldJoinRelation(qObject.OwnerTable,currentClass.TableName,qObject.KeyField.DBName,"ObjectId"),
new QFieldJoinRelation(currentClass.TableName,"MetaDictionary",field.Name,"MetaDictionaryId",new SimpleFilterCondition(new QField("MetaFieldId"),field.Id.ToString(),SimpleFilterType.Equal) )
}
);
qObject.Fields.Add(SFieldValue);
qObject.Fields.Add(SFieldId);
qObject.Dictionary.Add(new QDictionary(SFieldId, SFieldValue, string.Format("SELECT MetaDictionaryId as Id, Value FROM MetaDictionary WHERE MetaFieldId = {0}", field.Id)));
break;
case MetaDataType.Image:
case MetaDataType.Binary:
// Ignory [12/8/2004]
break;
case MetaDataType.File:
case MetaDataType.ImageFile:
qObject.Fields.Add(new QField(string.Format("{1}", qObject.OwnerTable, field.Name),
field.FriendlyName,
"FileName",
DbType.String,
QFieldUsingType.Field | QFieldUsingType.Grouping,
new QFieldJoinRelation[]{
new QFieldJoinRelation(qObject.OwnerTable,currentClass.TableName,qObject.KeyField.DBName,"ObjectId"),
new QFieldJoinRelation(currentClass.TableName,"MetaFileValue",field.Name,"MetaKey")
}
));
break;
case MetaDataType.LongHtmlString:
case MetaDataType.LongString:
qObject.Fields.Add(new QField(string.Format("{1}", qObject.OwnerTable, field.Name),
field.FriendlyName,
field.Name,
MetaDataType2DbType(field.DataType),
QFieldUsingType.Field | QFieldUsingType.Grouping | QFieldUsingType.Sort,
new QFieldJoinRelation(qObject.OwnerTable, currentClass.TableName, qObject.KeyField.DBName, "ObjectId"))
);
break;
default:
qObject.Fields.Add(new QField(string.Format("{1}", qObject.OwnerTable, field.Name),
field.FriendlyName,
field.Name,
MetaDataType2DbType(field.DataType),
QFieldUsingType.Field | QFieldUsingType.Grouping | QFieldUsingType.Filter | QFieldUsingType.Sort,
new QFieldJoinRelation(qObject.OwnerTable, currentClass.TableName, qObject.KeyField.DBName, "ObjectId"))
);
break;
}
}
}
/// <summary>
/// Creates the specified name.
/// </summary>
/// <param name="Name">The name.</param>
/// <param name="FriendlyName">Name of the friendly.</param>
/// <param name="TableName">Name of the table.</param>
/// <param name="Parent">The parent.</param>
/// <param name="IsSystem">if set to <c>true</c> [is system].</param>
/// <param name="Description">The description.</param>
/// <returns></returns>
public static MetaClass Create(string name, string friendlyName, string tableName, MetaClass parent, bool isSystem, string description)
{
return MetaClass.Create(isSystem ? MetaNamespace.SystemRoot : MetaNamespace.UserRoot, name, friendlyName, tableName, parent == null ? 0 : parent.Id, isSystem ? MetaClassType.System : MetaClassType.User, description);
}
/// <summary>
/// Gets the list.
/// </summary>
/// <param name="metaClass">The meta class.</param>
/// <returns></returns>
internal static MetaFieldCollection GetList(MetaClass metaClass)
{
#region ArgumentNullExceptions
if (metaClass == null)
throw new ArgumentNullException("metaClass", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
#endregion
MetaFieldCollection retVal = new MetaFieldCollection();
using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaFieldListByMetaClassId"),
new SqlParameter("@MetaClassId", metaClass.Id)))
{
while (reader.Read())
{
MetaField newItem = MetaField.Load(metaClass, reader);
newItem.SetOwnerMetaClass(metaClass);
retVal.Add(newItem);
}
reader.Close();
}
return retVal;
}
/// <summary>
/// Creates the specified namespace.
/// </summary>
/// <param name="Namespace">The namespace.</param>
/// <param name="Name">The name.</param>
/// <param name="FriendlyName">Name of the friendly.</param>
/// <param name="TableName">Name of the table.</param>
/// <param name="Parent">The parent.</param>
/// <param name="type">The type.</param>
/// <param name="Description">The description.</param>
/// <returns></returns>
public static MetaClass Create(string metaNamespace, string name, string friendlyName, string tableName, MetaClass parent, MetaClassType type, string description)
{
return MetaClass.Create(metaNamespace, name, friendlyName, tableName, parent == null ? 0 : parent.Id, type, description);
}
/// <summary>
/// Loads the specified meta class.
/// </summary>
/// <param name="metaClass">The meta class.</param>
/// <param name="reader">The reader.</param>
/// <returns></returns>
protected static MetaField Load(MetaClass metaClass, SqlDataReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
MetaField retVal = new MetaField();
// Load MetaField Information [11/18/2004]
retVal._id = (int)reader["MetaFieldId"];
retVal._namespace = (string)reader["Namespace"];
retVal._name = (string)reader["Name"];
retVal._friendlyName = (string)reader["FriendlyName"];
if (reader["Description"] != DBNull.Value)
retVal._description = (string)reader["Description"];
retVal._dataType = (MetaDataType)reader["DataTypeId"];
retVal._length = (int)reader["Length"];
retVal._allowNulls = (bool)reader["AllowNulls"];
retVal._saveHistory = (bool)reader["SaveHistory"];
//retVal._multilanguageValue = (bool)reader["MultiLanguageValue"];
retVal._allowSearch = (bool)reader["AllowSearch"];
retVal._systemMetaClassId = (int)reader["SystemMetaClassId"];
retVal._tag = SqlHelper.DBNull2Null(reader["Tag"]);
return retVal;
}
/// <summary>
///
/// </summary>
/// <param name="field"></param>
/// <param name="cls"></param>
/// <returns></returns>
private static bool MetaFieldIsNotConnected(MetaField field, MetaClass cls)
{
return(cls != null && !cls.MetaFields.Contains(field));
}
private static bool MetaFieldIsNotConnected(MetaField field, MetaClass cls)
{
return cls != null && !cls.MetaFields.Contains(field);
}
public static void Delete(int objectId, MetaClass type)
{
MetaObject obj = MetaObject.Load(objectId, type);
if (obj != null)
{
obj.Delete();
obj.AcceptChanges();
}
}
/// <summary>
/// Creates the specified name.
/// </summary>
/// <param name="Name">The name.</param>
/// <param name="FriendlyName">Name of the friendly.</param>
/// <param name="TableName">Name of the table.</param>
/// <param name="Parent">The parent.</param>
/// <param name="type">The type.</param>
/// <param name="Description">The description.</param>
/// <returns></returns>
public static MetaClass Create(string name, string friendlyName, string tableName, MetaClass parent, MetaClassType type, string description)
{
return MetaClass.Create((type == MetaClassType.System) ? MetaNamespace.SystemRoot : MetaNamespace.UserRoot, name, friendlyName, tableName, parent == null ? 0 : parent.Id, type, description);
}
public static IDataReader GetHistoryDataReader(MetaClass metaClass, int metaObjectId)
{
if (metaClass == null)
throw new ArgumentNullException("metaClass");
return SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, string.Format(AsyncResources.GetConstantValue("SPAT_TABLE_History"), metaClass.TableName), new SqlParameter("@ObjectId", metaObjectId));
}
private void BindData(bool needToBind)
{
pageView = new PageView(false, PageViewType.Static, string.Empty, this.Page, MetaClassName);
mc = MetaClass.Load(MetaClassName);
if (ObjectId > 0)
obj = MetaDataWrapper.LoadMetaObject(ObjectId, MetaClassName);
if (obj == null)
obj = MetaDataWrapper.NewMetaObject(ObjectId, MetaClassName);
GenerateMainTable();
LoadControls(needToBind);
wasBound = true;
}
static MetaObject Load(MetaClass type, SqlDataReader reader)
{
MetaObject retVal = new MetaObject();
retVal._objectId = (int)reader["ObjectId"];
retVal._metaClass = type;
retVal.LoadMetaFields(reader);
return retVal;
}
