///-------------------------------------------------------------------------------------------------
/// <summary> An ISchemaElement extension method that adds an implicit constraint. </summary>
/// <typeparam name="T"> Generic type parameter. </typeparam>
/// <param name="metadata"> The metadata to act on. </param>
/// <param name="expression"> The expression. </param>
/// <param name="message"> The message. </param>
/// <param name="propertyName"> (Optional) name of the property. </param>
/// <returns> An ConstraintBuilder<T> </returns>
///-------------------------------------------------------------------------------------------------
public static ConstraintBuilder <T> AddImplicitConstraint <T>(this SchemaEntity <T> metadata, Func <T, bool> expression, DiagnosticMessage message, string propertyName = null) where T : IModelEntity
{
Contract.Requires(metadata, "metadata");
Contract.Requires(expression, "expression");
Contract.Requires(message, "message");
return(new ConstraintBuilder <T>(metadata, propertyName, expression, message, true));
}
public IEnumerable <PointPosition> Handle(SchemaEntity schema)
{
var now = _dateTimeProvider.GetToday();
var supposedDaysInGithubTable = SupposedWeeksCountInGithubTable * 7;
var supposedWeek = now.AddDays(-supposedDaysInGithubTable);
_logger.Info($"Supposed last week hidden in github table: {supposedWeek.ToShortDateString()}");
var startTableDay = FindNextDateByDayOfWeek(supposedWeek, DayOfWeek.Sunday);
_logger.Info($"Start table day: {startTableDay.ToShortDateString()}");
var pointsPositions = new List <PointPosition>();
var currentDay = startTableDay;
for (var weekIndex = 0; weekIndex < schema.Points.GetLength(1); weekIndex++)
{
for (var dayIndex = 0; dayIndex < 7; dayIndex++)
{
if (schema.Points[dayIndex, weekIndex] != PointType.empty)
{
var point = new PointPosition(weekIndex, dayIndex,
(Saturation)schema.Points[dayIndex, weekIndex] - 1, currentDay);
pointsPositions.Add(point);
}
currentDay = currentDay.AddDays(1);
}
}
return(pointsPositions);
}
public void AddSchemaEntity(SchemaEntity schemaEntity)
{
if (schemaEntity != null)
{
_schemaEntitiesTable.InsertOnSubmit(schemaEntity);
context.SubmitChanges();
}
}
public static SchemaVersion Parse(this SchemaEntity schemaEntity)
{
return(new SchemaVersion
{
MajorVersion = schemaEntity.MajorVersion,
MinorVersion = schemaEntity.MinorVersion,
ScriptVersion = schemaEntity.ScriptVersion
});
}
private void UpdateScriptsRan(List <SchemaVersion> results)
{
results.ForEach(result =>
{
var schemaEntity = new SchemaEntity {
ScriptName = Path.GetFileName(result.ScriptPath), MajorVersion = result.MajorVersion, MinorVersion = result.MinorVersion, ScriptVersion = result.ScriptVersion, ScriptRunDateTime = DateTime.Now
};
_schemaRepository.AddSchemaEntity(schemaEntity);
});
}
protected override void DefineSchema(ISchema schema)
{
ISchemaEntity customer = new SchemaEntity <Customer>(schema);
customer.DefineProperty <string>("Name");
ISchemaEntity product = new SchemaEntity <Product>(schema);
product.DefineProperty <string>("Name");
ISchemaRelationship rel = new SchemaRelationship("CustomerReferencesProducts", customer, product, Cardinality.ManyToMany);
}
public bool Equals(SchemaEntity other)
{
if (MajorVersion != other.MajorVersion)
{
return(false);
}
if (MinorVersion != other.MinorVersion)
{
return(false);
}
return(ScriptVersion == other.ScriptVersion);
}
private static SchemaEntity CreateEmptySchema()
{
var schema = new SchemaEntity();
for (var weekIndex = 0; weekIndex < schema.Points.GetLength(1); weekIndex++)
{
for (var dayIndex = 0; dayIndex < 7; dayIndex++)
{
schema.Points[dayIndex, weekIndex] = PointType.empty;
}
}
return(schema);
}
protected override void DefineSchema(ISchema metaModel)
{
NamedElement = new SchemaEntity(metaModel, "NamedElement");
Library = new SchemaEntity(metaModel, "Library", NamedElement);
Book = new SchemaEntity(metaModel, "Book");
Member = new SchemaEntity(metaModel, "Member", NamedElement);
Loan = new SchemaEntity(metaModel, "Loan");
LoanReferencesBook = new SchemaRelationship("LoanReferencesBook", Loan, Book, Cardinality.ManyToOne, false, null, "Book");
LibraryHasBooks = new SchemaRelationship("LibraryHasBooks", Library, Book, Cardinality.OneToMany, true, null, "Books");
LibraryHasMembers = new SchemaRelationship("LibraryHasMembers", Library, Member, Cardinality.OneToMany, true, null, "Members");
LibraryHasLoans = new SchemaRelationship("LibraryHasLoans", Library, Loan, Cardinality.OneToMany, true, null, "Loans");
LoanReferencesMember = new SchemaRelationship("LoanReferencesMember", Loan, Member, Cardinality.ManyToOne, false, null, "Member");
NamedElement.DefineProperty <string>("Name");
Book.DefineProperty <string>("Title");
Book.DefineProperty <int>("Copies");
}
public static SchemaField getFieldFromSchema(SchemaEntities entities, string entityName, string fieldName)
{
SchemaEntity entity = entities.entities.FirstOrDefault(e => e.name == entityName);
if (ReferenceEquals(entity, null))
{
return(null);
}
SchemaField field = entity.fields.FirstOrDefault(f => f.name == fieldName);
if (ReferenceEquals(field, null))
{
return(null);
}
return(field);
}
public static void setCheckEntitiesListItemByName(CheckedListBox cbxList, string[] selected)
{
List <SchemaEntity> se = cbxList.Items.Cast <SchemaEntity>().ToList();
foreach (string item in selected)
{
SchemaEntity current = se.FirstOrDefault(x => x.name == item);
if (!ReferenceEquals(current, null))
{
cbxList.SetItemChecked(cbxList.Items.IndexOf(current), true);
}
}
//foreach (object item in cbxList.Items)
//{
// PropertyInfo prop = item.GetType().GetProperty("name");
// if (ReferenceEquals(prop, null)) continue;
// if( prop.GetValue(item)
//}
}
bool IDtdParserAdapter.PopEntity(out SchemaEntity oldEntity, out int newEntityId)
{
return(reader.DtdParserProxy_PopEntity(out oldEntity, out newEntityId));
}
bool IDtdParserAdapter.PushEntity(SchemaEntity entity, int entityId)
{
return(reader.DtdParserProxy_PushEntity(entity, entityId));
}
