Get data:
Infant DeathLow Birthweight at Full Term
Neonatal Death
Perinatal Death
Postneonatal Death
Preterm Birth
Sex Ratio
Total (Lifetime) Fertility
Very Low Birthweight
Very Preterm Birth
Data Stories
About Birth Outcomes
Birth Outcomes
About Birth Outcomes
Close to 125,000 live births occur in New York City (NYC) each year. Most babies are born healthy, but those born prematurely or with low birth weight are at greater risk of disability or death. This site tracks indicators of fetal growth and development, infant and perinatal mortality, fertility and sex ratio at birth.
Birth Outcomes and the Environment
Because many genetic and lifestyle factors influence growth and development of fetuses and babies, it can be difficult for researchers to study the effects of environmental exposures on birth outcomes. Smoking cigarettes during pregnancy, however, is known to result in exposure to many chemicals that can slow the growth of the fetus. Exposure to second-hand smoke can also be harmful. There is some evidence that prenatal exposure to air pollution (particulate matter and other pollutants), lead, pesticides and solvents increases the likelihood that a pregnancy results in an adverse outcome.
About the Data and Indicators
We restricted our data to births (and infant deaths) occurring in NYC to mothers whose usual residence is NYC. The mother’s usual residence is recorded on the baby’s birth certificate.
We use the physician’s clinical estimate of gestation to identify preterm births.
We use very low birth weight (< 3 lbs, 5 oz) as an indicator of preterm birth, because most very low birth weight babies are born preterm.
We use low birth weight (< 5 lbs, 8 oz) among pregnancies that reach term (at least 37 weeks) as an indicator of “growth retardation”. Restricting to term pregnancies removes the majority of low birth weight babies who are small because they were born preterm and did not have time to finish growing before birth.
Historically, the ratio of male to female births has been about 1.05. Some have hypothesized that exposure to certain chemicals in the environment can reduce the number of male births, so sex ratio may be a useful environmental public health indicator.
Total (lifetime) fertility rate is the expected number of births to a hypothetical cohort of 1,000 women experiencing the current age-specific birth rates among NYC women. Measures of childbirth are only crude indicators of fertility since the decision to have children is dependent on many behavioral and social customs.
Our tracking indicators differ from those presented by the NYC Bureau of Vital Statistics. For more information, click here. For a definition of terms, click on the glossary link below.
Having a Healthy Pregnancy
The following may increase the likelihood of a healthy pregnancy outcome:
- Pregnant women should seek prenatal care in the first trimester of pregnancy, eat a nutritious and balanced diet and take folic acid beginning before conception, avoid being over or underweight and work with their doctors to control diabetes, high-blood pressure and sexually transmitted infections.
- Health care providers should advise their patients about factors that affect birth outcomes, such as maternal smoking, drug and alcohol abuse, poor nutrition, stress, insufficient prenatal care, chronic illness or other medical problems.
- Damaged lead-containing paint in homes should be safely addressed by properly trained workers, ideally prior to pregnancy. Pregnant women and small children should stay out of the home until lead-paint projects are completed.
- Employers should provide workplaces free from unsafe chemical exposures and provide protective gear to workers when necessary. To learn more about the chemicals at work, employees can ask their employers for the Material Safety Data Sheets for the products used.
Key Messages
New York City has made considerable progress in reducing infant deaths. In the early 1990s, the rate was double what it is today, but the rate of decline has slowed in recent years. In lower income neighborhoods, infant mortality rates are almost double the citywide average rate.
The majority of infant deaths occur in the neonatal period (less than 28 days old).
Leading causes of infant death are birth defects, prematurity, low birth weight, cardiovascular disorders, and injury (including sudden infant death syndrome).
Over the past 10 years, about 8% of singleton births to NYC resident mothers have been preterm (less than 37 weeks of pregnancy); about 1.4% of singletons have been very preterm (less than 32 weeks of pregnancy).
Historically, the sex ratio of male to female births has been relatively constant at about 1.05, or 5% more males than females are born each year.


Ever been stuck in an unfamiliar area but want to find a brewery near you? Look no further!
Need to create a character really quickly because the game starts soon! The team I worked with has got you covered!
A note taker application that uses express.js to create, read, update and delete notes!
Unsure what to wear? Umbrella? Sunscreen? Dont worry about! Get the current weather and the next five days!
Need a secure customizable password of your choosing? Well look no further!


