public static String toHumanTimePeriod(Context ctx, DateTime start, DateTime end) {
String result;
Resources res = ctx.getResources();
Period p = new Period(start, end);
if (p.getYears() == 0
&& p.getMonths() == 0
&& p.getWeeks() == 0
&& p.getDays() == 0
&& p.getHours() == 0
&& p.getMinutes() == 0) {
result = res.getQuantityString(R.plurals.seconds_ago, p.getSeconds(), p.getSeconds());
} else if (p.getYears() == 0
&& p.getMonths() == 0
&& p.getWeeks() == 0
&& p.getDays() == 0
&& p.getHours() == 0) {
result = res.getQuantityString(R.plurals.minutes_ago, p.getMinutes(), p.getMinutes());
} else if (p.getYears() == 0 && p.getMonths() == 0 && p.getWeeks() == 0 && p.getDays() == 0) {
result = res.getQuantityString(R.plurals.hours_ago, p.getHours(), p.getHours());
} else if (p.getYears() == 0 && p.getMonths() == 0 && p.getWeeks() == 0) {
result = res.getQuantityString(R.plurals.days_ago, p.getDays(), p.getDays());
} else {
result =
start
.toLocalDateTime()
.toString(DateTimeFormat.patternForStyle("M-", res.getConfiguration().locale));
}
return result;
}
private String epocToSimpleDate(long epoc) {
Period diff = new Period(epoc, System.currentTimeMillis(), PeriodType.standard());
PeriodType type;
if (diff.getMonths() > 0) {
type = PeriodType.yearMonthDay();
} else if (diff.getWeeks() > 0) {
type = PeriodType.yearWeekDay();
} else if (diff.getDays() > 0) {
type = PeriodType.dayTime().withSecondsRemoved().withMillisRemoved().withMinutesRemoved();
} else if (diff.getMinutes() > 0) {
type = PeriodType.time().withMillisRemoved().withSecondsRemoved();
} else {
type = PeriodType.time().withMillisRemoved();
}
return PeriodFormat.getDefault().print(new Period(epoc, System.currentTimeMillis(), type));
}
/**
* Adds adjustment to the shortest set time range in period. E.g. period("5 days 3 hours", 1) ->
* "5 days 4 hours". This will fall back to adjusting years if no field in the period is set.
*
* @param period The period to be adjusted
* @param adjustment The adjustment. Note that positive values will result in larger periods and
* an earlier time
* @return The adjusted period
*/
private Period adjust(final Period period, int adjustment) {
if (adjustment == 0) return period;
// Order is VERY important here
LinkedHashMap<Integer, DurationFieldType> map = new LinkedHashMap<>();
map.put(period.getSeconds(), DurationFieldType.seconds());
map.put(period.getMinutes(), DurationFieldType.minutes());
map.put(period.getHours(), DurationFieldType.hours());
map.put(period.getDays(), DurationFieldType.days());
map.put(period.getWeeks(), DurationFieldType.weeks());
map.put(period.getMonths(), DurationFieldType.months());
map.put(period.getYears(), DurationFieldType.years());
for (Map.Entry<Integer, DurationFieldType> entry : map.entrySet()) {
if (entry.getKey() > 0) {
return period.withFieldAdded(entry.getValue(), adjustment);
}
}
// Fall back to modifying years
return period.withFieldAdded(DurationFieldType.years(), adjustment);
}
@Override
protected void reduce(Text key, Iterable<Text> values, Context context)
throws IOException, InterruptedException {
Text temp = new Text();
DateTimeFormatter dtf = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);
WeekSpec ws = new WeekSpec();
int numberWeek = 0;
Date[] firstDayPeriod = new Date[48];
Date[] lastDayPeriod = new Date[48];
Date firstPeriod, lastPeriod;
// iniciar daqui
for (Text val : values) {
// String[] tokens = StringUtils.split(text.replaceAll("\"", ""), SEPERATOR);
// Deslocando alguns arquivos
String[] tokens = val.toString().split(",");
// Alterar para joda
DateTime st_time = dtf.parseDateTime(tokens[0]);
DateTime en_time = dtf.parseDateTime(tokens[1]);
// DateTime dateTime = new DateTime(date);
// Data de referencia da semana
// PROCESSO DE TRANSBORDO
// Transhipment process
ws.setReferenceDate(st_time.toDate());
// comparação se a data de término esta dentro da data da partição(Ultimo dia da semana)
// cria um novos registros
// quantas semanas devo duplicar
// A classe periodo do Joda esta co problema, temos que verificar se será utilizada
Period period = new Period(st_time, en_time);
numberWeek = period.getWeeks();
// System.out.println(numberWeek);
if (en_time.toDate().after(ws.getLastDate())) {
ws.setReferenceDate(st_time.toDate());
firstPeriod = st_time.toDate();
lastPeriod = ws.getLastDate();
for (int i = 0; i <= numberWeek; ++i) {
if (numberWeek != i) {
if (firstDayPeriod[i] == null) {
firstDayPeriod[i] = firstPeriod;
}
if (firstDayPeriod[i].after(firstPeriod)) {
firstDayPeriod[i] = firstPeriod;
}
if (lastDayPeriod[i] == null) {
lastDayPeriod[i] = lastPeriod;
}
if (lastDayPeriod[i].before(lastPeriod)) {
lastDayPeriod[i] = lastPeriod;
}
} else {
// tratamento o ultimo loop
if (firstDayPeriod[i] == null) {
firstDayPeriod[i] = firstPeriod;
}
if (firstDayPeriod[i].after(firstPeriod)) {
firstDayPeriod[i] = firstPeriod;
}
if (lastDayPeriod[i] == null) {
lastDayPeriod[i] = en_time.toDate();
}
if (lastDayPeriod[i].before(en_time.toDate())) {
lastDayPeriod[i] = en_time.toDate();
}
}
// Popula variaveis para o próximo loop
ws.setReferenceDate(ws.getFirstDayofNextWeek());
firstPeriod = ws.getFirstDate();
lastPeriod = ws.getLastDate();
}
} else {
// Logica do numero maior
// se a data do looping for menor que a do array
// atualiza o array
if (firstDayPeriod[0] == null) {
firstDayPeriod[0] = st_time.toDate();
}
if (firstDayPeriod[0].after(st_time.toDate())) {
firstDayPeriod[0] = st_time.toDate();
}
// se a data do looping for maior que a do array
// atualiza o array
if (lastDayPeriod[0] == null) {
lastDayPeriod[0] = en_time.toDate();
}
if (lastDayPeriod[0].before(en_time.toDate())) {
lastDayPeriod[0] = en_time.toDate();
}
}
// fim do processo de transbordo
}
String[] rawTokens = key.toString().split(",");
for (int i = 0; i <= firstDayPeriod.length; i++) {
if (firstDayPeriod[i] == null) {
break;
}
temp.set(
sdf1.format(firstDayPeriod[i])
+ ";"
+ sdf1.format(lastDayPeriod[i])
+ ";"
+ rawTokens[0]
+ ";"
+ rawTokens[1]
+ ";"
+ rawTokens[2]);
context.write(NullWritable.get(), temp);
}
}
@Override
public long truncate(long t) {
if (isCompound) {
try {
return truncateMillisPeriod(t);
} catch (UnsupportedOperationException e) {
return truncateCompoundPeriod(t);
}
}
final int years = period.getYears();
if (years > 0) {
if (years > 1 || hasOrigin) {
int y = chronology.years().getDifference(t, origin);
y -= y % years;
long tt = chronology.years().add(origin, y);
// always round down to the previous period (for timestamps prior to origin)
if (t < tt) t = chronology.years().add(tt, -years);
else t = tt;
return t;
} else {
return chronology.year().roundFloor(t);
}
}
final int months = period.getMonths();
if (months > 0) {
if (months > 1 || hasOrigin) {
int m = chronology.months().getDifference(t, origin);
m -= m % months;
long tt = chronology.months().add(origin, m);
// always round down to the previous period (for timestamps prior to origin)
if (t < tt) t = chronology.months().add(tt, -months);
else t = tt;
return t;
} else {
return chronology.monthOfYear().roundFloor(t);
}
}
final int weeks = period.getWeeks();
if (weeks > 0) {
if (weeks > 1 || hasOrigin) {
// align on multiples from origin
int w = chronology.weeks().getDifference(t, origin);
w -= w % weeks;
long tt = chronology.weeks().add(origin, w);
// always round down to the previous period (for timestamps prior to origin)
if (t < tt) t = chronology.weeks().add(tt, -weeks);
else t = tt;
return t;
} else {
t = chronology.dayOfWeek().roundFloor(t);
// default to Monday as beginning of the week
return chronology.dayOfWeek().set(t, 1);
}
}
final int days = period.getDays();
if (days > 0) {
if (days > 1 || hasOrigin) {
// align on multiples from origin
int d = chronology.days().getDifference(t, origin);
d -= d % days;
long tt = chronology.days().add(origin, d);
// always round down to the previous period (for timestamps prior to origin)
if (t < tt) t = chronology.days().add(tt, -days);
else t = tt;
return t;
} else {
t = chronology.hourOfDay().roundFloor(t);
return chronology.hourOfDay().set(t, 0);
}
}
final int hours = period.getHours();
if (hours > 0) {
if (hours > 1 || hasOrigin) {
// align on multiples from origin
long h = chronology.hours().getDifferenceAsLong(t, origin);
h -= h % hours;
long tt = chronology.hours().add(origin, h);
// always round down to the previous period (for timestamps prior to origin)
if (t < tt) t = chronology.hours().add(tt, -hours);
else t = tt;
return t;
} else {
t = chronology.minuteOfHour().roundFloor(t);
return chronology.minuteOfHour().set(t, 0);
}
}
final int minutes = period.getMinutes();
if (minutes > 0) {
// align on multiples from origin
if (minutes > 1 || hasOrigin) {
long m = chronology.minutes().getDifferenceAsLong(t, origin);
m -= m % minutes;
long tt = chronology.minutes().add(origin, m);
// always round down to the previous period (for timestamps prior to origin)
if (t < tt) t = chronology.minutes().add(tt, -minutes);
else t = tt;
return t;
} else {
t = chronology.secondOfMinute().roundFloor(t);
return chronology.secondOfMinute().set(t, 0);
}
}
final int seconds = period.getSeconds();
if (seconds > 0) {
// align on multiples from origin
if (seconds > 1 || hasOrigin) {
long s = chronology.seconds().getDifferenceAsLong(t, origin);
s -= s % seconds;
long tt = chronology.seconds().add(origin, s);
// always round down to the previous period (for timestamps prior to origin)
if (t < tt) t = chronology.seconds().add(tt, -seconds);
else t = tt;
return t;
} else {
return chronology.millisOfSecond().set(t, 0);
}
}
final int millis = period.getMillis();
if (millis > 0) {
if (millis > 1) {
long ms = chronology.millis().getDifferenceAsLong(t, origin);
ms -= ms % millis;
long tt = chronology.millis().add(origin, ms);
// always round down to the previous period (for timestamps prior to origin)
if (t < tt) t = chronology.millis().add(tt, -millis);
else t = tt;
return t;
} else {
return t;
}
}
return t;
}