public static Size MeasureReportItem(Graphics graphics, IReportItem item)
{
BaseTextItem textItem = item as BaseTextItem;
if (textItem != null)
{
string str = String.Empty;
BaseDataItem dataItem = item as BaseDataItem;
if (dataItem != null)
{
str = dataItem.DBValue;
}
else
{
BaseTextItem it = item as BaseTextItem;
if (it != null)
{
str = it.Text;
}
}
SizeF sf = graphics.MeasureString(str.TrimEnd(),
textItem.Font,
textItem.Size.Width);
return(sf.ToSize());
}
return(item.Size);
}
public void ExportColumnIsNotNull()
{
BaseDataItem bt = new BaseDataItem();
var bec = bt.CreateExportColumn();
Assert.IsNotNull(bec);
}
public void DefaultSettings()
{
BaseDataItem bdi = new BaseDataItem();
Assert.AreEqual("System.String", bdi.DataType);
Assert.IsTrue(String.IsNullOrEmpty(bdi.BaseTableName));
}
public void NullValue_In_Property_Should_Return_EmptyString()
{
ContributorsList contributorsList = new ContributorsList();
var contColl = contributorsList.ContributorCollection;
foreach (Contributor element in contColl)
{
element.GroupItem = null;
}
IDataManager dm = ICSharpCode.Reports.Core.DataManager.CreateInstance(contColl, new ReportSettings());
IDataNavigator dataNav = dm.GetNavigator;
ReportItemCollection searchCol = new ReportItemCollection();
searchCol.Add(new BaseDataItem()
{
Name = "GroupItem",
ColumnName = "GroupItem"
}
);
dataNav.Reset();
dataNav.MoveNext();
do
{
dataNav.Fill(searchCol);
BaseDataItem resultItem = searchCol[0] as BaseDataItem;
Assert.That(resultItem.Name, Is.EqualTo("GroupItem"));
Assert.That(resultItem.DBValue, Is.EqualTo(String.Empty));
}while (dataNav.MoveNext());
}
public void GetSetTableName()
{
BaseDataItem bdi = new BaseDataItem();
bdi.BaseTableName = "MyTable";
Assert.AreEqual("MyTable", bdi.BaseTableName, "ColumnName should be eqaul <MyTable>");
}
public void GetSetDataType()
{
BaseDataItem bdi = new BaseDataItem();
bdi.DataType = "System.String";
Assert.AreEqual("System.String", bdi.DataType, "DataType should be <System.String>");
}
public void GetSetTableName ()
{
BaseDataItem bdi = new BaseDataItem();
bdi.BaseTableName = "MyTable";
Assert.AreEqual("MyTable",bdi.BaseTableName,"ColumnName should be eqaul <MyTable>");
}
public void GetSetDBValue()
{
BaseDataItem bdi = new BaseDataItem();
bdi.DBValue = "DBValue";
Assert.AreEqual("DBValue", bdi.DBValue, "DataType should be <DBValue>");
}
public override int SaveChanges()
{
IEnumerable <ObjectStateEntry> objectStateEntries;
ObjectContext context = ((IObjectContextAdapter)this).ObjectContext;
//Find all Entities that are Added/Modified that inherit from BaseDataItem
objectStateEntries =
from item in context.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified)
where (item.IsRelationship == false) &&
(item.Entity != null) &&
(typeof(BaseDataItem).IsAssignableFrom(item.Entity.GetType()))
select item;
DateTime currentTime = DateTime.Now;
foreach (ObjectStateEntry entry in objectStateEntries)
{
BaseDataItem entityBase = entry.Entity as BaseDataItem;
if (entry.State == EntityState.Added)
{
entityBase.CreatedDate = currentTime;
}
entityBase.ModifiedDate = currentTime;
}
return(base.SaveChanges());
}
public void DataItemWithNoColumnNameHasErrorMessageInDbValue()
{
var baseRow = new BaseRowItem();
var dataItem = new BaseDataItem()
{
};
baseRow.Items.Add(dataItem);
var row = new System.Collections.Generic.List <IPrintableObject>();
row.Add(baseRow);
var reportSettings = new ReportSettings();
var collectionSource = new CollectionDataSource(list, reportSettings);
collectionSource.Bind();
foreach (var element in collectionSource.SortedList)
{
collectionSource.Fill(row, element);
var r = (BaseRowItem)row[0];
foreach (var result in r.Items)
{
Assert.That(((BaseDataItem)result).DBValue.StartsWith("Missing"), Is.EqualTo(true));
}
}
}
public void GetSetNullValue()
{
BaseDataItem bdi = new BaseDataItem();
bdi.NullValue = "NullValue";
Assert.AreEqual("NullValue", bdi.NullValue, "DataType should be <NullValue>");
}
public void GetSetColumnName()
{
BaseDataItem bdi = new BaseDataItem();
bdi.ColumnName = "MyColumn";
Assert.AreEqual("MyColumn", bdi.ColumnName, "ColumnName should be eqaul <MyColumn>");
}
public void DefaultSettings()
{
BaseDataItem bdi = new BaseDataItem();
Assert.AreEqual("System.String",bdi.DataType);
Assert.AreEqual(GlobalValues.UnboundName,bdi.ColumnName);
Assert.IsTrue(String.IsNullOrEmpty(bdi.BaseTableName));
Assert.AreEqual("." + GlobalValues.UnboundName,bdi.MappingName);
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
base.PopulateFromDataItemOverride(dataItem);
BaseDataItemWithImages i = dataItem as BaseDataItemWithImages;
ImageNames = i.ImageNames;
}
public void PopulateFromDataItem(BaseDataItem dataItem)
{
if (HasData)
{
DataItem = dataItem;
PopulateFromDataItemOverride(dataItem);
}
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
base.PopulateFromDataItemOverride(dataItem);
DataItemMegaItem i = dataItem as DataItemMegaItem;
PercentComplete = i.PercentComplete;
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
base.PopulateFromDataItemOverride(dataItem);
BaseDataItemWithDetails i = dataItem as BaseDataItemWithDetails;
Details = i.Details;
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
base.PopulateFromDataItemOverride(dataItem);
BaseDataItemWithName i = dataItem as BaseDataItemWithName;
Name = i.Name;
}
public void GetSetMappingName()
{
BaseDataItem bdi = new BaseDataItem();
bdi.BaseTableName = "MyTable";
bdi.ColumnName = "MyColumn";
Assert.AreEqual("MyTable" + "." + "MyColumn", bdi.MappingName, "ColumnName should be eqaul <MyTable.MyColumn>");
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
var megaItem = dataItem as DataItemMegaItem;
EndTime = DateTime.SpecifyKind(megaItem.EndTime, DateTimeKind.Local);
base.PopulateFromDataItemOverride(dataItem);
}
public void TypeofExportShouldBeExportText()
{
BaseTextItem bt = new BaseDataItem();
var bec = bt.CreateExportColumn();
Type t = typeof(ExportText);
Assert.AreEqual(t, bec.GetType(), "Type should be 'ExportText");
}
public void GetSetMappingName ()
{
BaseDataItem bdi = new BaseDataItem();
bdi.BaseTableName = "MyTable";
bdi.ColumnName = "MyColumn";
Assert.AreEqual("MyTable" +"." + "MyColumn",bdi.MappingName,"ColumnName should be eqaul <MyTable.MyColumn>");
}
public void ConstructurWithColumnName()
{
BaseDataItem bdi = new BaseDataItem("TestColumn");
Assert.IsNotNull(bdi);
Assert.AreEqual("System.String",bdi.DataType);
Assert.AreEqual("TestColumn",bdi.ColumnName);
Assert.IsTrue(String.IsNullOrEmpty(bdi.BaseTableName));
Assert.AreEqual("." + "TestColumn",bdi.MappingName);
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
var megaItem = dataItem as DataItemMegaItem;
// We don't localize holidays since they're just raw dates
EndTime = DateTime.SpecifyKind(megaItem.EndTime, DateTimeKind.Local);
base.PopulateFromDataItemOverride(dataItem);
}
public void DefaultSettings()
{
BaseDataItem bdi = new BaseDataItem();
Assert.AreEqual("System.String", bdi.DataType);
Assert.AreEqual(GlobalValues.UnboundName, bdi.ColumnName);
Assert.IsTrue(String.IsNullOrEmpty(bdi.BaseTableName));
Assert.AreEqual("." + GlobalValues.UnboundName, bdi.MappingName);
}
public override int CompareTo(BaseDataItem other)
{
if (other is DataItemClass)
{
return(CompareTo(other as DataItemClass));
}
return(base.CompareTo(other));
}
public void TextValueEqualExportedText()
{
BaseDataItem bt = new BaseDataItem();
bt.Text = "Text";
ExportText bec = (ExportText)bt.CreateExportColumn();
bec.Text = bt.Text;
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
base.PopulateFromDataItemOverride(dataItem);
BaseDataItemWithOverriddenGPACredits i = dataItem as BaseDataItemWithOverriddenGPACredits;
OverriddenGPA = i.OverriddenGPA;
OverriddenCredits = i.OverriddenCredits;
}
public void ConstructurWithColumnName()
{
BaseDataItem bdi = new BaseDataItem("TestColumn");
Assert.IsNotNull(bdi);
Assert.AreEqual("System.String", bdi.DataType);
Assert.AreEqual("TestColumn", bdi.ColumnName);
Assert.IsTrue(String.IsNullOrEmpty(bdi.BaseTableName));
Assert.AreEqual("." + "TestColumn", bdi.MappingName);
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
base.PopulateFromDataItemOverride(dataItem);
DataItemWeightCategory i = dataItem as DataItemWeightCategory;
WeightValue = i.WeightValue;
NeedsRecalc = true;
}
object ExtractDBValue(DataRow row, BaseDataItem item)
{
if (EvaluationHelper.CanEvaluate(item.Expression))
{
return(ExtractFromExpression(item.Expression, row));
}
else
{
return(DBValueFromRow(row, item.ColumnName));
}
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
base.PopulateFromDataItemOverride(dataItem);
BaseDataItemHomeworkExamGrade i = dataItem as BaseDataItemHomeworkExamGrade;
Date = DateTime.SpecifyKind(i.Date, DateTimeKind.Local);
GradeReceived = i.GradeReceived;
GradeTotal = i.GradeTotal;
IsDropped = i.IsDropped;
IndividualWeight = i.IndividualWeight;
}
protected override void PopulateFromDataItemOverride(BaseDataItem dataItem)
{
base.PopulateFromDataItemOverride(dataItem);
DataItemSchedule schedule = (DataItemSchedule)dataItem;
DayOfWeek = schedule.DayOfWeek;
StartTime = DateTime.SpecifyKind(schedule.StartTime, DateTimeKind.Local);
EndTime = DateTime.SpecifyKind(schedule.EndTime, DateTimeKind.Local);
Room = schedule.Room;
ScheduleWeek = schedule.ScheduleWeek;
}
public BaseViewItem(BaseDataItem dataItem)
{
if (dataItem != null)
{
DataItem = dataItem;
Identifier = dataItem.Identifier;
DateCreated = dataItem.DateCreated;
PopulateFromDataItemOverride(dataItem);
}
}
public void TextValueEqualExportedText ()
{
BaseDataItem bt = new BaseDataItem();
bt.Text = "Text";
ExportText bec = (ExportText)bt.CreateExportColumn();
bec.Text = bt.Text;
}
public void ToStringOverride ()
{
BaseDataItem bdi = new BaseDataItem("TestColumn");
Assert.AreEqual ("BaseDataItem",bdi.ToString(),"ToString override");
}
public void GetSetNullValue ()
{
BaseDataItem bdi = new BaseDataItem();
bdi.NullValue ="NullValue";
Assert.AreEqual("NullValue",bdi.NullValue,"DataType should be <NullValue>");
}
public void GetSetDBValue ()
{
BaseDataItem bdi = new BaseDataItem();
bdi.DBValue ="DBValue";
Assert.AreEqual("DBValue",bdi.DBValue,"DataType should be <DBValue>");
}
public void GetSetDataType ()
{
BaseDataItem bdi = new BaseDataItem();
bdi.DataType ="System.String";
Assert.AreEqual("System.String",bdi.DataType,"DataType should be <System.String>");
}
public void GetSetColumnName ()
{
BaseDataItem bdi = new BaseDataItem();
bdi.ColumnName = "MyColumn";
Assert.AreEqual("MyColumn",bdi.ColumnName,"ColumnName should be eqaul <MyColumn>");
}
object ExtractDBValue(DataRow row,BaseDataItem item)
{
if (EvaluationHelper.CanEvaluate(item.Expression)) {
return ExtractFromExpression(item.Expression, row);
}
else
{
return DBValueFromRow(row, item.ColumnName);
}
}
public void DefaultSettings()
{
BaseDataItem bdi = new BaseDataItem();
Assert.AreEqual("System.String",bdi.DataType);
Assert.IsTrue(String.IsNullOrEmpty(bdi.BaseTableName));
}
public void DefaultConstructur()
{
BaseDataItem bdi = new BaseDataItem();
Assert.IsNotNull(bdi);
}
public void ExportColumnIsNotNull ()
{
BaseDataItem bt = new BaseDataItem();
var bec = bt.CreateExportColumn();
Assert.IsNotNull(bec);
}
public void TypeofExportShouldBeExportText ()
{
BaseTextItem bt = new BaseDataItem();
var bec = bt.CreateExportColumn();
Type t = typeof(ExportText);
Assert.AreEqual(t,bec.GetType(),"Type should be 'ExportText");
}