11:00AM Annual Knott (A) 5K Run Knott Hall End Time: 1:00PM Description: Knott Hall knows it's hard during midterms season, so they want you to RUN FOR YOUR LIVES! Come run a 4.9K (Knott a 5K!) around Mod Quad and beyond! Proceeds go towards St. Jude's Hospital. $5 per runner. Attendance: 122 GOING Tags: 5K, Knott Hall GO! 9:00AM Hesburgh Hackathon Hesburgh Library End Time: 12:00PM Description: Come Hack your way to a better student body! Come to the annual Hesuburgh Hackathon for code, food, fun, and prizes! Attendance: 67 GOING Tags: CSE, Engineering, Competition GO!
10:30AM Engineering Lunch and Munch with the Bunch Morris Inn End Time: 2:00PM Description: Engineers! The Engineering Council has organized a professor student luncheon. Please RSVP by emailing<EMAIL_ADDRESS>and come enjoy the food!. Attendance: 32 GOING Tags: food, Engineering GO!
12:00AM Eat for the Earth Notre Dame End Time: 11:59PM Description: Engineers! Engineering leads the future, so we encourage all engineers on Friday and Saturday to NOT EAT MEAT! Show off your pride as an innovator and pride as a human being, and Eat for the Earth! Hosted by the Engineering Council Attendance: 16 GOING Tags: food, Engineering GO! S 12:00AM Eat for the Earth Notre Dame End Time: 11:59PM Description: Engineers! Engineering leads the future, so we encourage all engineers on Friday and Saturday to NOT EAT MEAT! Show off your pride as an innovator and pride as a human being, and Eat for the Earth! Hosted by the Engineering Council Attendance: 16 GOING Tags: food, Engineering GO!
12:00AM Eat for the Earth Notre Dame End Time: 11:59PM Description: Engineers! Engineering leads the future, so we encourage all engineers on Friday and Saturday to NOT EAT MEAT! Show off your pride as an innovator and pride as a human being, and Eat for the Earth! Hosted by the Engineering Council Attendance: 16 GOING Tags: food, Engineering GO!


RecTagField
Other
RecTagFieldManifest
Other
Rt
game
rec
Server
records
recTag
Other
Immutable
Proxy
records
thrift
reply
MyServ$FinagleService


Rithmeieatgmail
I'm Rithm, I'm living with dad on a top of mountain
I love dog, and dream become a superman
I have been starting self study programing since 2014
I'm familiar with all layers of the software stack with strong focus on backend logic.
Personal projects
homepage of my blog


External version of Map module to support new Google Map v2 sdk
Obtain map API key from google. You can find instructions here: https://developers.google.com/maps/documentation/android/start#thegooglemapsapikey
Testing device needs to have Google Play installed. Otherwise map won't work. Add this to tiapp.xml - replace "API KEY HERE" with your API key.
<manifest>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES"/>
<permission android:name="com.map.permission.MAPS_RECEIVE" android:protectionLevel="signature"/>
<uses-feature android:glEsVersion="0x00020000" android:required="true"/>
<uses-permission android:name="com.map.permission.MAPS_RECEIVE"/>
<application>
<meta-data
android:name="com.google.android.maps.v2.API_KEY" android:value="API KEY HERE"/>
</application>
</manifest>
To access this module from JavaScript, you would do the following:
var map = require('ti.map');
View the change log for this module.
Please direct all questions, feedback, and concerns to<EMAIL_ADDRESS>Hieu Pham
Copyright(c) 2013 by Appcelerator, Inc. All Rights Reserved. Please see the LICENSE file included in the distribution for further details.


Goal: Keep hitting the blue ball with the white paddle, but be careful, it gets faster over time!
Failed to log in, please check your credentials


Click
the
tab.
and
.
skip the paywall.
Get full-text
of research papers as you browse, using Unpaywall's index of ten million
legal, open-access articles.


