private MetadataDto CreateDefaultMetadataDto()
{
var metadataDto = new MetadataDto("Rem.Ria.PatientModule.Web.Common.PatientProfileDto");
var firstNameNode = metadataDto.AddChildMetadata("FirstName");
firstNameNode.AddMetadataItem(new DisplayNameMetadataItemDto {
Name = "The Patient's First Name"
});
firstNameNode.AddMetadataItem(new ReadonlyMetadataItemDto {
IsReadonly = true
});
var middleNameNode = metadataDto.AddChildMetadata("MiddleName");
middleNameNode.AddMetadataItem(new RequiredMetadataItemDto {
IsRequired = true
});
var lastNameNode = metadataDto.AddChildMetadata("LastName");
lastNameNode.AddMetadataItem(new DisplayNameMetadataItemDto {
Name = "Default LastName"
});
lastNameNode.AddMetadataItem(new HiddenMetadataItemDto {
IsHidden = true
});
return(metadataDto);
}
private void FullFwAssertValid(MetadataDto metadata)
{
metadata.Should().NotBeNull();
FullFwAssertValid(metadata.Service);
FullFwAssertValid(metadata.System);
}
public CardPaymentDetailsDto(CardPaymentDetails payment)
{
Cardholder = new CardholderDto(payment.Cardholder);
CreditCard = new CreditCardDto(payment.CreditCard);
Currency = payment.Currency.ToString();
Description = payment.Description;
GeneratePaymentToken = payment.GeneratePaymentToken;
GenerateRecurrenceToken = payment.GenerateRecurrenceToken;
Intent = payment.Intent.ToString();
Language = payment.Language.ToString();
Operation = payment.Operation.Value;
PayeeInfo = new PayeeInfoResponseDto(payment.PayeeInfo);
PayerReference = payment.PayerReference;
PaymentToken = payment.PaymentToken;
RiskIndicator = new RiskIndicatorDto(payment.RiskIndicator);
Urls = new UrlsDto(payment.Urls);
UserAgent = payment.UserAgent;
if (payment.Metadata != null)
{
Metadata = new MetadataDto(payment.Metadata);
}
Prices = new List <PriceDto>();
foreach (var item in payment.Prices)
{
Prices.Add(new PriceDto(item));
}
}
private void InitializeCustomizedMetadata()
{
// Case 1: _metadataProvider.MetadataDto is null
// Case 2: Child is not found
// Case 3: _metadataProvider.MetadataDto is changed
// Case 4: Child is replaced or removed
if (_customizedMetadata != null)
{
var customizedMetadataItemsCollection = _customizedMetadata.MetadataItemDtos as INotifyCollectionChanged;
customizedMetadataItemsCollection.CollectionChanged -= MetadataItemDtosCollectionChanged;
}
if (_metadataProvider.MetadataDto != null)
{
var metadataChildrenCollection = _metadataProvider.MetadataDto.Children as INotifyCollectionChanged;
metadataChildrenCollection.CollectionChanged -= MetadataChildrenCollectionChanged;
}
_customizedMetadata = null;
_customizedMetadata = GetMetadataForSelectedResource(_metadataProvider.MetadataDto);
if (_customizedMetadata != null)
{
var customizedMetadataItemsCollection = _customizedMetadata.MetadataItemDtos as INotifyCollectionChanged;
customizedMetadataItemsCollection.CollectionChanged += MetadataItemDtosCollectionChanged;
}
if (_metadataProvider.MetadataDto != null)
{
var metadataChildrenCollection = _metadataProvider.MetadataDto.Children as INotifyCollectionChanged;
metadataChildrenCollection.CollectionChanged += MetadataChildrenCollectionChanged;
}
}
public void MapToDto_ValidMetadata_Succeeds()
{
const string propertyWithMetadata = "PatientAddressType";
Mapper.CreateMap <PatientAddress, PatientAddressDtoTest> ();
Mapper.CreateMap <IMetadataItem, IMetadataItemDto>()
.Include <ReadonlyMetadataItem, ReadonlyMetadataItemDto>()
.Include <RequiredMetadataItem, RequiredMetadataItemDto>()
.Include <HiddenMetadataItem, HiddenMetadataItemDto>()
.Include <DisplayNameMetadataItem, DisplayNameMetadataItemDto>();
var metaDataRepository = new Mock <IMetadataRepository> ();
var metaDataRoot = new MetadataRoot(typeof(PatientAddress).FullName, 1);
metaDataRoot.AddChild(propertyWithMetadata);
metaDataRoot.Children[0].MetadataItems.Add(new DisplayNameMetadataItem());
metaDataRepository.Setup(m => m.GetMetadata(typeof(PatientAddress).FullName)).Returns(metaDataRoot);
var metadataMapper = new MetadataMapper(metaDataRepository.Object);
var metaDataDto = new MetadataDto(typeof(PatientAddressDtoTest).FullName);
metadataMapper.MapToDto(typeof(PatientAddress), typeof(PatientAddressDtoTest), metaDataDto);
Assert.AreEqual(1, metaDataDto.Children.Count);
Assert.AreEqual(1, metaDataDto.Children[0].MetadataItemDtos.Count);
Assert.AreEqual(typeof(DisplayNameMetadataItemDto), metaDataDto.Children[0].MetadataItemDtos[0].GetType());
}
/// <summary>
/// Handles the metadata item dto.
/// </summary>
/// <typeparam name="T">The type of metadataitemdto.</typeparam>
/// <param name="metadataDto">The metadata dto.</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="apply">If set to <c>true</c> [apply].</param>
/// <param name="metaDataItemToApply">The meta data item to apply.</param>
/// <returns>A <see cref="System.Boolean"/></returns>
private static bool HandleMetadataItemDto <T> (this MetadataDto metadataDto, string resourceName, bool apply, T metaDataItemToApply)
where T : IMetadataItemDto
{
var done = false;
var metaDataToApply = metadataDto;
if (metaDataToApply.ResourceName != resourceName)
{
metaDataToApply = metadataDto.GetChildMetadata(resourceName);
}
var exists = metaDataToApply.FindMetadataItem <T> () != null;
if (!apply && exists)
{
metaDataToApply.RemoveMetadataItem <T> ();
done = true;
}
if (apply && !exists)
{
metaDataToApply.AddMetadataItem(metaDataItemToApply);
done = true;
}
return(done);
}
private MetadataDto CreateMetadataDto <T> ()
{
var metadataDto = new MetadataDto(typeof(T).Name);
var completenessRuleCollections = _completenessRuleCollectionFactory.GetCompletnessRuleCollections <T> ();
completenessRuleCollections.ToList();
foreach (var completenessRuleCollection in completenessRuleCollections)
{
foreach (var ruleSet in completenessRuleCollection.RuleSets)
{
var ruleSetMetadataDto = metadataDto;
var firstRule = (IPropertyRule)ruleSet.First(r => r is IPropertyRule && !r.IsDisabled);
if (firstRule == null)
{
continue;
}
ruleSetMetadataDto = firstRule.PropertyChain.Take(firstRule.PropertyChain.Count - 1)
.Aggregate(ruleSetMetadataDto, (current, propertyPart) => current.GetChildMetadata(propertyPart));
foreach (IPropertyRule rule in ruleSet.Where(r => !r.IsDisabled))
{
var childMetadata = ruleSetMetadataDto.AddChildMetadata(rule.PropertyChain.Last());
childMetadata.AddMetadataItem(new RequiredForCompletenessMetadataItemDto(completenessRuleCollection.CompletenessCategory));
}
}
}
return(metadataDto);
}
/// <summary>
/// Metadatas the item exists.
/// </summary>
/// <typeparam name="TMetadataItem">The type of the metadata item.</typeparam>
/// <param name="metadataDto">The metadata dto.</param>
/// <param name="callback">The callback.</param>
/// <returns>Whether metadata item exists.</returns>
public static bool MetadataItemExists <TMetadataItem> (this MetadataDto metadataDto, Predicate <TMetadataItem> callback)
{
if (metadataDto.MetadataItemDtos != null)
{
return(metadataDto.MetadataItemDtos.Any((m => m.GetType() == typeof(TMetadataItem) && callback((TMetadataItem)m))));
}
return(false);
}
private void InitializeDefaultMetadata()
{
_defaultMetadata = GetMetadataForSelectedResource(_metadataService.GetMetadata(_metadataProvider.GetType()));
if (_defaultMetadata == null)
{
_defaultMetadata = new MetadataDto(string.Empty);
}
}
public Metadata(MetadataDto dto)
{
this.dto = dto;
Permissions = dto.Permissions.ToDictionary(
x => x.UserId,
x => x.Permission);
Path = dto.PathIds.Aggregate("", (current, next) => current + "/" + next);
}
public void MapToDto_NullDtoType_ThrowsArgumentException()
{
var metaDataRepository = new Mock <IMetadataRepository>();
var metadataMapper = new MetadataMapper(metaDataRepository.Object);
var metaDataDto = new MetadataDto(typeof(PatientAddressDtoTest).FullName);
metadataMapper.MapToDto(typeof(PatientAddress), null, metaDataDto);
}
/// <summary>
/// Maps Metadata to dto metadata.
/// </summary>
/// <param name="entityType">
/// Type of the entity.
/// </param>
/// <param name="dtoType">
/// Type of the dto.
/// </param>
/// <param name="dtoMetadata">
/// The dto metadata to map to.
/// </param>
public void MapToDto(Type entityType, Type dtoType, MetadataDto dtoMetadata)
{
Check.IsNotNull(entityType, "entityType is required.");
Check.IsNotNull(dtoType, "dtoType is required.");
Check.IsNotNull(dtoMetadata, "dtoMetadata is required.");
var metaData = _metadataRepository.GetMetadata(entityType.FullName);
if (metaData != null)
{
MapRecursive(metaData, entityType, dtoType, dtoMetadata);
}
}
public void CanSerialize_AndDeserialize_Metadata()
{
var metadata = new MetadataDto
{
{ "key1", 1000000000000 },
{ "key2", "test-string" }
};
var serialized = JsonSerializer.Serialize(metadata, JsonSerialization.JsonSerialization.Settings);
var result = JsonSerializer.Deserialize <MetadataDto>(serialized, JsonSerialization.JsonSerialization.Settings);
Assert.Equal(metadata["key2"], result["key2"]);
Assert.Equal(metadata["key1"], result["key1"]);
}
private MetadataDto GetMetadataForSelectedResource(MetadataDto metadataDto)
{
// Initially, assume that we are selecting the base metadata object
var metadataForSelectedResource = metadataDto;
// however, if the ChildMetaDataName property is set then it means we want
// a metadata child.
if (metadataDto != null && !string.IsNullOrWhiteSpace(_childMetadataName))
{
metadataForSelectedResource = metadataDto.Children.FirstOrDefault(m => m.ResourceName == _childMetadataName);
}
return(metadataForSelectedResource);
}
private MetadataDto CreateNewCustomizedMetadataDto()
{
var metadataDto = new MetadataDto("Rem.Ria.PatientModule.Web.Common.PatientProfileDto");
var lastNameNode = metadataDto.AddChildMetadata("LastName");
lastNameNode.AddMetadataItem(new RequiredMetadataItemDto {
IsRequired = true
});
lastNameNode.AddMetadataItem(new HiddenMetadataItemDto {
IsHidden = false
});
return(metadataDto);
}
public void MetadataDto_SetWithSameMetadataDto_NotFirePropertyChangedEvent()
{
bool isPropertyChangedEventFired = false;
var metadataDto = new MetadataDto("Default");
var personDto = new PersonDto {
FirstName = "John", LastName = "Wayne"
};
personDto.MetadataDto = metadataDto;
personDto.PropertyChanged += (sender, e) => { isPropertyChangedEventFired = true; };
personDto.MetadataDto = metadataDto;
Assert.IsFalse(isPropertyChangedEventFired);
}
public void MetadataDto_UsingDataContractSerializerToDeserialize_MetadataItemDtosHasValues()
{
var metadataDto = CreateMetadataDtoWithChildrenAndItems();
var knownTypes = new List <Type>
{
typeof(HiddenMetadataItemDto),
typeof(ReadonlyMetadataItemDto),
typeof(RequiredMetadataItemDto),
typeof(DisplayNameMetadataItemDto)
};
var text = ContractObjectToXml(metadataDto, knownTypes);
MetadataDto resultMetadataDto = XmlToContractObject <MetadataDto>(text, knownTypes);
Assert.AreEqual(2, resultMetadataDto.MetadataItemDtos.Count);
}
private void FullFwAssertValid(MetadataDto metadata)
{
metadata.Should().NotBeNull();
if (AgentConfig.GlobalLabels == null)
{
metadata.Labels.Should().BeNull();
}
else
{
metadata.Labels.Should().Equal(AgentConfig.GlobalLabels);
}
FullFwAssertValid(metadata.Service);
FullFwAssertValid(metadata.System);
}
public void MetadataDto_UsingDataContractSerializerToDeserialize_Succeed()
{
var metadataDto = CreateMetadataDtoWithChildrenAndItems();
var knownTypes = new List <Type>
{
typeof(HiddenMetadataItemDto),
typeof(ReadonlyMetadataItemDto),
typeof(RequiredMetadataItemDto),
typeof(DisplayNameMetadataItemDto)
};
var text = ContractObjectToXml(metadataDto, knownTypes);
MetadataDto resultMetadataDto = XmlToContractObject <MetadataDto> (text, knownTypes);
Assert.IsNotNull(resultMetadataDto);
}
public AddResult AddMetadata(MetadataDto metadataDto)
{
var isAlreadyMetadataWithThisName =
_uow.MetadataRepository.IsMetadataWithThisNameAdded(metadataDto.MetadataName);
if (!isAlreadyMetadataWithThisName)
{
var metadataEntity = BusinessMapper.Mapper.Map <Metadata>(metadataDto);
_uow.MetadataRepository.Add(metadataEntity);
var comp = _uow.Complete();
return(comp > 0 ? AddResult.Added : AddResult.UnknownError);
}
return(AddResult.DuplicateElement);
}
public AddResult EditMetadata(MetadataDto metadataDto)
{
var isAlreadyMetadataWithThisName =
_uow.MetadataRepository.IsMetadataWithThisNameAdded(metadataDto.MetadataName);
if (!isAlreadyMetadataWithThisName)
{
var metadataEntity = _uow.MetadataRepository.Get(metadataDto.MetadataId);
metadataEntity.Name = metadataDto.MetadataName;
var com = _uow.Complete();
return(com > 0 ? AddResult.Added : AddResult.UnknownError);
}
return(AddResult.DuplicateElement);
}
public CardPaymentVerifyRequestDetailsDto(CardPaymentVerifyRequestDetails payment)
{
Operation = payment.Operation.Value;
Intent = payment.Intent.ToString();
RecurrenceToken = payment.RecurrenceToken;
Currency = payment.Currency.ToString();
Amount = payment.Amount.InLowestMonetaryUnit;
VatAmount = payment.VatAmount.InLowestMonetaryUnit;
Description = payment.Description;
UserAgent = payment.UserAgent;
Language = payment.Language.ToString();
Urls = new UrlsDto(payment.Urls);
PayeeInfo = new PayeeInfoResponseDto(payment.PayeeInfo);
if (payment.Metadata != null)
{
Metadata = new MetadataDto(payment.Metadata);
}
}
private MetadataDto CreateMetadataDtoWithChildrenAndItems()
{
var metadataDto = new MetadataDto("Default");
metadataDto.AddMetadataItem(new ReadonlyMetadataItemDto {
IsReadonly = true
});
metadataDto.AddMetadataItem(new DisplayNameMetadataItemDto {
Name = "Test"
});
var child = metadataDto.AddChildMetadata("Child");
child.AddMetadataItem(new HiddenMetadataItemDto {
IsHidden = true
});
child.AddMetadataItem(new RequiredMetadataItemDto {
IsRequired = true
});
return(metadataDto);
}
public MainPageViewModel()
{
_metadataDto = new MetadataDto
{
DeviceType = "SimulatedTurbine"
};
InitializeTurbineModels();
_tickTimer = new DispatcherTimer {
Interval = TimeSpan.FromSeconds(1)
};
_tickTimer.Tick += TickTimerOnTick;
var tempId = ApplicationData.Current.LocalSettings.Values["StudentId"]?.ToString();
if (tempId != null)
{
StudentId = tempId;
}
}
public PaymentOrderRequestDetailsDto(PaymentOrderRequestDetails paymentOrder)
{
Amount = paymentOrder.Amount.InLowestMonetaryUnit;
Currency = paymentOrder.Currency.ToString();
Description = paymentOrder.Description;
GenerateRecurrenceToken = paymentOrder.GenerateRecurrenceToken;
Language = paymentOrder.Language.ToString();
Operation = paymentOrder.Operation.Value;
PayeeInfo = new PayeeInfoResponseDto(paymentOrder.PayeeInfo);
Payer = new PayerDto(paymentOrder.Payer);
RiskIndicator = new RiskIndicatorDto(paymentOrder.RiskIndicator);
Urls = new UrlsDto(paymentOrder.Urls);
UserAgent = paymentOrder.UserAgent;
VatAmount = paymentOrder.VatAmount.InLowestMonetaryUnit;
DisablePaymentMenu = paymentOrder.DisablePaymentMenu;
if (paymentOrder.Metadata != null)
{
Metadata = new MetadataDto(paymentOrder.Metadata);
}
if (paymentOrder.Items != null)
{
Items = new List <ItemDto>();
foreach (var item in paymentOrder.Items)
{
Items.Add(new ItemDto(item));
}
}
if (paymentOrder.OrderItems != null)
{
OrderItems = new List <OrderItemDto>();
foreach (var item in paymentOrder.OrderItems)
{
OrderItems.Add(new OrderItemDto(item));
}
}
}
public MobilePayPaymentDetailsDto(IMobilePayPaymentDetails payment)
{
Currency = payment.Currency.ToString();
Description = payment.Description;
Intent = payment.Intent.ToString();
Language = payment.Language.ToString();
Operation = payment.Operation.Value;
PayeeInfo = new PayeeInfoResponseDto(payment.PayeeInfo);
PayerReference = payment.PayerReference;
PrefillInfo = new PrefillInfoDto(payment.PrefillInfo);
Prices = new List <PriceDto>();
foreach (var item in payment.Prices)
{
Prices.Add(new PriceDto(item));
}
Urls = new UrlsDto(payment.Urls);
UserAgent = payment.UserAgent;
if (payment.Metadata != null)
{
Metadata = new MetadataDto(payment.Metadata);
}
}
private static IList <MetadataDto> MapMetadataList(IEnumerable <IMetadata> metadatas)
{
IList <MetadataDto> metadataDtos = new List <MetadataDto> ();
foreach (var metadata in metadatas)
{
var metadataDto = new MetadataDto(metadata.ResourceName);
metadataDtos.Add(metadataDto);
var items = MapMetadataItems(metadata.MetadataItems);
foreach (var metadataItemDto in items)
{
metadataDto.AddMetadataItem(metadataItemDto);
}
var children = MapMetadataList(metadata.Children);
foreach (var child in children)
{
metadataDto.AddChildMetadata(child);
}
}
return(metadataDtos);
}
private static void MapRecursive(IMetadata metadata, Type entityType, Type dtoType, MetadataDto dtoMetadata)
{
dtoMetadata.AddMetadataItemRange(MapMetadataItems(metadata.MetadataItems));
foreach (var propertyInfo in entityType.GetProperties())
{
if ((typeof(IAggregateRoot).IsAssignableFrom(propertyInfo.PropertyType) ||
typeof(IAggregateRoot).IsAssignableFrom(propertyInfo.PropertyType)) &&
metadata.HasChild(propertyInfo.PropertyType.FullName))
{
var dtoPropertyName = TryFindDestinationPropertyName(entityType, dtoType, propertyInfo);
if (dtoPropertyName == null)
{
continue;
}
var dtoPropertyInfo = dtoType.GetProperty(dtoPropertyName);
if (typeof(IDataTransferObject).IsAssignableFrom(dtoPropertyInfo.PropertyType))
{
MapRecursive(
metadata.FindChildMetadata(propertyInfo.PropertyType.FullName),
propertyInfo.PropertyType,
dtoPropertyInfo.PropertyType,
dtoMetadata.GetChildMetadata(dtoPropertyInfo.PropertyType.FullName));
}
else
{
var subDtoPropertyMetadata = dtoMetadata.GetChildMetadata(dtoPropertyInfo.Name);
var subPropertyMetadata = metadata.FindChildMetadata(propertyInfo.PropertyType.FullName);
subDtoPropertyMetadata.AddMetadataItemRange(
MapMetadataItems(subPropertyMetadata.MetadataItems));
}
}
else if (metadata.HasChild(propertyInfo.Name))
{
var dtoPropertyName = PropertyNameMapper.GetDistinctDestinationPropertyName(entityType, dtoType, propertyInfo.Name);
if (dtoPropertyName == null)
{
continue;
}
var subDtoPropertyMetadata = dtoMetadata.GetChildMetadata(dtoPropertyName);
var subPropertyMetadata = metadata.FindChildMetadata(propertyInfo.Name);
subDtoPropertyMetadata.AddMetadataItemRange(
MapMetadataItems(subPropertyMetadata.MetadataItems));
}
}
}
public MinimalDirectoryMetadata(MetadataDto dto, uint numberOfChilds) : base(dto)
{
NumberOfChilds = numberOfChilds;
}
public void OnDeserialization(StreamingContext context)
{
IsDirty = false;
MetadataDto = new MetadataDto(GetType().FullName);
}
/// <summary>
/// Adds the child metadata.
/// </summary>
/// <param name="metadataDto">The metadata dto.</param>
public void AddChildMetadata( MetadataDto metadataDto )
{
_children.Add ( metadataDto );
}
