/// <summary>
/// Write a Modified By node.
/// </summary>
/// <param name="writer">XML Writer</param>
/// <param name="name">Node name</param>
/// <param name="modifiedBy">Modified By</param>
private void WriteModifiedBy(XmlWriter writer, string name, ModifiedBy modifiedBy)
{
writer.WriteStartElement(name);
writer.WriteAttributeString(ConstXmlConfigHeader.XML_CONFIG_HEADER_MB_ATTR_USER, modifiedBy.User);
writer.WriteAttributeString(ConstXmlConfigHeader.XML_CONFIG_HEADER_MB_ATTR_TIME, modifiedBy.Timestamp.ToString());
writer.WriteEndElement();
}
public static ModifiedBy ModifiedBy()
{
ModifiedBy modifiedBy = new ModifiedBy();
modifiedBy.date = DateTime.Now;
modifiedBy.personId = Environment.UserName;
modifiedBy.programId = "SAM_gbXML";
return(modifiedBy);
}
public void IsSatisfiedBy_WhenModifiedByMatchesValue_ReturnsTrue()
{
var modifiedBy = _fixture.Create <int>();
var mockEntity = new Mock <IModifiedAudit>();
mockEntity.Setup(a => a.ModifiedBy).Returns(modifiedBy);
var specification = new ModifiedBy <IModifiedAudit>(modifiedBy);
var satisified = specification.IsSatisfiedBy(mockEntity.Object);
Assert.IsTrue(satisified);
}
/// <summary>
/// Add a record about modification of the entity
/// </summary>
public void AddHistoryRecord(UserReference actionedBy, string message)
{
ModifiedBy.Add(new BacklogItemHistoryRecord
{
ActionedBy = actionedBy,
Summary = message
});
// Cap the number of records in 200 most recent one. An arbitrary number to avoid the collection getting out of proportion
const int maxCount = 200;
if (ModifiedBy.Count > maxCount)
{
var lastTimestamp = ModifiedBy.OrderByDescending(m => m.Timestamp).Skip(maxCount - 1).First().Timestamp;
ModifiedBy.RemoveAll(m => m.Timestamp > lastTimestamp);
}
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (Name == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Name");
}
if (LanguagePair == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "LanguagePair");
}
if (Category == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Category");
}
if (Status == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Status");
}
if (CreatedBy == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "CreatedBy");
}
if (ModifiedBy == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "ModifiedBy");
}
if (ApiDomain == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "ApiDomain");
}
if (LanguagePair != null)
{
LanguagePair.Validate();
}
if (Category != null)
{
Category.Validate();
}
if (CreatedBy != null)
{
CreatedBy.Validate();
}
if (ModifiedBy != null)
{
ModifiedBy.Validate();
}
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (Name == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Name");
}
if (CreatedBy == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "CreatedBy");
}
if (ModifiedBy == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "ModifiedBy");
}
if (ModelStatus == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "ModelStatus");
}
if (Documents != null)
{
foreach (var element in Documents)
{
if (element != null)
{
element.Validate();
}
}
}
if (ModelRegionStatuses != null)
{
foreach (var element1 in ModelRegionStatuses)
{
if (element1 != null)
{
element1.Validate();
}
}
}
if (CreatedBy != null)
{
CreatedBy.Validate();
}
if (ModifiedBy != null)
{
ModifiedBy.Validate();
}
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (Name == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Name");
}
if (CreatedBy == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "CreatedBy");
}
if (ModifiedBy == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "ModifiedBy");
}
if (DocumentType == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "DocumentType");
}
if (CreatedBy != null)
{
CreatedBy.Validate();
}
if (ModifiedBy != null)
{
ModifiedBy.Validate();
}
if (Files != null)
{
foreach (var element in Files)
{
if (element != null)
{
element.Validate();
}
}
}
if (Languages != null)
{
foreach (var element1 in Languages)
{
if (element1 != null)
{
element1.Validate();
}
}
}
}
public void Save_NewFakeComplexEntity_MatchesExpected()
{
var subSubEntity = new SubSubEntity("SubSubUniqueName", 6445);
var subEntity = new SubEntity("SubUniqueName", 234, subSubEntity, 67893);
var createdBy = new CreatedBy("CreateUniqueName", 1122);
var modifiedBy = new ModifiedBy("ModifiedBy", 454);
var expected = new ComplexEntity("UniqueName", subEntity, FakeEnumeration.FirstFake, createdBy)
{
ModifiedBy = modifiedBy,
ModifiedTime = DateTimeOffset.Now.AddHours(1)
};
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.FirstOrDefault(It.IsAny <EntitySelection <ComplexRaisedRow> >()))
.Returns(default(ComplexRaisedRow));
repositoryProvider.Setup(provider => provider.Insert(It.IsAny <ComplexRaisedRow>()))
.Callback((ComplexRaisedRow row) => row.ComplexEntityId = 43)
.Returns((ComplexRaisedRow row) => row);
using (var provider = repositoryProvider.Object)
{
var target = new EntityRepository <ComplexEntity, ComplexRaisedRow>(provider, this.mapper);
var actual = target.Save(expected);
Assert.IsNotNull(actual.SubEntity);
Assert.IsNotNull(actual.SubEntity.SubSubEntity);
Assert.IsNotNull(actual.CreatedBy);
Assert.IsNotNull(actual.ModifiedBy);
Assert.AreEqual(6445, actual.SubSubEntity.FakeSubSubEntityId);
Assert.AreSame(expected.SubEntity.SubSubEntity, actual.SubEntity.SubSubEntity);
Assert.AreEqual(67893, actual.SubEntity.FakeSubEntityId);
Assert.AreEqual(expected.SubEntity, actual.SubEntity);
Assert.AreEqual(1122, actual.CreatedBy.FakeMultiReferenceEntityId);
Assert.AreEqual(expected.CreatedBy, actual.CreatedBy);
Assert.AreEqual(454, actual.ModifiedBy.FakeMultiReferenceEntityId);
Assert.AreEqual(expected.ModifiedBy, actual.ModifiedBy);
Assert.AreEqual(43, actual.ComplexEntityId);
Assert.AreEqual(expected, actual, string.Join(Environment.NewLine, expected.GetDifferences(actual)));
}
}
/// <summary>
/// Serialises all properties. The output will be a dictionary containing the
/// objects properties in a form that can easily be converted to Json.
/// </summary>
///
/// <returns>The serialised object in dictionary form.</returns>
public IDictionary <string, object> Serialise()
{
var dictionary = new Dictionary <string, object>();
// Object Id
dictionary.Add("ObjectID", ObjectId);
// Created By
if (CreatedBy != null)
{
dictionary.Add("CreatedBy", CreatedBy.Serialise());
}
// Date Created
dictionary.Add("DateCreated", JsonSerialisation.Serialise(DateCreated));
// Modified By
if (ModifiedBy != null)
{
dictionary.Add("ModifiedBy", ModifiedBy.Serialise());
}
// Date Modified
if (DateModified.HasValue)
{
dictionary.Add("DateModified", JsonSerialisation.Serialise(DateModified.Value));
}
// Value
dictionary.Add("Value", Value.Serialise());
// Write Lock
if (WriteLock != null)
{
dictionary.Add("WriteLock", WriteLock);
}
return(dictionary);
}
public virtual string ToLog()
{
StringBuilder builder = new StringBuilder();
builder.Append("[");
//From Rule
builder.Append("ID:");
builder.Append(ID);
builder.Append(", ");
builder.Append("Description:");
builder.Append(Description.ToLog());
builder.Append(", ");
builder.Append("Version");
builder.Append(Version);
builder.Append(", ");
builder.Append("CreatedDate:");
builder.Append(CreatedDate);
builder.Append(", ");
builder.Append("ModifiedDate:");
builder.Append(ModifiedDate);
builder.Append(", ");
builder.Append("ModifiedBy:");
builder.Append(ModifiedBy.ToString());
builder.Append(", ");
//From IsoScriptRule
builder.Append("Script:");
builder.Append(Script);
builder.Append("]");
return(builder.ToString());
}
/// <summary>
/// Parse a modification info node.
/// </summary>
/// <param name="elem">XML Element</param>
/// <returns>Modification info</returns>
private ModifiedBy ParseModifiedBy(XmlElement elem)
{
if (elem.HasAttributes)
{
ModifiedBy mb = new ModifiedBy();
XmlAttribute attr = elem.Attributes[ConstXmlConfigHeader.XML_CONFIG_HEADER_MB_ATTR_USER];
if (attr != null)
{
mb.User = attr.Value;
}
attr = elem.Attributes[ConstXmlConfigHeader.XML_CONFIG_HEADER_MB_ATTR_TIME];
if (attr != null)
{
string ts = attr.Value;
if (!String.IsNullOrWhiteSpace(ts))
{
mb.Timestamp = Int64.Parse(ts);
}
}
return(mb);
}
return(null);
}
public void Save_UpdatedFakeComplexEntity_MatchesExpected()
{
var subSubEntity = new SubSubEntity("SubSubUniqueName", 45)
{
Description = "OriginalSubSub"
};
var subEntity = new SubEntity("SubUniqueName", 234, subSubEntity, 16)
{
Description = "OriginalSub"
};
var createdBy = new CreatedBy("CreateUniqueName", 432)
{
Description = "OriginalCreatedBy"
};
var modifiedBy = new ModifiedBy("ModifiedBy", 433)
{
Description = "OriginalModifiedBy"
};
var creationTime = DateTimeOffset.Now.AddDays(-1);
var baseline = new ComplexEntity("UniqueName", subEntity, FakeEnumeration.FirstFake, createdBy, creationTime, 22)
{
Description = "OriginalComplexEntity",
ModifiedBy = modifiedBy,
ModifiedTime = DateTimeOffset.Now.AddHours(1)
};
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.FirstOrDefault(It.IsAny <EntitySet <ComplexRaisedRow> >()))
.Returns(this.mapper.Map <ComplexRaisedRow>(baseline));
repositoryProvider.Setup(
provider => provider.Contains(It.Is <IEntitySet>(selection => (int?)selection.PropertyValues.FirstOrDefault() == 22)))
.Returns(true);
repositoryProvider.Setup(provider => provider.Update(It.IsAny <UpdateSet <ComplexRaisedRow> >())).Returns(1);
using (var provider = repositoryProvider.Object)
{
var newModifiedBy = new ModifiedBy("ModifiedBy", 433)
{
Description = "UpdatedModifiedBy"
};
var target = new EntityRepository <ComplexEntity, ComplexRaisedRow>(provider, this.mapper);
var expected = target.FirstOrDefault(22);
expected.Description = "UpdatedEntity";
expected.ModifiedBy = newModifiedBy;
expected.ModifiedTime = DateTimeOffset.Now.AddHours(1);
expected.SubEntity.Description = "ModifiedSub";
expected.SubSubEntity.Description = "ModifiedSubSub";
var actual = target.Save(expected);
Assert.IsNotNull(actual.SubEntity);
Assert.IsNotNull(actual.SubEntity.SubSubEntity);
Assert.IsNotNull(actual.CreatedBy);
Assert.IsNotNull(actual.ModifiedBy);
Assert.AreEqual(16, actual.SubEntity.FakeSubEntityId);
Assert.AreEqual(expected.SubEntity, actual.SubEntity);
Assert.AreEqual(45, actual.SubSubEntity.FakeSubSubEntityId);
Assert.AreEqual(expected.SubEntity.SubSubEntity, actual.SubEntity.SubSubEntity);
Assert.AreEqual(432, actual.CreatedBy.FakeMultiReferenceEntityId);
Assert.AreEqual(
baseline.CreatedBy,
actual.CreatedBy,
string.Join(Environment.NewLine, baseline.CreatedBy.GetDifferences(actual.CreatedBy)));
Assert.AreEqual(creationTime, actual.CreationTime);
Assert.AreEqual(433, actual.ModifiedBy.FakeMultiReferenceEntityId);
Assert.AreEqual(expected.ModifiedBy, actual.ModifiedBy);
Assert.AreEqual(expected.ModifiedTime, actual.ModifiedTime);
Assert.AreEqual(22, actual.ComplexEntityId);
Assert.AreEqual(expected, actual, string.Join(Environment.NewLine, expected.GetDifferences(actual)));
}
}
/// <summary>
/// Parse the configuration header information.
/// </summary>
/// <param name="name">Configuration name</param>
/// <param name="version">Expected configuration version</param>
/// <param name="elem">Header XML element</param>
private void ParseHeader(string name, Version version, XmlElement elem, string passwrod)
{
if (elem.HasAttributes)
{
ConfigurationHeader header = new ConfigurationHeader();
string attr = elem.GetAttribute(ConstXmlConfigHeader.XML_CONFIG_HEADER_ATTR_GROUP);
if (!String.IsNullOrWhiteSpace(attr))
{
header.ApplicationGroup = attr;
}
attr = elem.GetAttribute(ConstXmlConfigHeader.XML_CONFIG_HEADER_ATTR_ID);
if (!String.IsNullOrWhiteSpace(attr))
{
header.Id = attr;
}
attr = elem.GetAttribute(ConstXmlConfigHeader.XML_CONFIG_HEADER_ATTR_APP);
if (!String.IsNullOrWhiteSpace(attr))
{
header.Application = attr;
}
attr = elem.GetAttribute(ConstXmlConfigHeader.XML_CONFIG_HEADER_ATTR_NAME);
if (!String.IsNullOrWhiteSpace(attr))
{
header.Name = attr;
}
attr = elem.GetAttribute(ConstXmlConfigHeader.XML_CONFIG_HEADER_ATTR_VERSION);
if (!String.IsNullOrWhiteSpace(attr))
{
Version ver = Version.Parse(attr);
if (!ver.Equals(version))
{
throw new ConfigurationException(String.Format("Configuration Version mis-match: [expected={0}][actual={1}]", version.ToString(), ver.ToString()));
}
header.Version = ver;
}
if (name != header.Name)
{
throw new ConfigurationException(String.Format("Invalid Configuration: Name mis-match. [expected={0}][actual={1}]", name, header.Name));
}
attr = elem.GetAttribute(ConstXmlConfigHeader.XML_CONFIG_HEADER_ATTR_HASH);
if (!String.IsNullOrWhiteSpace(attr))
{
header.EncryptionHash = attr;
if (String.IsNullOrWhiteSpace(passwrod))
{
throw new ConfigurationException(String.Format("Configuration has encryption, but no password specified. [name={0}]", header.Name));
}
if (!CryptoUtils.CompareHash(header.EncryptionHash, passwrod))
{
throw new ConfigurationException(String.Format("Password doesn't match the hash specified in the configuration. [name={0}]", header.Name));
}
}
if (elem.HasChildNodes)
{
foreach (XmlNode node in elem.ChildNodes)
{
if (node.NodeType == XmlNodeType.Element)
{
if (node.Name == ConstXmlConfigHeader.XML_CONFIG_HEADER_CREATED_BY)
{
ModifiedBy mb = ParseModifiedBy((XmlElement)node);
if (mb != null)
{
header.CreatedBy = mb;
}
}
else if (node.Name == ConstXmlConfigHeader.XML_CONFIG_HEADER_UPDATED_BY)
{
ModifiedBy mb = ParseModifiedBy((XmlElement)node);
if (mb != null)
{
header.ModifiedBy = mb;
}
}
else if (IsTextNode((XmlElement)node))
{
if (node.Name == ConstXmlConfigHeader.XML_CONFIG_HEADER_DESC)
{
header.Description = node.InnerText;
}
}
}
}
}
header.Timestamp = DateTime.Now.Ticks;
LogUtils.Debug(String.Format("Loaded Header: [name={0}]", header.Name), header);
configuration.Header = header;
}
else
{
throw new ConfigurationException(String.Format("Error loading configuration header: No attributes defined. [name={0}]", name));
}
}
public bool isModified()
{
return(!ModifiedBy.Equals(CreatedBy) && !CreatedOn.Equals(ModifiedOn));
}