Wednesday (9/16/15) 11:00 AM - The End is Near
We’re almost at the end! The tension and anticipation is building .. what will our final projects be!? Will they be good? Will we impress?
This week is much better than last. My day off helped. I would go so far as to say my day off was mandatory for me to be functional now. The stressful commute is wearying and I’m looking forward to the day where I can have more power in my choice of environment.
We’ve got a female teacher on loan from SF. She’s fantastic, and I’m incredibly grateful to have a female role model. Thus far, I have not met a women I could relate to that is experienced in web development. And now I have :).
Today is spike day, where we get to play with all kinds of frameworks and gems.  We’ve had exposure to: Angular, Handlebars, Sass, ZURB Foundations, and others. This afternoon, we’ll dive into React.
This week the focus has been less on learning, and more on exploration. The pace is significantly less stressful. I’m sure I will appreciate the break once our projects begin and our collective stress meters travel, once again, into the red.
We did the DISC personality test in EE today. I’m an ‘I’, an “Influencer” and a “Spontaneous Creator”. It was super cool how we figured it out. We geolocated ourselves on an axis, then got feedback from everyone we’ve been working with regarding where we should stand. I was corrected from the driver (D) role to the spontaneous creator (I) role by my cohort. I loved getting this feedback. I’m super curious about how I come across to others, and now I know how I come across at DBC! Score!
We (me and the other spontaneous creator ‘I’ types) got the ‘flame’ metaphor - we have a lot of energy and inspiration to add to a team, but we need direction and we’re easily snuffed out. I’ve unfortunately got some firsthand experience of the snuffed out flame scenario. The good news is that I know now that I need a workplace and workmates that will let me be excited, or (even better) that will encourage me to be excited.
Something I learned today - when you find yourself too upset to be rational, take a deep breath, and then another deep breath, and if you can take enough deep breaths that you can put yourself in the other person’s shoes, you can connect much more easily as people.
TL;DR: in challenging moments, reach for empathy.
Saturday (9/19/15) 6:56 PM - Project Mayhem
We’re all so darn motivated, and I love it, and I’m scared that I won’t be able to find that outside of the DBC bubble.
I’m really enjoying working on this project. We’re doing interesting things with code & these are people that I enjoy working with. One of my worries for the future is that I won’t find good people once I leave here. There must be companies out there in the wild that would suit me. I’ll do my best to find one when the time comes.
Side note - waffle.io + github + slack makes for a seriously fantastic workflow. Also amazing - our project lead. Because she really knows what she’s about, we were able to get our harness set with a minimum of fuss or stress. Best project team I’ve ever been a part of.
Summary (6/6/16) - Where did the Time Go?
The final weeks were so busy that it didn’t leave much time for reflection. Here are my recollections and reflections, almost one year later:
- We had a four person team, we were working 12-14 hour days, constantly engaged in one task or another, sometimes pairing, sometimes solo.
- We did agile workflow to the max - when we weren’t coding we were scrumming. We had at least 3 standups per day to coordinate our efforts and reprioritize as necessary.
- I felt fully engaged in my work - inspired, energized, excited. I felt connected to my team, and it seemed like all of us cared equally as much that we create something beautiful and meaningful for our final demo.
- Our final demo was a massive success. We managed to create something beautiful, functional, clever, and technically impressive in less than 8 days. The pride I felt for what we accomplished surpassed the pride I felt in completing a multi-year university degree. I wasn’t only proud of myself - I felt equal, if not greater, pride for my team, and for my cohort at large. I felt immense gratitude for my teachers, for my mentors and coaches and councelors, and to the greater DBC institution.
I still miss the space, and every single person I worked with in NYC. I will never forget this experience because, in going through it, it became part of my identity. I am an NYC DBC boot camp graduate. I always will be.


Your total is: $
0
Transaction Name:
Transaction Amount:
Transaction Category:
Other
Entertainment
Household
Organization
Add Funds
Subtract Funds
Category Filter:
All
Other
Entertainment
Household
Organization
Date & Time
Transaction
Amount
Category
Total :
0


Jess DeHart
Jess is currently an Adjunct Assistant Professor at Suffolk County Community College where she teaches in the Fitness Specialist Program in the Physical Education Department. She spent 10 years as the Director of Personal Training for a national fitness franchise. Jess also teaches exercise classes for Strength for Life, a not-for-profit that offers free exercise classes for cancer patients and survivors to enhance their recovery process.
Jess was a varsity high school athlete where she played field hockey (all-county), basketball and ran track for all 4 years. In college she played rugby and continued to run and strength train as a way to stay fit and relieve stress. This love for fitness propelled her to become a personal trainer/run coach where she has coached/trained one to one, small group and online for all ages and abilities. From aspiring Olympic competitors who need to improve their running times to individuals who want to run their first running race, she has worked with a wide ranging clientele. She hopes to take all of her knowledge and experience to help individuals to reach their full potential.


{% extends "dashboard.html" %} {% set active_page = "stats" %} {% set page_title = "Settings" %} {% block head %} {% endblock %} {% block dashboard %}
{{ _("Since there is no registration we use the message signing system built into the QT wallet to prove you control the address. The basic process is:") }}
{{ _("By default if you do not have an address set for a merge mined coin it will automatically be converted to your account currency") }} ({{ user_currency }}).
{{ _("You may (optionally) set an address for any coin we mine and you'll be paid out your portion of that rather than exchanging it") }}
{{ _("Some merge mined coins can't be exchanged so you'll need to set an address for them or they'll be donated to the pool.") }}


