// TODO: TEST date paid being set / nullified (integration -- cannot accomplish via unit).
public void ChangeMedicalVendorInvoicePaymentStatus(long medicalVendorInvoiceId, PaymentStatus paymentStatus, DateTime datePaid)
{
if (paymentStatus != PaymentStatus.Paid && paymentStatus != PaymentStatus.Unpaid)
{
throw new ArgumentOutOfRangeException("paymentStatus", string.Format("PaymentStatus {0} is invalid.", paymentStatus));
}
DateTime?newDatePaid;
switch (paymentStatus)
{
case PaymentStatus.Paid:
newDatePaid = datePaid;
break;
case PaymentStatus.Unpaid:
newDatePaid = null;
break;
default:
throw new ArgumentOutOfRangeException("paymentStatus", string.Format("PaymentStatus {0} is invalid.", paymentStatus));
}
var medicalVendorInvoiceEntity = new PhysicianInvoiceEntity(medicalVendorInvoiceId)
{
PaymentStatus = (byte)paymentStatus, DatePaid = newDatePaid
};
var bucket = new RelationPredicateBucket(PhysicianInvoiceFields.PhysicianInvoiceId == medicalVendorInvoiceId);
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
// TODO: What if no entities are updated due to a persistence error?
myAdapter.UpdateEntitiesDirectly(medicalVendorInvoiceEntity, bucket);
}
}
// TODO: TEST Set / nullify ApprovalDate (integration -- cannot accomplish via unit).
public void ChangeMedicalVendorInvoiceApprovalStatus(long medicalVendorInvoiceId, ApprovalStatus approvalStatus)
{
DateTime?approvalDate;
switch (approvalStatus)
{
case ApprovalStatus.Approved:
approvalDate = DateTime.Now;
break;
case ApprovalStatus.Unapproved:
approvalDate = null;
break;
default:
throw new ArgumentOutOfRangeException("approvalStatus", string.Format("ApprovalStatus {0} is invalid.", approvalStatus));
}
var medicalVendorInvoiceEntity = new PhysicianInvoiceEntity(medicalVendorInvoiceId)
{
ApprovalStatus = (byte)approvalStatus, DateApproved = approvalDate
};
var bucket = new RelationPredicateBucket(PhysicianInvoiceFields.PhysicianInvoiceId == medicalVendorInvoiceId);
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
// TODO: What if no entities are updated due to a persistence error?
myAdapter.UpdateEntitiesDirectly(medicalVendorInvoiceEntity, bucket);
}
}
public PhysicianInvoice CreateMedicalVendorInvoice(PhysicianInvoiceEntity medicalVendorInvoiceEntity,
EntityCollection <PhysicianInvoiceItemEntity> medicalVendorInvoiceItemEntities)
{
List <MedicalVendorInvoiceItem> medicalVendorInvoiceItems = _medicalVendorInvoiceItemFactory.
CreateMedicalVendorInvoiceItems(medicalVendorInvoiceItemEntities);
return(CreateMedicalVendorInvoice(medicalVendorInvoiceEntity, medicalVendorInvoiceItems));
}
/// <summary> setups the sync logic for member _physicianInvoice</summary>
/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
private void SetupSyncPhysicianInvoice(IEntity2 relatedEntity)
{
if (_physicianInvoice != relatedEntity)
{
DesetupSyncPhysicianInvoice(true, true);
_physicianInvoice = (PhysicianInvoiceEntity)relatedEntity;
base.PerformSetupSyncRelatedEntity(_physicianInvoice, new PropertyChangedEventHandler(OnPhysicianInvoicePropertyChanged), "PhysicianInvoice", PhysicianPaymentInvoiceEntity.Relations.PhysicianInvoiceEntityUsingPhysicianInvoiceId, true, new string[] { });
}
}
/// <summary> Initializes the class members</summary>
protected virtual void InitClassMembers()
{
_physicianInvoice = null;
_physicianPayment = null;
PerformDependencyInjection();
// __LLBLGENPRO_USER_CODE_REGION_START InitClassMembers
// __LLBLGENPRO_USER_CODE_REGION_END
OnInitClassMembersComplete();
}
public void CreateMedicalVendorInvoiceEntitySetsOrganizationRoleUserNameToPhysicianName()
{
var medicalVendorInvoice = new PhysicianInvoice {
PhysicianName = "Bobby"
};
_mocks.ReplayAll();
PhysicianInvoiceEntity medicalVendorInvoiceEntity = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoiceEntity(medicalVendorInvoice);
_mocks.VerifyAll();
Assert.AreEqual(medicalVendorInvoice.PhysicianName, medicalVendorInvoiceEntity.PhysicianName);
}
public void CreateMedicalVendorInvoiceEntitySetsDatePaidToDomainDatePaidProperty()
{
var expectedDatePaid = new DateTime(2004, 2, 1);
_mocks.ReplayAll();
PhysicianInvoiceEntity medicalVendorInvoiceEntity = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoiceEntity(new PhysicianInvoice {
DatePaid = expectedDatePaid
});
_mocks.VerifyAll();
Assert.AreEqual(expectedDatePaid, medicalVendorInvoiceEntity.DatePaid);
}
public PhysicianInvoice GetMedicalVendorInvoice(long medicalVendorInvoiceId)
{
var medicalVendorInvoiceEntity = new PhysicianInvoiceEntity(medicalVendorInvoiceId);
var medicalVendorInvoiceItemEntites = new EntityCollection <PhysicianInvoiceItemEntity>();
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
if (!myAdapter.FetchEntity(medicalVendorInvoiceEntity))
{
throw new ObjectNotFoundInPersistenceException <PhysicianInvoice>(medicalVendorInvoiceEntity.PhysicianInvoiceId);
}
var medicalVendorInvoiceItemBucket = new RelationPredicateBucket
(PhysicianInvoiceItemFields.PhysicianInvoiceId == medicalVendorInvoiceEntity.PhysicianInvoiceId);
myAdapter.FetchEntityCollection(medicalVendorInvoiceItemEntites, medicalVendorInvoiceItemBucket);
}
return(_medicalVendorInvoiceFactory.CreateMedicalVendorInvoice(medicalVendorInvoiceEntity, medicalVendorInvoiceItemEntites));
}
public void CreateMedicalVendorInvoiceStatisticSetsDataRowFieldsToStatisticFieldsCorrectly()
{
const long medicalVendorInvoiceId = 25;
const decimal invoiceAmount = 25.33m;
const int numberOfEvaluations = 43;
var medicalVendorInvoiceEntity = new PhysicianInvoiceEntity(medicalVendorInvoiceId);
AddRowToDataTable(invoiceAmount, numberOfEvaluations);
MedicalVendorInvoiceStatistic medicalVendorInvoiceStatistic = _medicalVendorInvoiceStatisticFactory.
CreateMedicalVendorInvoiceStatistic(medicalVendorInvoiceEntity, _medicalVendorInvoiceDataTable.Rows[0]);
Assert.AreEqual(medicalVendorInvoiceId, medicalVendorInvoiceStatistic.Id);
Assert.AreEqual(invoiceAmount, medicalVendorInvoiceStatistic.InvoiceAmount);
Assert.AreEqual(numberOfEvaluations, medicalVendorInvoiceStatistic.NumberOfEvaluations);
}
public PhysicianInvoice CreateMedicalVendorInvoice(PhysicianInvoiceEntity medicalVendorInvoiceEntity,
List <MedicalVendorInvoiceItem> medicalVendorInvoiceItems)
{
if (medicalVendorInvoiceEntity == null)
{
throw new ArgumentNullException("medicalVendorInvoiceEntity", "The given MedicalVendorInvoiceEntity cannot be null.");
}
if (medicalVendorInvoiceItems == null)
{
throw new ArgumentNullException("medicalVendorInvoiceEntity", "The given list of MedicalVendorInvoiceItems cannot be null.");
}
var medicalVendorInvoice = new PhysicianInvoice(medicalVendorInvoiceEntity.PhysicianInvoiceId)
{
MedicalVendorInvoiceItems = medicalVendorInvoiceItems
};
_medicalVendorInvoiceBaseFactory.SetMedicalVendorInvoiceBaseFields(medicalVendorInvoice, medicalVendorInvoiceEntity);
return(medicalVendorInvoice);
}
public void CreateMedicalVendorInvoiceEntitySetsPaymentStatusToPaymentStatusByteValue()
{
var paidMedicalVendorInvoice = new PhysicianInvoice {
PaymentStatus = PaymentStatus.Paid
};
var unpaidMedicalVendorInvoice = new PhysicianInvoice {
PaymentStatus = PaymentStatus.Unpaid
};
_mocks.ReplayAll();
PhysicianInvoiceEntity paidMedicalVendorInvoiceEntity = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoiceEntity(paidMedicalVendorInvoice);
PhysicianInvoiceEntity unpaidMedicalVendorInvoiceEntity = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoiceEntity(unpaidMedicalVendorInvoice);
_mocks.VerifyAll();
Assert.AreEqual((byte)paidMedicalVendorInvoice.PaymentStatus, paidMedicalVendorInvoiceEntity.PaymentStatus);
Assert.AreEqual((byte)unpaidMedicalVendorInvoice.PaymentStatus, unpaidMedicalVendorInvoiceEntity.PaymentStatus);
}
public void CreateMedicalVendorInvoiceEntitySetsApprovalStatusToApprovalStatusByteValue()
{
var approvedMedicalVendorInvoice = new PhysicianInvoice {
ApprovalStatus = ApprovalStatus.Approved
};
var unapprovedMedicalVendorInvoice = new PhysicianInvoice {
ApprovalStatus = ApprovalStatus.Unapproved
};
_mocks.ReplayAll();
PhysicianInvoiceEntity approvedMedicalVendorInvoiceEntity = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoiceEntity(approvedMedicalVendorInvoice);
PhysicianInvoiceEntity unapprovedMedicalVendorInvoiceEntity = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoiceEntity(unapprovedMedicalVendorInvoice);
_mocks.VerifyAll();
Assert.AreEqual((byte)approvedMedicalVendorInvoice.ApprovalStatus, approvedMedicalVendorInvoiceEntity.ApprovalStatus);
Assert.AreEqual((byte)unapprovedMedicalVendorInvoice.ApprovalStatus, unapprovedMedicalVendorInvoiceEntity.ApprovalStatus);
}
public MedicalVendorInvoiceStatistic CreateMedicalVendorInvoiceStatistic(PhysicianInvoiceEntity medicalVendorInvoiceEntity,
DataRow invoiceItemStatisticsForInvoice)
{
if (medicalVendorInvoiceEntity == null)
{
throw new ArgumentNullException("medicalVendorInvoiceEntity");
}
var invoiceAmount = invoiceItemStatisticsForInvoice.Field <decimal>("InvoiceAmount");
var numberOfEvaluations = invoiceItemStatisticsForInvoice.Field <int>("NumberOfEvaluations");
var evaluationStartTime = invoiceItemStatisticsForInvoice.Field <DateTime?>("EvaluationStartTime");
var evaluationEndTime = invoiceItemStatisticsForInvoice.Field <DateTime?>("EvaluationEndTime");
var evaluationTimeInMinutes = (evaluationStartTime.HasValue && evaluationEndTime.HasValue) ?
(decimal)(evaluationEndTime.Value - evaluationStartTime.Value).TotalMinutes : 0;
var averageHourlyRate = evaluationTimeInMinutes != 0 ? invoiceAmount / evaluationTimeInMinutes : 0;
var medicalVendorInvoiceStatistic = new MedicalVendorInvoiceStatistic(medicalVendorInvoiceEntity.PhysicianInvoiceId, invoiceAmount,
numberOfEvaluations, averageHourlyRate);
_medicalVendorInvoiceBaseFactory.SetMedicalVendorInvoiceBaseFields(medicalVendorInvoiceStatistic, medicalVendorInvoiceEntity);
return(medicalVendorInvoiceStatistic);
}
public PhysicianInvoice GetMedicalVendorInvoice(Guid approvalGuid)
{
var medicalVendorInvoiceEntity = new PhysicianInvoiceEntity {
ApprovalGuid = approvalGuid
};
var medicalVendorInvoiceItemEntities = new EntityCollection <PhysicianInvoiceItemEntity>();
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
var uniqueConstraintFilter = new PredicateExpression(PhysicianInvoiceFields.ApprovalGuid == approvalGuid);
if (!myAdapter.FetchEntityUsingUniqueConstraint(medicalVendorInvoiceEntity, uniqueConstraintFilter))
{
throw new ObjectNotFoundInPersistenceException <PhysicianInvoice>(approvalGuid);
}
var medicalVendorInvoiceItemBucket = new RelationPredicateBucket
(PhysicianInvoiceItemFields.PhysicianInvoiceId == medicalVendorInvoiceEntity.PhysicianInvoiceId);
myAdapter.FetchEntityCollection(medicalVendorInvoiceItemEntities, medicalVendorInvoiceItemBucket);
}
return(_medicalVendorInvoiceFactory.CreateMedicalVendorInvoice(medicalVendorInvoiceEntity, medicalVendorInvoiceItemEntities));
}
public void CreateMedicalVendorInvoicesReturnsOneInvoiceWhenOneInvoiceEntityGiven()
{
var medicalVendorInvoiceEntity = new PhysicianInvoiceEntity();
var medicalVendorInvoiceItemEntities = new EntityCollection <PhysicianInvoiceItemEntity>();
Expect.Call(_medicalVendorInvoiceItemFactory.CreateMedicalVendorInvoiceItems(medicalVendorInvoiceItemEntities))
.Return(new List <MedicalVendorInvoiceItem>());
Expect.Call(() => _medicalVendorInvoiceBaseFactory.SetMedicalVendorInvoiceBaseFields(null, null)).IgnoreArguments();
_mocks.ReplayAll();
List <PhysicianInvoice> medicalVendorInvoices = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoices(new EntityCollection <PhysicianInvoiceEntity> {
medicalVendorInvoiceEntity
},
medicalVendorInvoiceItemEntities);
_mocks.VerifyAll();
Assert.IsNotNull(medicalVendorInvoices);
Assert.AreEqual(1, medicalVendorInvoices.Count);
}
public void CreateMedicalVendorInvoiceEntityMapsDomainPropertiesToEntityPropertiesCorrectly()
{
var medicalVendorInvoice = new PhysicianInvoice
{
ApprovalGuid = Guid.NewGuid(),
PhysicianId = 3,
PayPeriodEndDate = new DateTime(2001, 3, 3),
MedicalVendorName = "Name"
};
_mocks.ReplayAll();
PhysicianInvoiceEntity medicalVendorInvoiceEntity = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoiceEntity(medicalVendorInvoice);
_mocks.VerifyAll();
Assert.AreEqual(medicalVendorInvoice.ApprovalGuid, medicalVendorInvoiceEntity.ApprovalGuid);
Assert.AreEqual(medicalVendorInvoice.PhysicianId, medicalVendorInvoiceEntity.PhysicianProfile.PhysicianId);
Assert.AreEqual(medicalVendorInvoice.PayPeriodEndDate, medicalVendorInvoiceEntity.PayPeriodEndDate);
Assert.AreEqual(medicalVendorInvoice.MedicalVendorName, medicalVendorInvoiceEntity.MedicalVendorName);
}
public void SaveMedicalVendorInvoiceThrowsExceptionWhenSavingInvoiceItemsFail()
{
var medicalVendorInvoice = new PhysicianInvoice();
var medicalVendorInvoiceEntity = new PhysicianInvoiceEntity(3);
Expect.Call(_mockedValidator.IsValid(medicalVendorInvoice)).Return(true);
ExpectGetDataAccessAdapterAndDispose(2);
ExpectFetchEntityCollection();
ExpectTransaction("MedicalVendorInvoiceRepository.SaveMedicalVendorInvoice", false);
ExpectSaveEntity(true, true);
ExpectSaveEntityCollection(0);
Expect.Call(_medicalVendorInvoiceFactory.CreateMedicalVendorInvoiceEntity(medicalVendorInvoice))
.Return(medicalVendorInvoiceEntity);
Expect.Call(_medicalVendorInvoiceItemFactory.CreateMedicalVendorInvoiceItemEntities
(medicalVendorInvoiceEntity.PhysicianInvoiceId, medicalVendorInvoice.MedicalVendorInvoiceItems))
.Return(new EntityCollection <PhysicianInvoiceItemEntity>());
_mocks.ReplayAll();
_medicalVendorInvoiceRepository.SaveMedicalVendorInvoice(medicalVendorInvoice);
_mocks.VerifyAll();
}
protected PhysicianPaymentInvoiceEntity(SerializationInfo info, StreamingContext context) : base(info, context)
{
if (SerializationHelper.Optimization != SerializationOptimization.Fast)
{
_physicianInvoice = (PhysicianInvoiceEntity)info.GetValue("_physicianInvoice", typeof(PhysicianInvoiceEntity));
if (_physicianInvoice != null)
{
_physicianInvoice.AfterSave += new EventHandler(OnEntityAfterSave);
}
_physicianPayment = (PhysicianPaymentEntity)info.GetValue("_physicianPayment", typeof(PhysicianPaymentEntity));
if (_physicianPayment != null)
{
_physicianPayment.AfterSave += new EventHandler(OnEntityAfterSave);
}
base.FixupDeserialization(FieldInfoProviderSingleton.GetInstance());
}
// __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor
// __LLBLGENPRO_USER_CODE_REGION_END
}
public void SaveMedicalVendorInvoiceCommitsTransactionOnSuccessfulPersistence()
{
var medicalVendorInvoice = new PhysicianInvoice();
var medicalVendorInvoiceEntity = new PhysicianInvoiceEntity(3);
const bool expectCommit = true;
Expect.Call(_mockedValidator.IsValid(medicalVendorInvoice)).Return(true);
ExpectGetDataAccessAdapterAndDispose(2);
ExpectFetchEntityCollection();
ExpectTransaction("MedicalVendorInvoiceRepository.SaveMedicalVendorInvoice", expectCommit);
ExpectSaveEntity(true, true);
ExpectSaveEntityCollection(1);
Expect.Call(_medicalVendorInvoiceFactory.CreateMedicalVendorInvoiceEntity(medicalVendorInvoice))
.Return(medicalVendorInvoiceEntity);
Expect.Call(_medicalVendorInvoiceItemFactory.CreateMedicalVendorInvoiceItemEntities
(medicalVendorInvoiceEntity.PhysicianInvoiceId, medicalVendorInvoice.MedicalVendorInvoiceItems))
.Return(new EntityCollection <PhysicianInvoiceItemEntity>());
_mocks.ReplayAll();
_medicalVendorInvoiceRepository.SaveMedicalVendorInvoice(medicalVendorInvoice);
_mocks.VerifyAll();
}
/// <summary> Removes the sync logic for member _physicianInvoice</summary>
/// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param>
/// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param>
private void DesetupSyncPhysicianInvoice(bool signalRelatedEntity, bool resetFKFields)
{
base.PerformDesetupSyncRelatedEntity(_physicianInvoice, new PropertyChangedEventHandler(OnPhysicianInvoicePropertyChanged), "PhysicianInvoice", PhysicianPaymentInvoiceEntity.Relations.PhysicianInvoiceEntityUsingPhysicianInvoiceId, true, signalRelatedEntity, "PhysicianPaymentInvoice", resetFKFields, new int[] { (int)PhysicianPaymentInvoiceFieldIndex.PhysicianInvoiceId });
_physicianInvoice = null;
}
public void SetMedicalVendorInvoiceBaseFields(PhysicianInvoiceBase baseObjectToSet, PhysicianInvoiceEntity physicianInvoiceEntity)
{
if (baseObjectToSet == null)
{
throw new ArgumentNullException("baseObjectToSet");
}
if (physicianInvoiceEntity == null)
{
throw new ArgumentNullException("physicianInvoiceEntity");
}
baseObjectToSet.ApprovalGuid = physicianInvoiceEntity.ApprovalGuid;
baseObjectToSet.ApprovalStatus = (ApprovalStatus)physicianInvoiceEntity.ApprovalStatus;
baseObjectToSet.PhysicianName = physicianInvoiceEntity.PhysicianName;
baseObjectToSet.PhysicianId = physicianInvoiceEntity.PhysicianId;
baseObjectToSet.DateApproved = physicianInvoiceEntity.DateApproved;
baseObjectToSet.DateGenerated = physicianInvoiceEntity.DateGenerated;
baseObjectToSet.MedicalVendorAddress = physicianInvoiceEntity.MedicalVendorAddress;
if (physicianInvoiceEntity.PhysicianProfile != null)
{
baseObjectToSet.MedicalVendorId = physicianInvoiceEntity.PhysicianProfile.PhysicianId;
}
baseObjectToSet.MedicalVendorName = physicianInvoiceEntity.MedicalVendorName;
baseObjectToSet.PaymentStatus = (PaymentStatus)physicianInvoiceEntity.PaymentStatus;
baseObjectToSet.PayPeriodStartDate = physicianInvoiceEntity.PayPeriodStartDate;
baseObjectToSet.PayPeriodEndDate = physicianInvoiceEntity.PayPeriodEndDate;
baseObjectToSet.DatePaid = physicianInvoiceEntity.DatePaid;
}
public void SaveMedicalVendorInvoice(PhysicianInvoice medicalVendorInvoice)
{
if (medicalVendorInvoice == null)
{
throw new ArgumentNullException("medicalVendorInvoice", "The given MedicalVendorInvoice cannot be null.");
}
if (!_validator.IsValid(medicalVendorInvoice))
{
throw new InvalidObjectException <PhysicianInvoice>(_validator);
}
// TODO: TEST (Integration)
var medicalVendorInvoiceEntities = new EntityCollection <PhysicianInvoiceEntity>();
IRelationPredicateBucket bucket = new RelationPredicateBucket
(PhysicianInvoiceFields.PhysicianId == medicalVendorInvoice.PhysicianId &
PhysicianInvoiceFields.PayPeriodStartDate <= medicalVendorInvoice.PayPeriodStartDate &
PhysicianInvoiceFields.PayPeriodEndDate >= medicalVendorInvoice.PayPeriodStartDate);
bucket.PredicateExpression.AddWithOr(
PhysicianInvoiceFields.PhysicianId == medicalVendorInvoice.PhysicianId &
PhysicianInvoiceFields.PayPeriodStartDate <= medicalVendorInvoice.PayPeriodEndDate &
PhysicianInvoiceFields.PayPeriodEndDate >= medicalVendorInvoice.PayPeriodEndDate);
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
myAdapter.FetchEntityCollection(medicalVendorInvoiceEntities, bucket);
}
if (!medicalVendorInvoiceEntities.IsEmpty())
{
throw new OverlappingInvoiceException(medicalVendorInvoice);
}
PhysicianInvoiceEntity medicalVendorInvoiceEntity = _medicalVendorInvoiceFactory.
CreateMedicalVendorInvoiceEntity(medicalVendorInvoice);
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
myAdapter.StartTransaction(IsolationLevel.ReadCommitted, "MedicalVendorInvoiceRepository.SaveMedicalVendorInvoice");
try
{
if (!myAdapter.SaveEntity(medicalVendorInvoiceEntity, true))
{
throw new PersistenceFailureException();
}
var medicalVendorInvoiceItemEntities = _medicalVendorInvoiceItemFactory.
CreateMedicalVendorInvoiceItemEntities(medicalVendorInvoiceEntity.PhysicianInvoiceId,
medicalVendorInvoice.MedicalVendorInvoiceItems);
if (myAdapter.SaveEntityCollection(medicalVendorInvoiceItemEntities) == 0)
{
throw new PersistenceFailureException();
}
myAdapter.Commit();
}
catch (Exception)
{
myAdapter.Rollback();
throw;
}
}
}