Difference between revisions of "MediaWiki:Gadget-calculator-drugs-core.js"
From WikiAnesthesia
Chris Rishel (talk | contribs) |
Chris Rishel (talk | contribs) |
||
| Line 53: | Line 53: | ||
}, | }, | ||
pill: { | pill: { | ||
baseName: ' | baseName: 'volume_abstract_2' | ||
}, | }, | ||
vial: { | vial: { | ||
Revision as of 07:51, 8 September 2021
/**
* @author Chris Rishel
*/
( function() {
var DEFAULT_DRUG_COLOR = 'default';
var DEFAULT_DRUG_POPULATION = 'general';
var DEFAULT_DRUG_ROUTE = 'iv';
mw.calculators.isValueDependent = function( value, variableId ) {
// This may need generalized to support other variables in the future
if( variableId === 'weight' ) {
return value && value.formatUnits().match( /\/[\s(]*?kg/ );
} else {
throw new Error( 'Dependence "' + variableId + '" not supported by isValueDependent' );
}
};
/**
* Define units
*/
mw.calculators.addUnitsBases( {
concentration: {
toString: function( units ) {
units = units.replace( ' pct', '%' );
units = units.replace( 'ug', 'mcg' );
return units;
}
},
mass: {
toString: function( units ) {
units = units.replace( 'ug', 'mcg' );
return units;
}
}
} );
mw.calculators.addUnits( {
mcg: {
baseName: 'mass',
definition: '1 ug'
},
pct: {
baseName: 'concentration',
definition: '10 mg/mL'
},
units: {
baseName: 'mass_abstract',
aliases: [
'unit'
]
},
pill: {
baseName: 'volume_abstract_2'
},
vial: {
baseName: 'volume_abstract'
}
} );
/**
* DrugColor
*/
mw.calculators.drugColors = {};
mw.calculators.addDrugColors = function( drugColorData ) {
var drugColors = mw.calculators.createCalculatorObjects( 'DrugColor', drugColorData );
for( var drugColorId in drugColors ) {
mw.calculators.drugColors[ drugColorId ] = drugColors[ drugColorId ];
}
};
mw.calculators.getDrugColor = function( drugColorId ) {
if( mw.calculators.drugColors.hasOwnProperty( drugColorId ) ) {
return mw.calculators.drugColors[ drugColorId ];
} else {
return null;
}
};
/**
* Class DrugColor
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugColor}
* @constructor
*/
mw.calculators.objectClasses.DrugColor = function( propertyValues ) {
var properties = {
required: [
'id'
],
optional: [
'parentColor',
'primaryColor',
'highlightColor',
'striped'
]
};
mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
this.parentColor = this.parentColor || this.id === DEFAULT_DRUG_COLOR ? this.parentColor : DEFAULT_DRUG_COLOR;
};
mw.calculators.objectClasses.DrugColor.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
mw.calculators.objectClasses.DrugColor.prototype.getParentDrugColor = function() {
if( !this.parentColor ) {
return null;
}
var parentDrugColor = mw.calculators.getDrugColor( this.parentColor );
if( !parentDrugColor ) {
throw new Error( 'Parent drug color "' + this.parentColor + '" not found for drug color "' + this.id + '"' );
}
return parentDrugColor;
};
mw.calculators.objectClasses.DrugColor.prototype.getHighlightColor = function() {
if( this.highlightColor ) {
return this.highlightColor;
} else if( this.parentColor ) {
return this.getParentDrugColor().getHighlightColor();
}
};
mw.calculators.objectClasses.DrugColor.prototype.getPrimaryColor = function() {
if( this.primaryColor ) {
return this.primaryColor;
} else if( this.parentColor ) {
return this.getParentDrugColor().getPrimaryColor();
}
};
mw.calculators.objectClasses.DrugColor.prototype.isStriped = function() {
if( this.striped !== null ) {
return this.striped;
} else if( this.parentColor ) {
return this.getParentDrugColor().isStriped();
}
};
/**
* DrugPopulation
*/
mw.calculators.drugPopulations = {};
mw.calculators.addDrugPopulations = function( drugPopulationData ) {
var drugPopulations = mw.calculators.createCalculatorObjects( 'DrugPopulation', drugPopulationData );
for( var drugPopulationId in drugPopulations ) {
mw.calculators.drugPopulations[ drugPopulationId ] = drugPopulations[ drugPopulationId ];
}
};
mw.calculators.getDrugPopulation = function( drugPopulationId ) {
if( mw.calculators.drugPopulations.hasOwnProperty( drugPopulationId ) ) {
return mw.calculators.drugPopulations[ drugPopulationId ];
} else {
return null;
}
};
/**
* Class DrugPopulation
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugPopulation}
* @constructor
*/
mw.calculators.objectClasses.DrugPopulation = function( propertyValues ) {
var properties = {
required: [
'id',
'name'
],
optional: [
'abbreviation',
'variables'
]
};
mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
if( this.variables ) {
for( var variableId in this.variables ) {
if( !mw.calculators.getVariable( variableId ) ) {
throw new Error( 'DrugPopulation variable "' + variableId + '" not defined' );
}
this.variables[ variableId ].min = this.variables[ variableId ].hasOwnProperty( 'min' ) ?
math.unit( this.variables[ variableId ].min ) : null;
this.variables[ variableId ].max = this.variables[ variableId ].hasOwnProperty( 'max' ) ?
math.unit( this.variables[ variableId ].max ) : null;
}
} else {
this.variables = {};
}
};
mw.calculators.objectClasses.DrugPopulation.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
mw.calculators.objectClasses.DrugPopulation.prototype.getCalculationData = function() {
var inputData = new mw.calculators.objectClasses.CalculationData();
for( var variableId in this.variables ) {
inputData.variables.required.push( variableId );
}
return inputData;
};
mw.calculators.objectClasses.DrugPopulation.prototype.getCalculationDataScore = function( dataValues ) {
// A return value of -1 indicates the data did not match the population definition
for( var variableId in this.variables ) {
if( !dataValues.hasOwnProperty( variableId ) ) {
return -1;
}
if( this.variables[ variableId ].min &&
( !dataValues[ variableId ] ||
!math.largerEq( dataValues[ variableId ], this.variables[ variableId ].min ) ) ) {
return -1;
}
if( this.variables[ variableId ].max &&
( !dataValues[ variableId ] ||
!math.smallerEq( dataValues[ variableId ], this.variables[ variableId ].max ) ) ) {
return -1;
}
}
// If the data matches the population definition, the score corresponds to the number of variables in the
// population definition. This should roughly correspond to the specificity of the population.
return Object.keys( this.variables ).length;
};
mw.calculators.objectClasses.DrugPopulation.prototype.toString = function() {
return mw.calculators.isMobile() && this.abbreviation ? this.abbreviation : this.name;
};
/**
* DrugRoute
*/
mw.calculators.drugRoutes = {};
mw.calculators.addDrugRoutes = function( drugRouteData ) {
var drugRoutes = mw.calculators.createCalculatorObjects( 'DrugRoute', drugRouteData );
for( var drugRouteId in drugRoutes ) {
mw.calculators.drugRoutes[ drugRouteId ] = drugRoutes[ drugRouteId ];
}
};
mw.calculators.getDrugRoute = function( drugRouteId ) {
if( mw.calculators.drugRoutes.hasOwnProperty( drugRouteId ) ) {
return mw.calculators.drugRoutes[ drugRouteId ];
} else {
return null;
}
};
/**
* Class DrugRoute
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugRoute}
* @constructor
*/
mw.calculators.objectClasses.DrugRoute = function( propertyValues ) {
mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
this.abbreviation = this.abbreviation ? this.abbreviation : this.name;
};
mw.calculators.objectClasses.DrugRoute.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
mw.calculators.objectClasses.DrugRoute.prototype.getProperties = function() {
return {
required: [
'id',
'name'
],
optional: [
'abbreviation',
'default'
]
};
};
mw.calculators.objectClasses.DrugRoute.prototype.toString = function() {
return mw.calculators.isMobile() && this.abbreviation ? this.abbreviation : this.name;
};
/**
* DrugIndication
*/
mw.calculators.drugIndications = {};
mw.calculators.addDrugIndications = function( drugIndicationData ) {
var drugIndications = mw.calculators.createCalculatorObjects( 'DrugIndication', drugIndicationData );
for( var drugIndicationId in drugIndications ) {
mw.calculators.drugIndications[ drugIndicationId ] = drugIndications[ drugIndicationId ];
}
};
mw.calculators.getDrugIndication = function( drugIndicationId ) {
if( mw.calculators.drugIndications.hasOwnProperty( drugIndicationId ) ) {
return mw.calculators.drugIndications[ drugIndicationId ];
} else {
return null;
}
};
/**
* Class DrugIndication
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugIndication}
* @constructor
*/
mw.calculators.objectClasses.DrugIndication = function( propertyValues ) {
var properties = {
required: [
'id',
'name'
],
optional: [
'abbreviation',
'default'
]
};
mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
};
mw.calculators.objectClasses.DrugIndication.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
mw.calculators.objectClasses.DrugIndication.prototype.toString = function() {
return mw.calculators.isMobile() && this.abbreviation ? this.abbreviation : this.name;
};
/**
* Drug
*/
mw.calculators.drugs = {};
mw.calculators.addDrugs = function( drugData ) {
var drugs = mw.calculators.createCalculatorObjects( 'Drug', drugData );
for( var drugId in drugs ) {
mw.calculators.drugs[ drugId ] = drugs[ drugId ];
var drugDosageCalculationId = mw.calculators.getDrugDosageCalculationId( drugId );
var drugDosageCalculation = mw.calculators.getCalculation( drugDosageCalculationId );
if( !drugDosageCalculation ) {
var calculationData = {};
calculationData[ drugDosageCalculationId ] = {
calculate: mw.calculators.objectClasses.DrugDosageCalculation.prototype.calculate,
drug: drugId,
type: 'drug'
};
mw.calculators.addCalculations( calculationData, 'DrugDosageCalculation' );
drugDosageCalculation = mw.calculators.getCalculation( drugDosageCalculationId );
}
drugDosageCalculation.setDependencies();
}
};
mw.calculators.addDrugDosages = function( drugId, drugDosageData ) {
var drug = mw.calculators.getDrug( drugId );
if( !drug ) {
throw new Error( 'DrugDosage references drug "' + drugId + '" which is not defined' );
}
drug.addDosages( drugDosageData );
// Update calculation dependencies
var drugDosageCalculation = mw.calculators.getCalculation( mw.calculators.getDrugDosageCalculationId( drugId ) );
drugDosageCalculation.updateVariables();
drugDosageCalculation.setDependencies();
};
mw.calculators.getDrug = function( drugId ) {
if( mw.calculators.drugs.hasOwnProperty( drugId ) ) {
return mw.calculators.drugs[ drugId ];
} else {
return null;
}
};
/**
* Class Drug
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.Drug}
* @constructor
*/
mw.calculators.objectClasses.Drug = function( propertyValues ) {
mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
if( !this.color ) {
this.color = DEFAULT_DRUG_COLOR;
}
var color = mw.calculators.getDrugColor( this.color );
if( !color ) {
throw new Error( 'Invalid drug color "' + this.color + '" for drug "' + this.id + '"' );
}
this.color = color;
if( this.preparations ) {
var preparationData = this.preparations;
this.preparations = [];
this.addPreparations( preparationData );
} else {
this.preparations = [];
}
if( this.dosages ) {
var dosageData = this.dosages;
this.dosages = [];
this.addDosages( dosageData );
} else {
this.dosages = [];
}
this.references = this.references ? this.references : [];
};
mw.calculators.objectClasses.Drug.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
mw.calculators.objectClasses.Drug.prototype.addDosages = function( dosageData ) {
var dosages = mw.calculators.createCalculatorObjects( 'DrugDosage', dosageData );
for( var dosageId in dosages ) {
dosages[ dosageId ].id = this.dosages.length;
this.dosages.push( dosages[ dosageId ] );
}
};
mw.calculators.objectClasses.Drug.prototype.addPreparations = function( preparationData ) {
var preparations = mw.calculators.createCalculatorObjects( 'DrugPreparation', preparationData );
for( var preparationId in preparations ) {
preparations[ preparationId ].id = this.preparations.length;
this.preparations.push( preparations[ preparationId ] );
}
};
mw.calculators.objectClasses.Drug.prototype.getIndications = function() {
var indications = [];
for( var iDosage in this.dosages ) {
if( this.dosages[ iDosage ].indication ) {
indications.push( this.dosages[ iDosage ].indication );
}
}
return indications.filter( mw.calculators.uniqueValues );
};
mw.calculators.objectClasses.Drug.prototype.getPopulations = function( indicationId ) {
var populations = [];
for( var iDosage in this.dosages ) {
if( this.dosages[ iDosage ].population &&
( !indicationId || ( this.dosages[ iDosage ].indication && this.dosages[ iDosage ].indication.id === indicationId ) ) ) {
populations.push( this.dosages[ iDosage ].population );
}
}
return populations.filter( mw.calculators.uniqueValues );
};
mw.calculators.objectClasses.Drug.prototype.getRoutes = function( indicationId ) {
var routes = [];
for( var iDosage in this.dosages ) {
if( this.dosages[ iDosage ].routes.length &&
( !indicationId || ( this.dosages[ iDosage ].indication && this.dosages[ iDosage ].indication.id === indicationId ) ) ) {
for( var iRoute in this.dosages[ iDosage ].routes ) {
routes.push( this.dosages[ iDosage ].routes[ iRoute ] );
}
}
}
return routes.filter( mw.calculators.uniqueValues );
};
mw.calculators.objectClasses.Drug.prototype.getPreparations = function( excludeDilutionRequired ) {
var preparations = this.preparations.filter( mw.calculators.uniqueValues );
if( excludeDilutionRequired ) {
for( var iPreparation in preparations ) {
if( preparations[ iPreparation ].dilutionRequired ) {
delete preparations[ iPreparation ];
}
}
}
return preparations;
};
mw.calculators.objectClasses.Drug.prototype.getProperties = function() {
return {
required: [
'id',
'name'
],
optional: [
'color',
'description',
'dosages',
'preparations',
'references',
'searchData'
]
};
};
/**
* DrugPreparation
*/
mw.calculators.addDrugPreparations = function( drugId, drugPreparationData ) {
var drug = mw.calculators.getDrug( drugId );
if( !drug ) {
throw new Error( 'DrugPreparation references drug "' + drugId + '" which is not defined' );
}
drug.addPreparations( drugPreparationData );
var drugDosageCalculation = mw.calculators.getCalculation( mw.calculators.getDrugDosageCalculationId( drugId ) );
drugDosageCalculation.recalculate();
};
/**
* Class DrugPreparation
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugPreparation}
* @constructor
*/
mw.calculators.objectClasses.DrugPreparation = function( propertyValues ) {
var properties = {
required: [
'id',
'concentration'
],
optional: [
'default',
'dilutionRequired',
'commonDilution'
]
};
mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
this.concentration = this.concentration.replace( 'mcg', 'ug' );
this.concentration = math.unit( this.concentration );
};
mw.calculators.objectClasses.DrugPreparation.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
mw.calculators.objectClasses.DrugPreparation.prototype.getVolumeUnits = function() {
// The units of concentration will always be of the form "mass / volume"
// The regular expression matches all text leading up to the volume units
return mw.calculators.getUnitsByBase( this.concentration ).volume;
};
mw.calculators.objectClasses.DrugPreparation.prototype.toString = function() {
return mw.calculators.getValueString( this.concentration );
};
/**
* Class DrugDosage
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugDosage}
* @constructor
*/
mw.calculators.objectClasses.DrugDosage = function( propertyValues ) {
mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
var drugIndication = mw.calculators.getDrugIndication( this.indication );
if( !drugIndication ) {
throw new Error( 'Invalid indication "' + this.indication + '" for drug dosage' );
}
this.indication = drugIndication;
this.population = this.population ? this.population : DEFAULT_DRUG_POPULATION;
var drugPopulation = mw.calculators.getDrugPopulation( this.population );
if( !drugPopulation ) {
throw new Error( 'Invalid population "' + this.population + '" for drug dosage' );
}
this.population = drugPopulation;
this.references = this.references ? this.references : [];
this.routes = this.routes ? this.routes : [ DEFAULT_DRUG_ROUTE ];
if( !Array.isArray( this.routes ) ) {
this.routes = [ this.routes ];
}
drugRoutes = [];
for( var iRoute in this.routes ) {
var drugRoute = this.routes[ iRoute ];
if( !drugRoute ) {
throw new Error( 'Invalid route "' + drugRoute + '" for drug dosage' );
}
drugRoutes[ iRoute ] = mw.calculators.getDrugRoute( drugRoute );
}
this.routes = drugRoutes;
// Add the dose objects to the drug
var drugDoseData = this.dose;
this.dose = [];
this.addDoses( drugDoseData );
};
mw.calculators.objectClasses.DrugDosage.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
mw.calculators.objectClasses.DrugDosage.prototype.addDoses = function( drugDoseData ) {
// Each dosage can have one or more associated doses. Ensure this value is an array.
if( !Array.isArray( drugDoseData ) ) {
drugDoseData = [ drugDoseData ];
}
var doses = mw.calculators.createCalculatorObjects( 'DrugDose', drugDoseData );
for( var doseId in doses ) {
doses[ doseId ].id = this.dose.length;
this.dose.push( doses[ doseId ] );
}
};
mw.calculators.objectClasses.DrugDosage.prototype.getCalculationData = function() {
var inputData = new mw.calculators.objectClasses.CalculationData();
inputData = inputData.merge( this.population.getCalculationData() );
for( var iDose in this.dose ) {
inputData = inputData.merge( this.dose[ iDose ].getCalculationData() );
}
return inputData;
};
mw.calculators.objectClasses.DrugDosage.prototype.getProperties = function() {
return {
required: [
'dose',
'id',
'indication'
],
optional: [
'description',
'population',
'routes',
'references'
]
};
};
mw.calculators.objectClasses.DrugDosage.prototype.getRouteString = function() {
var routeString = '';
for( var iRoute in this.routes ) {
routeString += routeString ? '/' : '';
routeString += this.routes[ iRoute ].abbreviation;
}
return routeString;
};
mw.calculators.objectClasses.DrugDosage.prototype.hasInfo = function() {
return this.description;
};
/**
* Class DrugDose
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugDose}
* @constructor
*/
mw.calculators.objectClasses.DrugDose = function( propertyValues ) {
mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
if( this.weightCalculation ) {
var weightCalculationIds = this.weightCalculation;
// weightCalculation property will contain references to the actual objects, so reinitialize
this.weightCalculation = [];
if( !Array.isArray( weightCalculationIds ) ) {
weightCalculationIds = [ weightCalculationIds ];
}
for( var iWeightCalculation in weightCalculationIds ) {
var weightCalculationId = weightCalculationIds[ iWeightCalculation ];
var weightCalculation = mw.calculators.getCalculation( weightCalculationId );
if( !weightCalculation ) {
throw new Error( 'Drug dose references weight calculation "' + weightCalculationId + '" which is not defined' );
}
this.weightCalculation.push( weightCalculation );
}
} else {
this.weightCalculation = [];
}
var mathProperties = this.getMathProperties();
var isWeightDependent = false;
for( var iMathProperty in mathProperties ) {
var mathProperty = mathProperties[ iMathProperty ];
if( this[ mathProperty ] ) {
// TODO consider making a UnitsBase.weight.fromString()
this[ mathProperty ] = this[ mathProperty ].replace( 'kg', 'kgwt' );
this[ mathProperty ] = this[ mathProperty ].replace( 'mcg', 'ug' );
this[ mathProperty ] = math.unit( this[ mathProperty ] );
if( mw.calculators.isValueDependent( this[ mathProperty ], 'weight' ) ) {
isWeightDependent = true;
}
} else {
this[ mathProperty ] = null;
}
}
if( isWeightDependent ) {
// Default is tbw
this.weightCalculation.push( mw.calculators.getCalculation( 'tbw' ) );
}
};
mw.calculators.objectClasses.DrugDose.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
mw.calculators.objectClasses.DrugDose.prototype.getAdministration = function() {
var administration = '';
if( this.frequency ) {
administration += administration ? ' ' : '';
administration += this.frequency;
}
if( this.duration ) {
administration += administration ? ' ' : '';
administration += 'over ' + this.duration;
}
return administration;
};
mw.calculators.objectClasses.DrugDose.prototype.getCalculationData = function() {
var calculationData = new mw.calculators.objectClasses.CalculationData();
for( var iWeightCalculation in this.weightCalculation ) {
calculationData.calculations.optional.push( this.weightCalculation[ iWeightCalculation ].id );
}
return calculationData;
};
mw.calculators.objectClasses.DrugDose.prototype.getMathProperties = function() {
return [
'dose',
'min',
'max',
'absoluteMin',
'absoluteMax'
];
};
mw.calculators.objectClasses.DrugDose.prototype.getProperties = function() {
return {
required: [
'id'
],
optional: [
'absoluteMax',
'absoluteMin',
'dose',
'duration',
'frequency',
'min',
'max',
'name',
'weightCalculation'
]
};
};
mw.calculators.getDrugDosageCalculationId = function( drugId ) {
return 'drugDosages-' + drugId;
};
/**
* Class DrugDosageCalculation
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugDosageCalculation}
* @constructor
*/
mw.calculators.objectClasses.DrugDosageCalculation = function( propertyValues ) {
mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
this.initialize();
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype = Object.create( mw.calculators.objectClasses.AbstractCalculation.prototype );
mw.calculators.objectClasses.DrugDosageCalculation.prototype.calculate = function( data ) {
var value = {
message: null,
population: null,
preparation: data.preparation,
dose: []
};
this.activeDosageId = null;
if( !data.drug.dosages.length ) {
value.message = 'No dose data';
return value;
}
// Determine which dosage to use
var populationScores = [];
for( var iDosage in data.drug.dosages ) {
var drugDosage = data.drug.dosages[ iDosage ];
// If the indication and route do not match, set the score to -1
var populationScore = -1;
// Make sure the indication matches
if( drugDosage.indication.id === data.indication.id ) {
for( var iRoute in drugDosage.routes ) {
// Make sure the route matches
if( drugDosage.routes[ iRoute ].id === data.route.id ) {
populationScore = drugDosage.population.getCalculationDataScore( data );
break;
}
}
}
populationScores.push( populationScore );
}
var maxPopulationScore = Math.max.apply( null, populationScores );
if( maxPopulationScore < 0 ) {
value.message = 'No dose data for indication "' + String( data.indication ) + '" and route "' + String( data.route ) + '"';
return value;
}
// If there is more than one dosage with the same score, take the first.
// This allows the data editor to decide which is most important.
this.activeDosageId = populationScores.indexOf( maxPopulationScore );
var dosage = data.drug.dosages[ this.activeDosageId ];
// A dosage may contain multiple doses (e.g. induction and maintenance)
for( var iDose in dosage.dose ) {
var dose = dosage.dose[ iDose ];
var mathProperties = dose.getMathProperties();
var weightCalculation = null;
var weightValue = null;
// data.weightCalculation should be in order of preference, so take the first non-null value
for( var iWeightCalculation in dose.weightCalculation ) {
if( dose.weightCalculation[ iWeightCalculation ].value !== null ) {
weightCalculation = dose.weightCalculation[ iWeightCalculation ];
weightValue = dose.weightCalculation[ iWeightCalculation ].value;
break;
}
}
// Initialize value properties for dose
value.dose[ iDose ] = {
massPerWeight: {},
mass: {},
volume: {},
weightCalculation: weightCalculation ? weightCalculation : null
};
var massUnits;
var volumeUnits;
for( var iMathProperty in mathProperties ) {
var mathProperty = mathProperties[ iMathProperty ];
var doseValue = dose[ mathProperty ];
if( doseValue ) {
var doseUnitsByBase = mw.calculators.getUnitsByBase( doseValue );
if( doseUnitsByBase.hasOwnProperty( 'weight' ) ) {
value.dose[ iDose ].massPerWeight[ mathProperty ] = doseValue;
if( weightValue ) {
massUnits = doseUnitsByBase.mass;
if( doseUnitsByBase.hasOwnProperty( 'time' ) ) {
massUnits += '/' + doseUnitsByBase.time;
}
// For whatever reason math.format will simplify the units, but math.formatUnits will not
// as a hack, we recreate a new unit value with the correct formatting of the result
value.dose[ iDose ].mass[ mathProperty ] = math.unit( math.multiply( doseValue, weightValue ).format() ).to( massUnits );
}
} else {
value.dose[ iDose ].mass[ mathProperty ] = doseValue;
}
if( data.preparation && value.dose[ iDose ].mass[ mathProperty ] ) {
// Need a special case for pct
if( data.preparation.concentration.formatUnits() === 'pct' ) {
volumeUnits = 'mL';
} else {
var preparationUnitsByBase = mw.calculators.getUnitsByBase( data.preparation.concentration );
volumeUnits = preparationUnitsByBase.volume;
}
if( doseUnitsByBase.hasOwnProperty( 'time' ) ) {
volumeUnits += '/' + doseUnitsByBase.time;
}
// Same hack as above to get units to simplify correctly
value.dose[ iDose ].volume[ mathProperty ] = math.unit( math.multiply( value.dose[ iDose ].mass[ mathProperty ], math.divide( 1, data.preparation.concentration ) ).format() ).to( volumeUnits );
}
}
}
if( value.dose[ iDose ].mass.hasOwnProperty( 'absoluteMin' ) ) {
if( value.dose[ iDose ].mass.hasOwnProperty( 'max' ) && math.larger( value.dose[ iDose ].mass.absoluteMin, value.dose[ iDose ].mass.max ) ) {
// Both min and max are larger than the absolute max dose, so just convert to single dose.
value.dose[ iDose ].mass.dose = value.dose[ iDose ].mass.absoluteMin;
delete value.dose[ iDose ].mass.min;
delete value.dose[ iDose ].mass.max;
if( value.dose[ iDose ].volume.hasOwnProperty( 'absoluteMin' ) ) {
value.dose[ iDose ].volume.dose = value.dose[ iDose ].volume.absoluteMin;
delete value.dose[ iDose ].volume.min;
delete value.dose[ iDose ].volume.max;
}
} else if( value.dose[ iDose ].mass.hasOwnProperty( 'min' ) && math.larger( value.dose[ iDose ].mass.absoluteMin, value.dose[ iDose ].mass.min ) ) {
value.dose[ iDose ].mass.min = value.dose[ iDose ].mass.absoluteMin;
if( value.dose[ iDose ].volume.hasOwnProperty( 'absoluteMin' ) ) {
value.dose[ iDose ].volume.min = value.dose[ iDose ].volume.absoluteMin;
}
} else if( value.dose[ iDose ].mass.hasOwnProperty( 'dose' ) && math.larger( value.dose[ iDose ].mass.absoluteMin, value.dose[ iDose ].mass.dose ) ) {
value.dose[ iDose ].mass.dose = value.dose[ iDose ].mass.absoluteMin;
if( value.dose[ iDose ].volume.hasOwnProperty( 'absoluteMin' ) ) {
value.dose[ iDose ].volume.dose = value.dose[ iDose ].volume.absoluteMin;
}
}
}
if( value.dose[ iDose ].mass.hasOwnProperty( 'absoluteMax' ) ) {
if( value.dose[ iDose ].mass.hasOwnProperty( 'min' ) && math.smaller( value.dose[ iDose ].mass.absoluteMax, value.dose[ iDose ].mass.min ) ) {
// Both min and max are larger than the absolute max dose, so just convert to single dose.
value.dose[ iDose ].mass.dose = value.dose[ iDose ].mass.absoluteMax;
delete value.dose[ iDose ].mass.min;
delete value.dose[ iDose ].mass.max;
if( value.dose[ iDose ].volume.hasOwnProperty( 'absoluteMax' ) ) {
value.dose[ iDose ].volume.dose = value.dose[ iDose ].volume.absoluteMax;
delete value.dose[ iDose ].volume.min;
delete value.dose[ iDose ].volume.max;
}
} else if( value.dose[ iDose ].mass.hasOwnProperty( 'max' ) && math.smaller( value.dose[ iDose ].mass.absoluteMax, value.dose[ iDose ].mass.max ) ) {
value.dose[ iDose ].mass.max = value.dose[ iDose ].mass.absoluteMax;
if( value.dose[ iDose ].volume.hasOwnProperty( 'absoluteMax' ) ) {
value.dose[ iDose ].volume.max = value.dose[ iDose ].volume.absoluteMax;
}
} else if( value.dose[ iDose ].mass.hasOwnProperty( 'dose' ) && math.smaller( value.dose[ iDose ].mass.absoluteMax, value.dose[ iDose ].mass.dose ) ) {
value.dose[ iDose ].mass.dose = value.dose[ iDose ].mass.absoluteMax;
if( value.dose[ iDose ].volume.hasOwnProperty( 'absoluteMax' ) ) {
value.dose[ iDose ].volume.dose = value.dose[ iDose ].volume.absoluteMax;
}
}
}
}
return value;
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.doRender = function() {
var $calculationContainer = $( '.' + this.getContainerId() );
if( !$calculationContainer.length ) {
return;
}
// Add all required classes
$calculationContainer.addClass( 'border ' + this.getContainerClasses() );
// Add search phrases
$calculationContainer.attr( 'data-search', this.getSearchString() );
// Store this object in a local variable since .each() will reassign this to the DOM object of each
// calculation container.
var calculation = this;
var calculationCount = 0;
// Eventually may implement different rendering, so we should regenerate
// all elements with each iteration of the loop.
// I.e. might show result in table and inline in 2 different places of article.
$calculationContainer.each( function() {
// Initalize the variables for all the elements of the calculation. These need to be in order of placement
// in the calculation container
var elementTypes = [
'title',
'dosage',
'info'
];
var elements = {};
for( var iElementType in elementTypes ) {
var elementType = elementTypes[ iElementType ];
// If an input contained by $container has user input focus, $container will not rerender (would be
// annoying behavior to the user). However, if it contains subelements which should try to rerender,
// add those elements to the contains property.
elements[ elementType ] = {
$container: null,
contains: [],
id: calculation.getContainerId() + '-' + elementType
};
if( calculationCount ) {
elements[ elementType ].id += '-' + calculationCount;
}
}
// Create title element and append to container
elements.title.$container = $( '<div>', {
id: elements.title.id,
class: 'col-12 border-bottom ' + calculation.getElementClasses( 'title' )
} );
elements.title.$container.append( calculation.getTitleHtml() );
if( calculation.hasInfo() ) {
// Id of the info container should already be set by getInfo()
elements.info.$container = calculation.getInfo();
}
// Create the dosage element
elements.dosage.$container = $( '<div>', {
id: elements.dosage.id,
class: 'row no-gutters ' + calculation.getElementClasses( 'dosage' )
} );
// Dose column
var $dose = $( '<div>', {
id: calculation.getContainerId() + '-dose',
class: 'col-7 ' + calculation.getElementClasses( 'dose' )
} );
var dash = '-';
// The options column should only show the preparation if there is a calculated volume
var hasVolume;
if( !calculation.value || calculation.activeDosageId === null ) {
if( calculation.value && calculation.value.hasOwnProperty( 'message' ) ) {
$dose.append( $( '<i>' ).append( calculation.value.message ) );
}
} else {
var dosage = calculation.drug.dosages[ calculation.activeDosageId ];
if( dosage.population && dosage.population.id !== DEFAULT_DRUG_POPULATION ) {
var $dosePopulation = $( '<div>', {
class: calculation.getElementClasses( 'dose-info' )
} );
$dosePopulation
.append( $( '<div>', {
class: calculation.getElementClasses( 'dose-info-population' )
} ).append( String( dosage.population ) + ' dosing' ) );
$dose.append( $dosePopulation );
}
var $doseData = $( '<div>', {
class: calculation.getElementClasses( 'dose-data' )
} );
// This will iterate through the calculated doses. iDose should exactly correspond to doses within dosage
// to allow referencing other properties of the dose.
for( var iDose in calculation.value.dose ) {
var dose = dosage.dose[ iDose ];
var doseValue = calculation.value.dose[ iDose ];
if( dose.name ) {
$doseData.append( dose.name + '<br />' );
}
var $doseList = $( '<ul>' );
var administration = '';
var administrationDisplayed = false;
if( dosage.routes && !mw.calculators.isMobile() ) {
administration += dosage.getRouteString();
}
var doseAdministration = dose.getAdministration();
if( doseAdministration ) {
administration += administration ? ' ' : '';
administration += doseAdministration;
}
var massPerWeightHtml = '';
if( doseValue.massPerWeight.hasOwnProperty( 'dose' ) ) {
massPerWeightHtml += mw.calculators.getValueString( doseValue.massPerWeight.dose );
} else if( doseValue.massPerWeight.hasOwnProperty( 'min' ) &&
doseValue.massPerWeight.hasOwnProperty( 'max' ) ) {
// getValueString will simplify the value and may adjust the units
var massPerWeightMinValue = math.unit( mw.calculators.getValueString( doseValue.massPerWeight.min ) );
var massPerWeightMaxValue = math.unit( mw.calculators.getValueString( doseValue.massPerWeight.max ) );
if( massPerWeightMinValue.formatUnits() !== massPerWeightMaxValue.formatUnits() ) {
// If the units between min and max don't match, show both
massPerWeightHtml += mw.calculators.getValueString( massPerWeightMinValue );
} else {
massPerWeightHtml += mw.calculators.getValueNumber( massPerWeightMinValue );
}
massPerWeightHtml += dash;
massPerWeightHtml += mw.calculators.getValueString( massPerWeightMaxValue );
}
if( massPerWeightHtml ) {
if( administration && ! administrationDisplayed ) {
massPerWeightHtml += ' ' + administration;
administrationDisplayed = true;
}
var massPerWeightNotesHtml = '';
if( doseValue.mass.hasOwnProperty( 'absoluteMin' ) ) {
massPerWeightNotesHtml += 'Min: ' + mw.calculators.getValueString( doseValue.mass.absoluteMin );
} else if( doseValue.mass.hasOwnProperty( 'absoluteMax' ) ) {
massPerWeightNotesHtml += 'Max: ' + mw.calculators.getValueString( doseValue.mass.absoluteMax );
}
if( dose.weightCalculation && dose.weightCalculation[ 0 ].id !== 'tbw' ) {
if( massPerWeightNotesHtml ) {
massPerWeightNotesHtml += ', ';
}
massPerWeightNotesHtml += dose.weightCalculation[ 0 ].getTitleString();
}
if( massPerWeightNotesHtml ) {
massPerWeightHtml += ' (' + massPerWeightNotesHtml + ')';
}
massPerWeightHtml = $( '<li>' ).append( massPerWeightHtml );
$doseList.append( massPerWeightHtml );
}
var massHtml = '';
if( doseValue.mass.hasOwnProperty( 'dose' ) ) {
massHtml += mw.calculators.getValueString( doseValue.mass.dose );
} else if( doseValue.mass.hasOwnProperty( 'min' ) &&
doseValue.mass.hasOwnProperty( 'max' ) ) {
// getValueString will simplify the value and may adjust the units
var massMinValue = math.unit( mw.calculators.getValueString( doseValue.mass.min ) );
var massMaxValue = math.unit( mw.calculators.getValueString( doseValue.mass.max ) );
if( massMinValue.formatUnits() !== massMaxValue.formatUnits() ) {
// If the units between min and max don't match, show both
massHtml += mw.calculators.getValueString( massMinValue );
} else {
massHtml += mw.calculators.getValueNumber( massMinValue );
}
massHtml += dash;
massHtml += mw.calculators.getValueString( massMaxValue );
}
if( massHtml ) {
if( administration && ! administrationDisplayed ) {
massHtml += ' ' + administration;
administrationDisplayed = true;
}
if( dose.weightCalculation.length && doseValue.weightCalculation.id !== dose.weightCalculation[ 0 ].id ) {
var weightCalculationLabel = doseValue.weightCalculation.getTitleString();
var $weightCalculationInfoIcon = $( '<a>', {
tabindex: '0',
'data-container': 'body',
'data-html': 'true',
'data-placement': 'top',
'data-toggle': 'popover',
'data-trigger': 'focus',
'data-content': doseValue.weightCalculation.name +
' is being used because data is missing for ' +
dose.weightCalculation[ 0 ].name + ': ' + dose.weightCalculation[ 0 ].message
} )
.append( $( '<i>', {
class: 'far fa-question-circle'
} ) );
massHtml += ' (' + weightCalculationLabel + ' ' + $weightCalculationInfoIcon[ 0 ].outerHTML + ')';
}
massHtml = $( '<li>' ).append( massHtml );
$doseList.append( massHtml );
}
var volumeHtml = '';
if( doseValue.volume.hasOwnProperty( 'dose' ) ) {
volumeHtml += mw.calculators.getValueString( doseValue.volume.dose );
} else if( doseValue.volume.hasOwnProperty( 'min' ) &&
doseValue.volume.hasOwnProperty( 'max' ) ) {
// getValueString will simplify the value and may adjust the units
var volumeMinValue = math.unit( mw.calculators.getValueString( doseValue.volume.min ) );
var volumeMaxValue = math.unit( mw.calculators.getValueString( doseValue.volume.max ) );
if( volumeMinValue.formatUnits() !== volumeMaxValue.formatUnits() ) {
// If the units between min and max don't match, show both
volumeHtml += mw.calculators.getValueString( volumeMinValue );
} else {
volumeHtml += mw.calculators.getValueNumber( volumeMinValue );
}
volumeHtml += dash;
volumeHtml += mw.calculators.getValueString( doseValue.volume.max );
}
if( volumeHtml ) {
if( administration && ! administrationDisplayed ) {
volumeHtml += ' ' + administration;
administrationDisplayed = true;
}
if( calculation.value.preparation && !mw.calculators.isMobile() ) {
volumeHtml += ' of ' + String( calculation.value.preparation );
}
volumeHtml = $( '<li>' ).append( volumeHtml );
$doseList.append( volumeHtml );
hasVolume = true;
}
$doseData.append( $doseList );
}
$dose.append( $doseData );
if( calculation.hasInfo() ) {
$dose.append( calculation.getInfoButton( calculationCount ) );
}
}
// Options column
var $options = $( '<div>', {
id: calculation.getContainerId() + '-options',
class: 'col-5 ' + calculation.getElementClasses( 'options' )
} );
var optionsRowClass = 'row no-gutters align-items-center';
if( !mw.calculators.isMobile() ) {
optionsRowClass += ' mb-2';
}
var optionLabelClass = mw.calculators.isMobile() ? 'col-4' : 'col-3';
var optionValueClass = mw.calculators.isMobile() ? 'col-8' : 'col-9';
var indications = calculation.drug.getIndications();
if( indications.length ) {
var indicationVariable = mw.calculators.getVariable( calculation.getVariableIds().indication );
$options
.append( $( '<div>', {
class: optionsRowClass
} )
.append(
$( '<div>', {
class: optionLabelClass,
html: indicationVariable.getLabelString() + ' '
} ),
$( '<div>', {
class: optionValueClass
} )
.append( indicationVariable.createInput({
class: 'calculator-container-input-DrugDosageCalculator-options',
hideLabel: true,
inline: true
} ) ) ) );
}
var routes = calculation.drug.getRoutes();
if( routes.length ) {
var routeVariable = mw.calculators.getVariable( calculation.getVariableIds().route );
$options
.append( $( '<div>', {
class: optionsRowClass
} )
.append(
$( '<div>', {
class: optionLabelClass,
html: routeVariable.getLabelString() + ' '
} ),
$( '<div>', {
class: optionValueClass
} )
.append( routeVariable.createInput({
class: 'calculator-container-input-DrugDosageCalculator-options',
hideLabel: true,
inline: true
} ) ) ) );
}
// Don't show preparations if there isn't a dose with volume
if( hasVolume ) {
var preparations = calculation.drug.getPreparations();
if( preparations.length ) {
var preparationVariable = mw.calculators.getVariable( calculation.getVariableIds().preparation );
$options
.append( $( '<div>', {
class: optionsRowClass
} )
.append(
$( '<div>', {
class: optionLabelClass,
html: preparationVariable.getLabelString() + ' '
} ),
$( '<div>', {
class: optionValueClass
} )
.append( preparationVariable.createInput({
class: 'calculator-container-input-DrugDosageCalculator-options',
hideLabel: true,
inline: true
} ) ) ) );
}
}
elements.dosage.$container.append( $dose, $options );
// Add elements to the contains array
elements.dosage.contains.push( $dose, $options );
// Iterate over elementTypes since it is in order of rendering
for( var iElementType in elementTypes ) {
var elementType = elementTypes[ iElementType ];
var element = elements[ elementType ];
var $existingContainer = $( '#' + element.id );
if( $existingContainer.length ) {
// If an input within this container has focus (i.e. the user changed a variable input which
// triggered this rerender), don't rerender the element as this would destroy the focus on
// the input.
if( !$.contains( $existingContainer[ 0 ], $( ':focus' )[ 0 ] ) ) {
$existingContainer.replaceWith( element.$container );
} else {
for( var containedElementId in element.contains ) {
var $containedElement = element.contains[ containedElementId ];
var $existingContainedContainer = $( '#' + $containedElement.attr( 'id' ) );
if( $existingContainedContainer.length ) {
if( !$.contains( $existingContainedContainer[ 0 ], $( ':focus' )[ 0 ] ) ) {
$existingContainedContainer.replaceWith( $containedElement );
}
}
}
}
} else {
$( this ).append( elements[ elementType ].$container );
}
}
calculationCount++;
} );
// Activate popovers
$( '[data-toggle="popover"]' ).popover();
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getCalculationData = function() {
var inputData = new mw.calculators.objectClasses.CalculationData();
// Add variables created by this calculation
var variableIds = this.getVariableIds();
for( var variableType in variableIds ) {
inputData.variables.optional.push( variableIds[ variableType ] );
}
var dataTypes = inputData.getDataTypes();
// Data is only actually required if it is required by every dosage for the drug.
// Data marked as required by an individual dosage that does not appear in every
// dosage will be converted to optional.
var requiredInputData = new mw.calculators.objectClasses.CalculationData();
// Need a way to tell the first iteration of the loop to initialize the required variables to a value that
// is distinct from the empty array (populated across loop using array intersect, so could become [] and shouldn't
// reinitialize).
var initializeRequiredData = true;
// Iterate through each dosage to determine variable dependency
for( var iDosage in this.drug.dosages ) {
var dosageInputData = this.drug.dosages[ iDosage ].getCalculationData();
inputData = inputData.merge( dosageInputData );
for( var iDataType in dataTypes ) {
var dataType = dataTypes[ iDataType ];
if( initializeRequiredData ) {
requiredInputData[ dataType ].required = inputData[ dataType ].required;
} else {
// Data is only truly required if it is required by all dosage calculations, so use array intersection
requiredInputData[ dataType ].required = requiredInputData[ dataType ].required.filter( function( index ) {
return dosageInputData[ dataType ].required.indexOf( index ) !== -1;
} );
}
}
initializeRequiredData = false;
}
for( var iDataType in dataTypes ) {
var dataType = dataTypes[ iDataType ];
// Move any data marked required in inputData to optional if it not actually required (i.e. doesn't appear
// in requiredInputData).
inputData[ dataType ].optional = inputData[ dataType ].optional.concat( inputData[ dataType ].required.filter( function( index ) {
return requiredInputData[ dataType ].required.indexOf( index ) === -1;
} ) ).filter( mw.calculators.uniqueValues );
inputData[ dataType ].required = requiredInputData[ dataType ].required;
}
return inputData;
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getCalculationDataValues = function() {
var data = mw.calculators.objectClasses.AbstractCalculation.prototype.getCalculationDataValues.call( this );
data.drug = this.drug;
data.indication = data[ this.getVariablePrefix() + 'indication' ] !== null ?
mw.calculators.getDrugIndication( mw.calculators.getVariable( this.getVariableIds().indication ).getValue() ) :
null;
delete data[ this.getVariablePrefix() + 'indication' ];
data.preparation = data[ this.getVariablePrefix() + 'preparation' ] !== null ?
this.drug.preparations[ mw.calculators.getVariable( this.getVariableIds().preparation ).getValue() ] :
null;
delete data[ this.getVariablePrefix() + 'preparation' ];
data.route = data[ this.getVariablePrefix() + 'route' ] !== null ?
mw.calculators.getDrugRoute( mw.calculators.getVariable( this.getVariableIds().route ).getValue() ) :
null;
delete data[ this.getVariablePrefix() + 'route' ];
return data;
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getClassName = function() {
return 'DrugDosageCalculation';
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getDescription = function() {
var description = this.drug.description ? this.drug.description : '';
if( this.activeDosageId !== null && this.drug.dosages[ this.activeDosageId ].description ) {
description += description ? '<br/><br/>' : '';
description += this.drug.dosages[ this.activeDosageId ].description;
}
return description;
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getInfoButton = function( infoCount ) {
var infoContainerId = this.getContainerId() + '-info';
if( infoCount ) {
infoContainerId += '-' + infoCount;
}
var infoString = 'More information';
infoString += !mw.calculators.isMobile() ? ' about this dose' : '';
return $( '<div>', {
class: this.getElementClasses( 'infoButton' )
} )
.append( $( '<a>', {
'data-toggle': 'collapse',
href: '#' + infoContainerId,
role: 'button',
'aria-expanded': 'false',
'aria-controls': infoContainerId
} )
.append( $( '<i>', {
class: 'far fa-question-circle'
} ), ' ' + infoString ) );
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getProperties = function() {
var inheritedProperties = mw.calculators.objectClasses.AbstractCalculation.prototype.getProperties();
return this.mergeProperties( inheritedProperties, {
required: [
'drug'
],
optional: []
} );
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getReferences = function() {
var references = this.drug.references;
if( this.activeDosageId !== null && this.drug.dosages[ this.activeDosageId ].references.length ) {
references = references
.concat( this.drug.dosages[ this.activeDosageId ].references )
.filter( mw.calculators.uniqueValues );
}
return references;
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getSearchString = function() {
var searchString = this.drug.name + ' ' + this.drug.color.id;
var indications = this.drug.getIndications();
for( var iIndication in indications ) {
var indication = indications[ iIndication ];
searchString += ' ' + indication.name;
searchString += indication.abbreviation ? ' ' + indication.abbreviation : '';
}
searchString += this.drug.searchData ? ' ' + this.drug.searchData : '';
return searchString.trim();
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getTitleHtml = function() {
var $title = $( '<a>', {
class: this.getElementClasses( 'title-name' ),
href: mw.util.getUrl( this.drug.name ),
text: this.getTitleString()
} ).css( 'background-color', '#fff' );
var highlightColor = this.drug.color.getHighlightColor();
if( highlightColor ) {
var highlightContainerAttributes = {
class: this.getElementClasses( 'title-highlight' )
};
var highlightContainerCss = {};
highlightContainerCss[ 'background' ] = highlightColor;
$title = $( '<span>', highlightContainerAttributes ).append( $title ).css( highlightContainerCss );
}
var primaryColor = this.drug.color.getPrimaryColor();
if( primaryColor ) {
var backgroundContainerAttributes = {
class: this.getElementClasses( 'title-background' )
};
var backgroundContainerCss = {};
if( this.drug.color.isStriped() ) {
backgroundContainerCss[ 'background' ] = 'repeating-linear-gradient(135deg,rgba(0,0,0,0),rgba(0,0,0,0)10px,rgba(255,255,255,1)10px,rgba(255,255,255,1)20px),' + primaryColor;
} else {
backgroundContainerCss[ 'background'] = primaryColor;
}
$title = $( '<span>', backgroundContainerAttributes ).append( $title ).css( backgroundContainerCss );
}
return $title;
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getTitleString = function() {
return this.drug ? this.drug.name : '';
}
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getVariableIds = function() {
return {
indication: this.getVariablePrefix() + 'indication',
preparation: this.getVariablePrefix() + 'preparation',
route: this.getVariablePrefix() + 'route'
};
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getVariableOptions = function( variableId ) {
if( variableId === this.getVariablePrefix() + 'indication' ) {
return this.drug.getIndications();
} else if( variableId === this.getVariablePrefix() + 'preparation' ) {
// Exclude preparations which require dilution
return this.drug.getPreparations( true );
} else if( variableId === this.getVariablePrefix() + 'route' ) {
return this.drug.getRoutes();
}
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.getVariablePrefix = function() {
return this.drug.id + '-';
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.initialize = function() {
if( typeof this.drug === 'string' ) {
var drug = mw.calculators.getDrug( this.drug );
if( !drug ) {
throw new Error( 'DrugDosage references drug "' + this.drug + '" which is not defined' );
}
this.drug = drug;
}
this.activeDosageId = null;
this.updateVariables();
mw.calculators.objectClasses.AbstractCalculation.prototype.initialize.call( this );
};
mw.calculators.objectClasses.DrugDosageCalculation.prototype.updateVariables = function() {
var variableIds = this.getVariableIds();
for( var variableType in variableIds ) {
var variableId = variableIds[ variableType ];
var variableOptions = this.getVariableOptions( variableId );
var variableOptionValues = {};
var defaultOption = 0;
for( var iVariableOption in variableOptions ) {
var variableOption = variableOptions[ iVariableOption ];
defaultOption = variableOption.default ? iVariableOption : defaultOption;
variableOptionValues[ variableOption.id ] = String( variableOption );
}
var defaultValue = variableOptions.length ? variableOptions[ defaultOption ].id : null;
var variable = mw.calculators.getVariable( variableId );
if( !variable ) {
var newVariable = {};
// TODO put this somewhere else
var abbreviation;
if( variableType === 'indication' ) {
abbreviation = 'Use';
} else if( variableType === 'route' ) {
abbreviation = 'Route';
} else if( variableType === 'preparation' ) {
abbreviation = 'Prep';
}
newVariable[ variableId ] = {
name: variableType.charAt(0).toUpperCase() + variableType.slice(1),
abbreviation: abbreviation,
type: 'string',
defaultValue: defaultValue,
options: variableOptionValues
};
mw.calculators.addVariables( newVariable );
} else {
// Probably not ideal to reach into the variable to change these things directly
// Perhaps add helper functions to variable class
mw.calculators.variables[ variableId ].defaultValue = defaultValue;
mw.calculators.variables[ variableId ].options = variableOptionValues;
}
}
};
mw.calculators.addDrugCalculators = function( moduleId, drugCalculatorData, className ) {
className = className ? className : 'DrugDosageCalculator';
for( var drugCalculatorId in drugCalculatorData ) {
drugCalculatorData[ drugCalculatorId ].module = moduleId;
for( var iCalculation in drugCalculatorData[ drugCalculatorId].calculations ) {
drugCalculatorData[ drugCalculatorId].calculations[ iCalculation ] = moduleId + '-' +
drugCalculatorData[ drugCalculatorId].calculations[ iCalculation ];
}
}
mw.calculators.addCalculators( moduleId, drugCalculatorData, className );
};
/**
* Class DrugDosageCalculator
* @param {Object} propertyValues
* @returns {mw.calculators.objectClasses.DrugDosageCalculator}
* @constructor
*/
mw.calculators.objectClasses.DrugDosageCalculator = function( propertyValues ) {
mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
};
mw.calculators.objectClasses.DrugDosageCalculator.prototype = Object.create( mw.calculators.objectClasses.AbstractCalculator.prototype );
mw.calculators.objectClasses.DrugDosageCalculator.prototype.getClassName = function() {
return 'DrugDosageCalculator';
};
}() );