---
layout: post
title: Run, You Fool, Run
date: '2011-01-01T13:09:00.000-06:00'
author: Jabell
tags:
- Family
- Running
- Health
modified_time: '2011-01-01T13:09:24.573-06:00'
blogger_id: tag:blogger.com,1999:blog-19739956.post-1356395073000344935
blogger_orig_url: http://theabellsix.blogspot.com/2011/01/run-you-fool-run.html
---
Wendy dragged me out of bed in summer and fall 2009 to start running. She had started four months earlier and part of what got me out of bed was guilt that she was running and I was not. Somehow, by God’s grace, I began to run more and more. Now, we run together. It is our joy to be together and neither of us like to run alone. It is good for our marriage, our bodies, and our souls.
2010 was the first calendar year of our running together. While I have a friend who ran over 1,700 miles in 2010, I am pleased to say that I ran 596.5 miles. If I had realized how close I was to 600, I would have pushed for 3.5 more. Oh, well. There is a parable about my life in those numbers.
Our goal for 2011 is at least 750 miles.
If you use Nike+ and I know you, let me know.


Roast.li is about bashing other people. Please don't name them. Just get rid of your opinion without harming anybody. This platform should provide you fun and joy. And most importantly, this shout be for everybody.
Found an problem? Report an issue
There will be a report opportunity in future to provide a good platform that doesn't harm anybody
You be able to leave any comment to assure, that you can provide your personal opinion to someone else's opinion


 Lick the plastic bag scratch the box so hide from vacuum cleaner so caticus cuteicus yet scream for no reason at 4 am.
Comments


Waveform navigation is performed by mouse movements, mouse clicks, and mouse wheel movements. It can take some getting used to. However with practice, users will quickly become more efficient in waveform navigation in comparison to navigating through traditional interfaces based on icons and scrollbars.
Pyclamp benefits substantially from the interactivity of Luke Campagnola’s PyQtGraph, which is a Python package that exploits the functionality of all three mouse buttons. This may make things tricky for users of Apple mice. Clicking while keeping the mouse motionless performs different functions depending on the button:
The other options in the context menu, seen after clicking the right mouse button, are not recommended. Note that the instead of using the middle button, a user may press the spacebar on the keyboard to toggle between concatenated and overlayed displays. Note that the waveform data is colour-coded according whether an episode occurs at the beginning (red) or end (blue) of a recording. While this is self-evident in the concatenated view, the colour code can be helpful in the overlayed view to detect gradual changes over time.
The mouse-wheel performs different navigation functions depending on the direction:
If a mouse is moved while a button is depressed, or ‘dragged’, the specific navigation performed depends on the button:
The effect of windowed-zoom performed by the left-drag is dependent on the direction:
Windows users may want to know that the ‘Meta’ key is in fact what is commonly called the ‘Windows’ key. Note that the ‘Meta’ and ‘Alt’ keys can be used to during all mouse movements to lock the y and x axes respectively. The only exception to this is if the left button is clicked with the mouse motionless, which performs a ‘view all’ navigation. It’s also possible to ‘select’ single events using the left mouse button. Multiple events can be selected by holding ‘Shift’ (or toggled using ‘Control’) before using left mouse button to drag a frame around the events you wish to select. There are also hotkeys for selection:
Finally, two keyboard buttons can be used to remove/return selected waveform episodes:
Apart from these keys, none of the operations described above actually change the waveform data. There a number of buttons towards the bottom screen, that allow the user to manipulate the waveform data, but note that these changes in no way affect the original wave data file.


#include <EOSProcess.h>
Public Member Functions | |
| EOSProcess (EOSLuaEnvironment *luaEnvPtr, EOSScriptManager *scriptManagerPtr, const char *processName, const char *scriptName) | |
| constructor | |
| ~EOSProcess () | |
| destructor | |
| bool | init () |
| executes "init" function from script | |
| bool | update () |
| executes "update" function from script | |
| bool | cleanup () |
| executes "cleanup" function from script | |
| void | processMessage (EOSMessage *message) |
| executes "processMessage" function from script | |
| bool | isActive () |
| returns the current activity status of this process | |
| bool | setActive (bool status) |
| sets the current activity status of this process | |
| bool | isGarbaged () |
| returns the current garbage status of this process | |
| void | garbage () |
| puts this process in "garbaged" status (a way to kill and deallocate it) | |
| bool | compileBuffer (unsigned char *bufferPtr, size_t bufferSize) |
| calls Lua compiler on Lua code stored in a memory buffer | |
| bool | selectScriptFunction (const char *functionName) |
| Selects a Lua Script function to call. | |
| void | addParam (int intValue) |
| loads integer parameter to the selected function | |
| void | addParam (float floatValue) |
| loads floating point parameter to the selected function | |
| void | addParam (char *string) |
| loads string parameter to the selected function | |
| bool | go (int nReturns=0) |
| Runs the loaded script. | |
| bool | scriptHasFunction (const char *functionName) |
| tests if the script contains a function with a given name | |
Protected Attributes | |
| EOSLuaEnvironment * | luaEnv |
| pointer to the Lua runtime environment | |
| int | luaThisRef |
| variable used to handle the "this" reference in scripts | |
| int | numArgs |
| counts the number of parameters loaded in the stack for the lua function | |
| const char * | currSelectedFuncName |
| contains the name of the current Lua function to call | |
| std::string | scriptName |
| contains the name of this script | |
Private Member Functions | |
| void | pushProcessName () |
| puts this process name in the Lua environment, under "this.processName" | |
| void | clearProcessName () |
| clears "this.processName" variable in the Lua environment | |
Private Attributes | |
| char | luaChunk [MAXCHUNKLENGTH+1] |
| holds a temporary lua source buffer | |
| const char * | thisProcessName |
| holds the name of this process | |
| bool | active |
| holds the current activity status of this process | |
| bool | valid |
| used to trace internally the validity of this process | |
| bool | initialized |
| used to trace internally the initialization status of this process | |
| bool | garbaged |
| holds the current "garbage" status of this process | |
| EOSScriptManager * | scriptManager |
| pointer to the ScriptManager class |
Many processes can share the same script source.
| EOSProcess::EOSProcess | ( | EOSLuaEnvironment * | luaEnvPtr, | |
| EOSScriptManager * | scriptManagerPtr, | |||
| const char * | processName, | |||
| const char * | scriptName | |||
| ) | [inline] |
constructor
| EOSProcess::~EOSProcess | ( | ) | [inline] |
destructor
| bool EOSProcess::init | ( | ) | [inline] |
executes "init" function from script
| bool EOSProcess::update | ( | ) | [inline] |
executes "update" function from script
| bool EOSProcess::cleanup | ( | ) | [inline] |
executes "cleanup" function from script
| void EOSProcess::processMessage | ( | EOSMessage * | message | ) |
executes "processMessage" function from script
| bool EOSProcess::isActive | ( | ) | [inline] |
returns the current activity status of this process
| bool EOSProcess::setActive | ( | bool | status | ) |
sets the current activity status of this process
| bool EOSProcess::isGarbaged | ( | ) | [inline] |
returns the current garbage status of this process
| void EOSProcess::garbage | ( | ) | [inline] |
puts this process in "garbaged" status (a way to kill and deallocate it)
| void EOSProcess::pushProcessName | ( | ) | [private] |
puts this process name in the Lua environment, under "this.processName"
| void EOSProcess::clearProcessName | ( | ) | [private] |
clears "this.processName" variable in the Lua environment
| bool EOSLuaScript::compileBuffer | ( | unsigned char * | bufferPtr, | |
| size_t | bufferSize | |||
| ) | [inherited] |
calls Lua compiler on Lua code stored in a memory buffer
| bool EOSLuaScript::selectScriptFunction | ( | const char * | functionName | ) | [inherited] |
Selects a Lua Script function to call.
| void EOSLuaScript::addParam | ( | int | intValue | ) | [inherited] |
loads integer parameter to the selected function
| void EOSLuaScript::addParam | ( | float | floatValue | ) | [inherited] |
loads floating point parameter to the selected function
| void EOSLuaScript::addParam | ( | char * | string | ) | [inherited] |
loads string parameter to the selected function
| bool EOSLuaScript::go | ( | int | nReturns = 0 |
) | [inherited] |
Runs the loaded script.
| bool EOSLuaScript::scriptHasFunction | ( | const char * | functionName | ) | [inherited] |
tests if the script contains a function with a given name
char EOSProcess::luaChunk[MAXCHUNKLENGTH+1] [private] |
holds a temporary lua source buffer
const char* EOSProcess::thisProcessName [private] |
holds the name of this process
bool EOSProcess::active [private] |
holds the current activity status of this process
bool EOSProcess::valid [private] |
used to trace internally the validity of this process
bool EOSProcess::initialized [private] |
used to trace internally the initialization status of this process
bool EOSProcess::garbaged [private] |
holds the current "garbage" status of this process
EOSScriptManager* EOSProcess::scriptManager [private] |
pointer to the ScriptManager class
EOSLuaEnvironment* EOSLuaScript::luaEnv [protected, inherited] |
pointer to the Lua runtime environment
int EOSLuaScript::luaThisRef [protected, inherited] |
variable used to handle the "this" reference in scripts
int EOSLuaScript::numArgs [protected, inherited] |
counts the number of parameters loaded in the stack for the lua function
const char* EOSLuaScript::currSelectedFuncName [protected, inherited] |
contains the name of the current Lua function to call
std::string EOSLuaScript::scriptName [protected, inherited] |
contains the name of this script


Left Arrow and Right Arrow turn the syringe.
Up Arrow applies thrust.
Space bar INJECTS
Connect a gamepad and JUICE like a pro!


midsole gel model {border-style Figure design optimization px;} #ffffff;} stress plantar element impact pressure footwear running Biomechanics finite shoe considered pad developing provided results analysis cushioning foot px; {font-family Engineering dynamic experimental font-size heel material max modelling optimized position study volume Medicine Sports conditions double; energy function loading mesh pads provide significantly situ stability terms ./j.jbiomech... Despite Running Science absorption border-color border-width boundary effect elastic new properties solid; stance use using {font-style {font-weight Bionics Chen EVA Footwear advanced and/or approach article aspect bold conceptual courier; different em; evolutionary examined gait geometry grid here, improvements initial insight insole kPa limited midsole's models nonlinear presented pt;} shoes strain strike structure studies study, suggest support values vital


{% extends 'base.html' %}
{% block title %}
{% include "includes/title.html" %}
{% endblock title %}
{% block sidebar_outer %}
{% include "includes/sidebar_container.html" %}
{% endblock sidebar_outer %}
{% block breadcrumbs_outer %}
{% include "includes/breadcrumbs.html" %}
{% endblock breadcrumbs_outer %}


public interface TaxonomyReader extends Closeable
A TaxonomyReader holds a list of categories. Each category has a serial number which we call an "ordinal", and a hierarchical "path" name:
An implementation must allow multiple readers to be active concurrently with a single writer. Readers follow so-called "point in time" semantics, i.e., a TaxonomyReader object will only see taxonomy entries which were available at the time it was created. What the writer writes is only available to (new) readers after the writer's commit() is called.
In faceted search, two separate indices are used: the main Lucene index, and the taxonomy. Because the main index refers to the categories listed in the taxonomy, it is important to open the taxonomy *after* opening the main index, and it is also necessary to reopen() the taxonomy after reopen()ing the main index.
This order is important, otherwise it would be possible for the main index to refer to a category which is not yet visible in the old snapshot of the taxonomy. Note that it is indeed fine for the the taxonomy to be opened after the main index - even a long time after. The reason is that once a category is added to the taxonomy, it can never be changed or deleted, so there is no danger that a "too new" taxonomy not being consistent with an older index.
| Modifier and Type | Interface and Description |
|---|---|
static interface
|
TaxonomyReader.ChildrenArrays
Equivalent representations of the taxonomy's parent info,
used internally for efficient computation of facet results:
"youngest child" and "oldest sibling"
|
| Modifier and Type | Field and Description |
|---|---|
static int
|
INVALID_ORDINAL
Ordinals are always non-negative, so a negative ordinal can be used to
signify an error.
|
static int
|
ROOT_ORDINAL
The root category (the category with the empty path) always has the
ordinal 0, to which we give a name ROOT_ORDINAL.
|
| Modifier and Type | Method and Description |
|---|---|
void
|
decRef
()
Expert: decreases the refCount of this TaxonomyReader instance.
|
TaxonomyReader.ChildrenArrays
|
getChildrenArrays
()
getChildrenArrays() returns a
TaxonomyReader.ChildrenArrays
object which can
be used together to efficiently enumerate the children of any category.
|
Map
<
String
,
String
>
|
getCommitUserData
()
Retrieve user committed data.
|
int
|
getOrdinal
(
CategoryPath
categoryPath)
getOrdinal() returns the ordinal of the category given as a path.
|
int
|
getParent
(int ordinal)
getParent() returns the ordinal of the parent category of the category
with the given ordinal.
|
int[]
|
getParentArray
()
getParentArray() returns an int array of size getSize() listing the
ordinal of the parent category of each category in the taxonomy.
|
CategoryPath
|
getPath
(int ordinal)
getPath() returns the path name of the category with the given
ordinal.
|
boolean
|
getPath
(int ordinal,
CategoryPath
result)
getPath() returns the path name of the category with the given
ordinal.
|
int
|
getRefCount
()
Expert: returns the current refCount for this taxonomy reader
|
int
|
getSize
()
getSize() returns the number of categories in the taxonomy.
|
void
|
incRef
()
Expert: increments the refCount of this TaxonomyReader instance.
|
boolean
|
refresh
()
refresh() re-reads the taxonomy information if there were any changes to
the taxonomy since this instance was opened or last refreshed.
|
static final int ROOT_ORDINAL
static final int INVALID_ORDINAL
int getOrdinal( CategoryPath categoryPath) throws IOException
If the given category wasn't found in the taxonomy, INVALID_ORDINAL is returned.
IOException
CategoryPath getPath(int ordinal) throws IOException
getPath(int, CategoryPath)
.
A null is returned if a category with the given ordinal does not exist.
IOException
boolean getPath(int ordinal, CategoryPath result) throws IOException
If a category with the given ordinal does not exist, the given
CategoryPath object is not modified, and the method returns
false
. Otherwise, the method returns
true
.
IOException
boolean refresh() throws IOException , InconsistentTaxonomyException
If there were no changes since this instance was opened or last refreshed, then this call does nothing. Note, however, that this is still a relatively slow method (as it needs to verify whether there have been any changes on disk to the taxonomy), so it should not be called too often needlessly. In faceted search, the taxonomy reader's refresh() should be called only after a reopen() of the main index.
Refreshing the taxonomy might fail in some cases, for example
if the taxonomy was recreated since this instance was opened or last refreshed.
In this case an
InconsistentTaxonomyException
is thrown,
suggesting that in order to obtain up-to-date taxonomy data a new
TaxonomyReader
should be opened. Note: This
TaxonomyReader
instance remains unchanged and usable in this case, and the application can
continue to use it, and should still
Closeable.close()
when no longer needed.
It should be noted that refresh() is similar in purpose to IndexReader.reopen(), but the two methods behave differently. refresh() refreshes the existing TaxonomyReader object, rather than opening a new one in addition to the old one as reopen() does. The reason is that in a taxonomy, one can only add new categories and cannot modify or delete existing categories; Therefore, there is no reason to keep an old snapshot of the taxonomy open - refreshing the taxonomy to the newest data and using this new snapshots in all threads (whether new or old) is fine. This saves us needing to keep multiple copies of the taxonomy open in memory.
IOException
InconsistentTaxonomyException
int getParent(int ordinal) throws IOException
When a category is specified as a path name, finding the path of its parent is as trivial as dropping the last component of the path. getParent() is functionally equivalent to calling getPath() on the given ordinal, dropping the last component of the path, and then calling getOrdinal() to get an ordinal back. However, implementations are expected to provide a much more efficient implementation:
getParent() should be a very quick method, as it is used during the facet aggregation process in faceted search. Implementations will most likely want to serve replies to this method from a pre-filled cache.
If the given ordinal is the ROOT_ORDINAL, an INVALID_ORDINAL is returned. If the given ordinal is a top-level category, the ROOT_ORDINAL is returned. If an invalid ordinal is given (negative or beyond the last available ordinal), an ArrayIndexOutOfBoundsException is thrown. However, it is expected that getParent will only be called for ordinals which are already known to be in the taxonomy.
IOException
int[] getParentArray() throws IOException
The caller can hold on to the array it got indefinitely - it is guaranteed that no-one else will modify it. The other side of the same coin is that the caller must treat the array it got as read-only and not modify it , because other callers might have gotten the same array too (and getParent() calls might be answered from the same array).
If you use getParentArray() instead of getParent(), remember that the array you got is (naturally) not modified after a refresh(), so you should always call getParentArray() again after a refresh().
This method's function is similar to allocating an array of size getSize() and filling it with getParent() calls, but implementations are encouraged to implement it much more efficiently, with O(1) complexity. This can be done, for example, by the implementation already keeping the parents in an array, and just returning this array (without any allocation or copying) when requested.
IOException
TaxonomyReader.ChildrenArrays getChildrenArrays()
TaxonomyReader.ChildrenArrays
object which can
be used together to efficiently enumerate the children of any category.
The caller can hold on to the object it got indefinitely - it is guaranteed that no-one else will modify it. The other side of the same coin is that the caller must treat the object which it got (and the arrays it contains) as read-only and not modify it , because other callers might have gotten the same object too.
Implementations should have O(getSize()) time for the first call or after a refresh(), but O(1) time for further calls. In neither case there should be a need to read new data from disk. These guarantees are most likely achieved by calculating this object (based on the getParentArray()) when first needed, and later (if the taxonomy was not refreshed) returning the same object (without any allocation or copying) when requested.
The reason we have one method returning one object, rather than two methods returning two arrays, is to avoid race conditions in a multi- threaded application: We want to avoid the possibility of returning one new array and one old array, as those could not be used together.
Map < String , String > getCommitUserData() throws IOException
IOException
TwoPhaseCommit.commit(Map)
void incRef()
void decRef() throws IOException
IOException
int getRefCount()
int getSize()
Because categories are numbered consecutively starting with 0, it means the taxonomy contains ordinals 0 through getSize()-1.
Note that the number returned by getSize() is often slightly higher than the number of categories inserted into the taxonomy; This is because when a category is added to the taxonomy, its ancestors are also added automatically (including the root, which always get ordinal 0).


menu
Fow Cube
Sign out
Sign-out
account_circle
Sign-in with Google
Card...
account_circle
Send
image


3D - LAB
3·D Experiments based on WebGL and ThreeJS
Graph 3D
View repository
Show demo
Earth 3D
View repository
Show demo
Globe 3D
View repository
Show demo
Physics example
View repository
Show demo


| 2023-02-16 17.35 EET |
Report received.
title: Stored XSS vulnerability in rename functionality
product: WeKan (Open-Source kanban)
vulnerable version: <=6.74
fixed version:
CVE number:
impact: Medium
homepage: https://wekan.github.io
found: 2022-12-30
by: Heiner Liesegang (Office Berlin)
SEC Consult Vulnerability Lab
An integrated part of SEC Consult, an Atos company
Europe | Asia | North America
https://www.sec-consult.com
Vendor description:
-------------------
WeKan ® is an completely Open Source and Free software collaborative
kanban board application with MIT license.
Whether you’re maintaining a personal todo list,
planning your holidays with some friends,
or working in a team on your next revolutionary idea, Kanban boards
are an unbeatable tool to keep your things organized.
They give you a visual overview of the current state of your project,
and make you productive by allowing you to focus on the few items that
matter the most.
Source: https://github.com/wekan/wekan
Business recommendation:
------------------------
Patch the application with the latest update supplied by the vendor.
Vulnerability overview/description:
-----------------------------------
1) Stored Cross-Site Scripting
An authenticated attacker with the role 'BoardAdmin' is able to rename
file attachments of Kanban cards. Being an admin of the Wekan instance
is not required in order for this exploit to work, as any user can
obtain 'BoardAdmin' privileges by creating a new Kanban board.
The 'renameAttachment' method does not sanitise user input and allows
embedding XSS payloads in the specified filename. The stored XSS payload is
triggered by opening the attachment as the modified filename is displayed in
the header bar of the file preview.
Proof of concept:
-----------------
1) Stored Cross-Site Scripting
The following steps are necessary to exploit the vulnerability:
1. Log into the application with at least "user" privileges
2a. Open a Kanban board in which you have 'BoardAdmin' privileges
2b. Or, create a new Kanban board otherwise
3. Create a Kanban card if none exist
4. Open Kanban card to edit it
5. If there is no attachment in the card, upload one
6. Click on "Attachment Actions" under the attachment and select "Rename"
7. Include arbitrary XSS payload such as the following inside the filename:
"[script]alert('Stored XSS')[/script]" (where change [] to open close tags)
8. Select "Save" to embed the XSS payload
Any user with access to the board clicking on the attachment preview
triggers the stored XSS. In case the used Kanban board is set to "public"
any person with a link to the board can access the targeted card and
trigger the payload inside the attachments' filename.
Vulnerable / tested versions:
-----------------------------
The following versions have been tested to be vulnerable:
* v6.64
* v6.69
* v6.71
TBD: According to the vendor, all previous versions are affected as well.
Vendor contact timeline:
------------------------
2023-02-16: Contacting vendor through email.
Solution:
---------
TBD: The vendor provides a patched version which should be installed immediately.
TBD: Link to vendor update & version information
Workaround:
-----------
None
Advisory URL:
-------------
https://sec-consult.com/vulnerability-lab/
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SEC Consult Vulnerability Lab
SEC Consult, an Atos company
Europe | Asia | North America
About SEC Consult Vulnerability Lab
The SEC Consult Vulnerability Lab is an integrated part of SEC Consult, an
Atos company. It ensures the continued knowledge gain of SEC Consult in the
field of network and application security to stay ahead of the attacker. The
SEC Consult Vulnerability Lab supports high-quality penetration testing and
the evaluation of new offensive and defensive technologies for our customers.
Hence our customers obtain the most current information about vulnerabilities
and valid recommendation about the risk profile of new technologies.
Web: https://www.sec-consult.com
Blog: http://blog.sec-consult.com
Twitter: https://twitter.com/sec_consult
EOF Heiner Liesegang / @2023
|