How to use timestamp method in freezegun

Best Python code snippet using freezegun

UserDashboard.js

Source:UserDashboard.js Github

copy

Full Screen

1'use strict'2const Cache = use('Cache')3const AnnotationModel = use('App/Models/Annotation')4const StringHelper = use('App/Helpers/StringHelper')5const AnnotationCommentModel = use('App/Models/AnnotationComment')6const AnnotationRateModel = use('App/Models/AnnotationRate')7const AnnotationCommentRateModel = use('App/Models/AnnotationCommentRate')8const DatabaseHelper = use('App/Helpers/DatabaseHelper')9class UserDashboard {10 register(Model) {11 12 Model.prototype.getAnnotationsInStep = async function (webpage, start_timestamp, end_timestamp) {13 let cacheKey = Cache.key(`User.getAnnotationsInStep`, start_timestamp, end_timestamp)14 15 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {16 let query = AnnotationModel17 .query()18 .with('notes')19 .where('deleted', false)20 .whereNot('type', 'SectionMainIdea')21 .where('user_id', this.primaryKeyValue)22 .where('webpage_id', webpage.primaryKeyValue)23 if (typeof(start_timestamp) === 'number') {24 query.where('created_at_unixms', '>=', start_timestamp)25 }26 if (typeof(end_timestamp) === 'number') {27 query.where('created_at_unixms', '<=', end_timestamp)28 }29 let result = await query.fetch()30 return result.toJSON()31 })32 return output33 }34 35 Model.prototype.getSectionAnnotationsInStep = async function (webpage, start_timestamp, end_timestamp) {36 let cacheKey = Cache.key(`User.getSectionAnnotationsInStep`, start_timestamp, end_timestamp)37 38 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {39 let query = AnnotationModel40 .query()41 .with('notes')42 .with('anchorPositions')43 .where('deleted', false)44 .where('type', 'SectionMainIdea')45 .where('user_id', this.primaryKeyValue)46 .where('webpage_id', webpage.primaryKeyValue)47 if (typeof(start_timestamp) === 'number') {48 query.where('created_at_unixms', '>=', start_timestamp)49 }50 if (typeof(end_timestamp) === 'number') {51 query.where('created_at_unixms', '<=', end_timestamp)52 }53 let result = await query.fetch()54 return result.toJSON()55 })56 return output57 }58 59 Model.prototype.countAnnotations = async function (webpage, start_timestamp, end_timestamp) {60 let cacheKey = Cache.key(`User.countAnnotations`, start_timestamp, end_timestamp)61 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {62 let annotations = await this.getAnnotationsInStep(webpage, start_timestamp, end_timestamp)63 //console.log(annotations)64 return annotations.length65 })66 return output67 }68 69 Model.prototype.countAnnotationNoteWords = async function (webpage, start_timestamp, end_timestamp) {70 let cacheKey = Cache.key(`User.countAnnotationNoteWords`, start_timestamp, end_timestamp)71 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {72 let wordCount = 073 74 let annotations = await this.getAnnotationsInStep(webpage, start_timestamp, end_timestamp)75 //console.log(annotations.length)76 annotations.forEach((annotation) => {77 annotation.notes.forEach((note) => {78 let noteText = note.note79 noteText = StringHelper.htmlToText(noteText, true)80 wordCount = wordCount + StringHelper.countWords(noteText)81 })82 })83 84 return wordCount85 })86 return output87 }88 89 Model.prototype.countAnnotationTypes = async function (webpage, start_timestamp, end_timestamp) {90 let cacheKey = Cache.key(`User.countAnnotationTypes`, start_timestamp, end_timestamp)91 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {92 let types = {}93 94 let annotations = await this.getAnnotationsInStep(webpage, start_timestamp, end_timestamp)95 annotations.forEach((annotation) => {96 let type = annotation.type97 98 if (typeof(types[type]) !== 'number') {99 types[type] = 0100 }101 types[type]++102 })103 104 return types105 })106 return output107 }108 109 110 Model.prototype.getSectionNotes = async function (webpage, start_timestamp, end_timestamp) {111 let cacheKey = Cache.key(`User.getSectionNotes`, start_timestamp, end_timestamp)112 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {113 let notes = []114 115 let annotations = await this.getSectionAnnotationsInStep(webpage, start_timestamp, end_timestamp)116 annotations.forEach((annotation) => {117 let sectionID = annotation.anchorPositions[0].section_id118 notes[sectionID] = annotation.notes[0].note119 })120 121 return notes122 })123 return output124 }125 126 127 // -----------------------------------------128 129 Model.prototype.getCommentsInStep = async function (webpage, start_timestamp, end_timestamp) {130 let cacheKey = Cache.key(`User.getCommentsInStep`, start_timestamp, end_timestamp)131 132 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {133 let query = AnnotationCommentModel134 .query()135 .whereHas('annotation', (builder) => {136 builder.where('deleted', false)137 .where('webpage_id', webpage.primaryKeyValue)138 }, '>', 0)139 .with('annotation', (builder) => {140 builder.with('user')141 })142 .where('deleted', false)143 .where('user_id', this.primaryKeyValue)144 //.where('webpage_id', webpage.primaryKeyValue)145 if (typeof(start_timestamp) === 'number') {146 query.where('created_at_unixms', '>=', start_timestamp)147 }148 if (typeof(end_timestamp) === 'number') {149 query.where('created_at_unixms', '<=', end_timestamp)150 }151 let result = await query.fetch()152 let resultJSON = result.toJSON()153 154 resultJSON.sort((a, b) => {155 if (a.annotation.id !== b.annotation.id) {156 return a.annotation.id - b.annotation.id157 }158 })159 160 return resultJSON161 })162 return output163 }164 165 Model.prototype.getInteracts = async function (webpage, start_timestamp, end_timestamp) {166 let cacheKey = Cache.key(`User.getInteracts`, start_timestamp, end_timestamp)167 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {168 let interactTo = {}169 170 let initUser = (user) => {171 if (!interactTo[user.id]) {172 interactTo[user.id] = {173 avatar_url: user.avatar_url,174 name: user.display_name,175 count: 0,176 annotationIDList: []177 }178 }179 }180 181 // ----------------------------------------------182 183 let comments = await this.getCommentsInStep(webpage, start_timestamp, end_timestamp)184 185 let lastAnnotationID186 187 comments.forEach((comment) => {188 let annotationID = comment.annotation.id189 if (!lastAnnotationID || lastAnnotationID !== annotationID) {190 lastAnnotationID = annotationID191 }192 else {193 return false194 }195 196 //console.log(JSON.stringify(comment, null, 2))197 let user = comment.annotation.user198 199 initUser(user)200 if (interactTo[user.id].annotationIDList.indexOf(annotationID) === -1) {201 interactTo[user.id].count++202 interactTo[user.id].annotationIDList.push(annotationID)203 }204 })205 206 // ------------------------------------------207 208 let annotationRates = await this.getAnnotationRatesInStep(webpage, start_timestamp, end_timestamp)209 //console.log(annotationRates)210 annotationRates.forEach((rate) => {211 let user = rate.annotation.user212 let annotationID = rate.annotation.id213 initUser(user)214 if (interactTo[user.id].annotationIDList.indexOf(annotationID) === -1) {215 interactTo[user.id].count++216 interactTo[user.id].annotationIDList.push(annotationID)217 }218 })219 220 // ------------------------------------------221 222 let commentRates = await this.getAnnotationCommentRatesInStep(webpage, start_timestamp, end_timestamp)223 //console.log(commentRates)224 commentRates.forEach((rate) => {225 let user = rate.comment.user226 initUser(user)227 interactTo[user.id].count++228 })229 230 // ------------------------------------------231 232 return interactTo233 })234 return output235 }236 237 Model.prototype.getComments = async function (webpage, start_timestamp, end_timestamp) {238 let cacheKey = Cache.key(`User.getComments`, start_timestamp, end_timestamp)239 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {240 let commentTo = {}241 242 let comments = await this.getCommentsInStep(webpage, start_timestamp, end_timestamp)243 244 let lastAnnotationID245 246 comments.forEach((comment) => {247 let annotationID = comment.annotation.id248 if (!lastAnnotationID || annotationID !== comment.annotation.id) {249 lastAnnotationID = comment.annotation.id250 }251 else {252 return false253 }254 255 //console.log(JSON.stringify(comment, null, 2))256 let user = comment.annotation.user257 258 if (!commentTo[user.id]) {259 commentTo[user.id] = {260 avatar_url: user.avatar_url,261 name: user.display_name,262 count: 0263 }264 }265 commentTo[user.id].count++266 })267 268 return commentTo269 })270 return output271 }272 273 // -----------------------------------------274 275 Model.prototype.getCommentedInStep = async function (webpage, start_timestamp, end_timestamp) {276 let cacheKey = Cache.key(`User.getCommentedInStep`, start_timestamp, end_timestamp)277 278 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {279 let query = AnnotationCommentModel280 .query()281 .whereHas('annotation', (builder) => {282 builder.where('deleted', false)283 .where('user_id', this.primaryKeyValue)284 .where('webpage_id', webpage.primaryKeyValue)285 }, '>', 0)286 //.with('annotation', (builder) => {287 //builder.with('user')288 //})289 .with('user')290 .where('deleted', false)291 292 //.where('webpage_id', webpage.primaryKeyValue)293 if (typeof(start_timestamp) === 'number') {294 query.where('created_at_unixms', '>=', start_timestamp)295 }296 if (typeof(end_timestamp) === 'number') {297 query.where('created_at_unixms', '<=', end_timestamp)298 }299 let result = await query.fetch()300 let resultJSON = result.toJSON()301 302 resultJSON.sort((a, b) => {303 if (a.annotation.id !== b.annotation.id) {304 return a.annotation.id - b.annotation.id305 }306 })307 308 return resultJSON309 })310 return output311 }312 313 Model.prototype.getCommented = async function (webpage, start_timestamp, end_timestamp) {314 let cacheKey = Cache.key(`User.getCommented`, start_timestamp, end_timestamp)315 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {316 let output = {}317 318 let comments = await this.getCommentedInStep(webpage, start_timestamp, end_timestamp)319 comments.forEach((comment) => {320 //console.log(JSON.stringify(comment, null, 2))321 let user = comment.user322 323 if (!output[user.id]) {324 output[user.id] = {325 avatar_url: user.avatar_url,326 name: user.display_name,327 count: 0328 }329 }330 output[user.id].count++331 })332 333 return output334 })335 return output336 }337 338 // -----------------------------------------------------------------339 340 Model.prototype.getAnnotationRatesInStep = async function (webpage, start_timestamp, end_timestamp) {341 let cacheKey = Cache.key(`User.getAnnotationRatesInStep`, start_timestamp, end_timestamp)342 343 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {344 let query = AnnotationRateModel345 .query()346 .whereHas('annotation', (builder) => {347 builder.where('deleted', false)348 //.where('user_id', this.primaryKeyValue)349 .where('webpage_id', webpage.primaryKeyValue)350 }, '>', 0)351 .with('annotation', (builder) => {352 builder.with('user')353 })354 .where('user_id', this.primaryKeyValue)355 .where('deleted', false)356 //.select('EXTRACT(EPOCH FROM created_at) as created_at_unixms')357 358 //.where('webpage_id', webpage.primaryKeyValue)359 let startOffset = ((new Date()).getTimezoneOffset()) * 60 * 1000360 let endOffset = startOffset361 //console.log(start_timestamp)362 if (start_timestamp < 1588077090978) {363 // 對應程式錯誤 #507364 startOffset = ''365 }366 367 if (typeof(start_timestamp) === 'number') {368 query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ${startOffset}) >= ?`, [start_timestamp])369 //query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000) >= ?`, [start_timestamp])370 }371 if (typeof(end_timestamp) === 'number') {372 //query.where('EXTRACT(EPOCH FROM created_at)', '<=', end_timestamp)373 query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ${endOffset}) <= ?`, [end_timestamp])374 //query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000) <= ?`, [end_timestamp])375 }376 //DatabaseHelper.consoleSQL(query)377 let result = await query.fetch()378 return result.toJSON()379 })380 return output381 }382 383 Model.prototype.getAnnotationCommentRatesInStep = async function (webpage, start_timestamp, end_timestamp) {384 let cacheKey = Cache.key(`User.getAnnotationCommentRatesInStep`, start_timestamp, end_timestamp)385 386 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {387 let query = AnnotationCommentRateModel388 .query()389 .whereHas('comment', (builder) => {390 builder.where('deleted', false)391 //.where('user_id', this.primaryKeyValue)392 .whereHas('annotation', (builder) => {393 builder.where('webpage_id', webpage.primaryKeyValue)394 .where('deleted', false)395 }, '>', 0)396 }, '>', 0)397 .with('comment', (builder) => {398 builder.with('user')399 })400 .where('user_id', this.primaryKeyValue)401 .where('deleted', false)402 //.select('EXTRACT(EPOCH FROM created_at) as created_at_unixms')403 //.where('webpage_id', webpage.primaryKeyValue)404 let startOffset = ((new Date()).getTimezoneOffset()) * 60 * 1000405 let endOffset = startOffset406 //console.log(start_timestamp)407 if (start_timestamp < 1588077090978) {408 // 對應程式錯誤 #507409 startOffset = ''410 //endOffset = ''411 }412 //offset = offset * -1413 //offset = '+' + offset414 //console.log(this.display_name, startOffset, endOffset)415 416 if (typeof(start_timestamp) === 'number') {417 query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ${startOffset} ) >= ?`, [start_timestamp])418 //query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ) >= ?`, [start_timestamp])419 }420 if (typeof(end_timestamp) === 'number') {421 //query.where('EXTRACT(EPOCH FROM created_at)', '<=', end_timestamp)422 423 query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ${endOffset}) <= ?`, [end_timestamp])424 //query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000) <= ?`, [end_timestamp])425 }426 //DatabaseHelper.consoleSQL(query)427 let result = await query.fetch()428 return result.toJSON()429 })430 return output431 }432 433 Model.prototype.getRates = async function (webpage, start_timestamp, end_timestamp) {434 let cacheKey = Cache.key(`User.getRates`, start_timestamp, end_timestamp)435 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {436 let rates437 438 let annotationRates = {}439 let commentRates = {}440 441 rates = await this.getAnnotationRatesInStep(webpage, start_timestamp, end_timestamp)442 //console.log(rates.length)443 rates.forEach((rate) => {444 //console.log(JSON.stringify(comment, null, 2))445 let type = rate.type446 let user = rate.annotation.user447 448 if (!annotationRates[type]) {449 annotationRates[type] = {}450 }451 452 //console.log(type, user.id)453 454 if (!annotationRates[type][user.id]) {455 annotationRates[type][user.id] = {456 avatar_url: user.avatar_url,457 name: user.display_name,458 count: 0459 }460 }461 annotationRates[type][user.id].count++462 })463 //console.log(JSON.stringify(annotationRates, null, 2))464 465 // --------------------------------------------------------------466 467 rates = await this.getAnnotationCommentRatesInStep(webpage, start_timestamp, end_timestamp)468 rates.forEach((rate) => {469 //console.log(JSON.stringify(comment, null, 2))470 let type = rate.type471 let user = rate.comment.user472 let userID = user.id + ''473 474 if (!commentRates[type]) {475 commentRates[type] = {}476 }477 478 //console.log(type, userID)479 if (!commentRates[type][userID]) {480 commentRates[type][userID] = {481 avatar_url: user.avatar_url,482 name: user.display_name,483 count: 0484 }485 }486 commentRates[type][userID].count++487 })488 // --------------------------------------------------------------489 490 return {491 annotation: annotationRates,492 comment: commentRates493 }494 })495 return output496 }497 498 499 // -----------------------------------------------------------------500 501 Model.prototype.getAnnotationRatedInStep = async function (webpage, start_timestamp, end_timestamp) {502 let cacheKey = Cache.key(`User.getAnnotationRatedInStep`, start_timestamp, end_timestamp)503 504 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {505 let query = AnnotationRateModel506 .query()507 .whereHas('annotation', (builder) => {508 builder.where('deleted', false)509 .where('user_id', this.primaryKeyValue)510 .where('webpage_id', webpage.primaryKeyValue)511 }, '>', 0)512 //.with('annotation', (builder) => {513 // builder.with('user')514 //})515 .with('rater')516 //.where('user_id', this.primaryKeyValue)517 .where('deleted', false)518 //.select('EXTRACT(EPOCH FROM created_at) as created_at_unixms')519 520 //.where('webpage_id', webpage.primaryKeyValue)521 let offset = ((new Date()).getTimezoneOffset()) * 60 * 1000522 if (typeof(start_timestamp) === 'number') {523 query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ${offset}) >= ?`, [start_timestamp])524 }525 if (typeof(end_timestamp) === 'number') {526 //query.where('EXTRACT(EPOCH FROM created_at)', '<=', end_timestamp)527 query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ${offset}) <= ?`, [end_timestamp])528 }529 //DatabaseHelper.consoleSQL(query)530 let result = await query.fetch()531 return result.toJSON()532 })533 return output534 }535 536 Model.prototype.getAnnotationCommentRatedInStep = async function (webpage, start_timestamp, end_timestamp) {537 let cacheKey = Cache.key(`User.getAnnotationCommentRatedInStep`, start_timestamp, end_timestamp)538 539 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {540 let query = AnnotationCommentRateModel541 .query()542 .whereHas('comment', (builder) => {543 builder.where('deleted', false)544 .where('user_id', this.primaryKeyValue)545 .whereHas('annotation', (builder) => {546 builder.where('webpage_id', webpage.primaryKeyValue)547 }, '>', 0)548 }, '>', 0)549 //.with('comment', (builder) => {550 // builder.with('user')551 //})552 .where('user_id', this.primaryKeyValue)553 .with('user')554 .where('deleted', false)555 //.select('EXTRACT(EPOCH FROM created_at) as created_at_unixms')556 //.where('webpage_id', webpage.primaryKeyValue)557 let offset = ((new Date()).getTimezoneOffset()) * 60 * 1000558 if (typeof(start_timestamp) === 'number') {559 query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ${offset}) >= ?`, [start_timestamp])560 }561 if (typeof(end_timestamp) === 'number') {562 //query.where('EXTRACT(EPOCH FROM created_at)', '<=', end_timestamp)563 query.whereRaw(`(EXTRACT(EPOCH FROM created_at) * 1000 ${offset}) <= ?`, [end_timestamp])564 }565 let result = await query.fetch()566 return result.toJSON()567 })568 return output569 }570 571 Model.prototype.getRated = async function (webpage, start_timestamp, end_timestamp) {572 let cacheKey = Cache.key(`User.getRated`, start_timestamp, end_timestamp)573 let output = await Cache.rememberWait([webpage, this, 'User'], cacheKey, async () => {574 let rates575 576 let annotationRates = {}577 let commentRates = {}578 579 rates = await this.getAnnotationRatedInStep(webpage, start_timestamp, end_timestamp)580 //console.log(rates.length)581 rates.forEach((rate) => {582 //console.log(JSON.stringify(comment, null, 2))583 let type = rate.type584 let user = rate.rater585 586 if (!annotationRates[type]) {587 annotationRates[type] = {}588 }589 590 //console.log(type, user.id)591 592 if (!annotationRates[type][user.id]) {593 annotationRates[type][user.id] = {594 avatar_url: user.avatar_url,595 name: user.display_name,596 count: 0597 }598 }599 annotationRates[type][user.id].count++600 })601 //console.log(JSON.stringify(annotationRates, null, 2))602 603 // --------------------------------------------------------------604 605 rates = await this.getAnnotationCommentRatedInStep(webpage, start_timestamp, end_timestamp)606 rates.forEach((rate) => {607 //console.log(JSON.stringify(comment, null, 2))608 let type = rate.type609 let user = rate.user610 611 if (!commentRates[type]) {612 commentRates[type] = {}613 }614 615 if (!commentRates[type][user.id]) {616 commentRates[type][user.id] = {617 avatar_url: user.avatar_url,618 name: user.display_name,619 count: 0620 }621 }622 commentRates[type][user.id].count++623 })624 // --------------------------------------------------------------625 626 return {627 annotation: annotationRates,628 comment: commentRates629 }630 })631 return output632 }633 634 } // register (Model) {635}...

Full Screen

Full Screen

timestamp.js

Source:timestamp.js Github

copy

Full Screen

1// Licensed under the Apache License, Version 2.0 (the "License");2// you may not use this file except in compliance with the License.3// You may obtain a copy of the License at4//5// http://www.apache.org/licenses/LICENSE-2.06//7// Unless required by applicable law or agreed to in writing, software8// distributed under the License is distributed on an "AS IS" BASIS,9// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.10// See the License for the specific language governing permissions and11// limitations under the License.12//13// Copyright 2009 Google Inc. All Rights Reserved14/**15 * This type is for INTERNAL use in MongoDB only and should not be used in applications.16 * The appropriate corresponding type is the JavaScript Date type.17 * 18 * Defines a Timestamp class for representing a 64-bit two's-complement19 * integer value, which faithfully simulates the behavior of a Java "Timestamp". This20 * implementation is derived from TimestampLib in GWT.21 *22 * Constructs a 64-bit two's-complement integer, given its low and high 32-bit23 * values as *signed* integers. See the from* functions below for more24 * convenient ways of constructing Timestamps.25 *26 * The internal representation of a Timestamp is the two given signed, 32-bit values.27 * We use 32-bit pieces because these are the size of integers on which28 * Javascript performs bit-operations. For operations like addition and29 * multiplication, we split each number into 16-bit pieces, which can easily be30 * multiplied within Javascript's floating-point representation without overflow31 * or change in sign.32 *33 * In the algorithms below, we frequently reduce the negative case to the34 * positive case by negating the input(s) and then post-processing the result.35 * Note that we must ALWAYS check specially whether those values are MIN_VALUE36 * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as37 * a positive number, it overflows back into a negative). Not handling this38 * case would often result in infinite recursion.39 *40 * @class41 * @param {number} low the low (signed) 32 bits of the Timestamp.42 * @param {number} high the high (signed) 32 bits of the Timestamp.43 */44function Timestamp(low, high) {45 if (!(this instanceof Timestamp)) return new Timestamp(low, high);46 this._bsontype = 'Timestamp';47 /**48 * @type {number}49 * @ignore50 */51 this.low_ = low | 0; // force into 32 signed bits.52 /**53 * @type {number}54 * @ignore55 */56 this.high_ = high | 0; // force into 32 signed bits.57}58/**59 * Return the int value.60 *61 * @return {number} the value, assuming it is a 32-bit integer.62 */63Timestamp.prototype.toInt = function() {64 return this.low_;65};66/**67 * Return the Number value.68 *69 * @method70 * @return {number} the closest floating-point representation to this value.71 */72Timestamp.prototype.toNumber = function() {73 return this.high_ * Timestamp.TWO_PWR_32_DBL_ + this.getLowBitsUnsigned();74};75/**76 * Return the JSON value.77 *78 * @method79 * @return {string} the JSON representation.80 */81Timestamp.prototype.toJSON = function() {82 return this.toString();83};84/**85 * Return the String value.86 *87 * @method88 * @param {number} [opt_radix] the radix in which the text should be written.89 * @return {string} the textual representation of this value.90 */91Timestamp.prototype.toString = function(opt_radix) {92 var radix = opt_radix || 10;93 if (radix < 2 || 36 < radix) {94 throw Error('radix out of range: ' + radix);95 }96 if (this.isZero()) {97 return '0';98 }99 if (this.isNegative()) {100 if (this.equals(Timestamp.MIN_VALUE)) {101 // We need to change the Timestamp value before it can be negated, so we remove102 // the bottom-most digit in this base and then recurse to do the rest.103 var radixTimestamp = Timestamp.fromNumber(radix);104 var div = this.div(radixTimestamp);105 var rem = div.multiply(radixTimestamp).subtract(this);106 return div.toString(radix) + rem.toInt().toString(radix);107 } else {108 return '-' + this.negate().toString(radix);109 }110 }111 // Do several (6) digits each time through the loop, so as to112 // minimize the calls to the very expensive emulated div.113 var radixToPower = Timestamp.fromNumber(Math.pow(radix, 6));114 rem = this;115 var result = '';116 while (!rem.isZero()) {117 var remDiv = rem.div(radixToPower);118 var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();119 var digits = intval.toString(radix);120 rem = remDiv;121 if (rem.isZero()) {122 return digits + result;123 } else {124 while (digits.length < 6) {125 digits = '0' + digits;126 }127 result = '' + digits + result;128 }129 }130};131/**132 * Return the high 32-bits value.133 *134 * @method135 * @return {number} the high 32-bits as a signed value.136 */137Timestamp.prototype.getHighBits = function() {138 return this.high_;139};140/**141 * Return the low 32-bits value.142 *143 * @method144 * @return {number} the low 32-bits as a signed value.145 */146Timestamp.prototype.getLowBits = function() {147 return this.low_;148};149/**150 * Return the low unsigned 32-bits value.151 *152 * @method153 * @return {number} the low 32-bits as an unsigned value.154 */155Timestamp.prototype.getLowBitsUnsigned = function() {156 return this.low_ >= 0 ? this.low_ : Timestamp.TWO_PWR_32_DBL_ + this.low_;157};158/**159 * Returns the number of bits needed to represent the absolute value of this Timestamp.160 *161 * @method162 * @return {number} Returns the number of bits needed to represent the absolute value of this Timestamp.163 */164Timestamp.prototype.getNumBitsAbs = function() {165 if (this.isNegative()) {166 if (this.equals(Timestamp.MIN_VALUE)) {167 return 64;168 } else {169 return this.negate().getNumBitsAbs();170 }171 } else {172 var val = this.high_ !== 0 ? this.high_ : this.low_;173 for (var bit = 31; bit > 0; bit--) {174 if ((val & (1 << bit)) !== 0) {175 break;176 }177 }178 return this.high_ !== 0 ? bit + 33 : bit + 1;179 }180};181/**182 * Return whether this value is zero.183 *184 * @method185 * @return {boolean} whether this value is zero.186 */187Timestamp.prototype.isZero = function() {188 return this.high_ === 0 && this.low_ === 0;189};190/**191 * Return whether this value is negative.192 *193 * @method194 * @return {boolean} whether this value is negative.195 */196Timestamp.prototype.isNegative = function() {197 return this.high_ < 0;198};199/**200 * Return whether this value is odd.201 *202 * @method203 * @return {boolean} whether this value is odd.204 */205Timestamp.prototype.isOdd = function() {206 return (this.low_ & 1) === 1;207};208/**209 * Return whether this Timestamp equals the other210 *211 * @method212 * @param {Timestamp} other Timestamp to compare against.213 * @return {boolean} whether this Timestamp equals the other214 */215Timestamp.prototype.equals = function(other) {216 return this.high_ === other.high_ && this.low_ === other.low_;217};218/**219 * Return whether this Timestamp does not equal the other.220 *221 * @method222 * @param {Timestamp} other Timestamp to compare against.223 * @return {boolean} whether this Timestamp does not equal the other.224 */225Timestamp.prototype.notEquals = function(other) {226 return this.high_ !== other.high_ || this.low_ !== other.low_;227};228/**229 * Return whether this Timestamp is less than the other.230 *231 * @method232 * @param {Timestamp} other Timestamp to compare against.233 * @return {boolean} whether this Timestamp is less than the other.234 */235Timestamp.prototype.lessThan = function(other) {236 return this.compare(other) < 0;237};238/**239 * Return whether this Timestamp is less than or equal to the other.240 *241 * @method242 * @param {Timestamp} other Timestamp to compare against.243 * @return {boolean} whether this Timestamp is less than or equal to the other.244 */245Timestamp.prototype.lessThanOrEqual = function(other) {246 return this.compare(other) <= 0;247};248/**249 * Return whether this Timestamp is greater than the other.250 *251 * @method252 * @param {Timestamp} other Timestamp to compare against.253 * @return {boolean} whether this Timestamp is greater than the other.254 */255Timestamp.prototype.greaterThan = function(other) {256 return this.compare(other) > 0;257};258/**259 * Return whether this Timestamp is greater than or equal to the other.260 *261 * @method262 * @param {Timestamp} other Timestamp to compare against.263 * @return {boolean} whether this Timestamp is greater than or equal to the other.264 */265Timestamp.prototype.greaterThanOrEqual = function(other) {266 return this.compare(other) >= 0;267};268/**269 * Compares this Timestamp with the given one.270 *271 * @method272 * @param {Timestamp} other Timestamp to compare against.273 * @return {boolean} 0 if they are the same, 1 if the this is greater, and -1 if the given one is greater.274 */275Timestamp.prototype.compare = function(other) {276 if (this.equals(other)) {277 return 0;278 }279 var thisNeg = this.isNegative();280 var otherNeg = other.isNegative();281 if (thisNeg && !otherNeg) {282 return -1;283 }284 if (!thisNeg && otherNeg) {285 return 1;286 }287 // at this point, the signs are the same, so subtraction will not overflow288 if (this.subtract(other).isNegative()) {289 return -1;290 } else {291 return 1;292 }293};294/**295 * The negation of this value.296 *297 * @method298 * @return {Timestamp} the negation of this value.299 */300Timestamp.prototype.negate = function() {301 if (this.equals(Timestamp.MIN_VALUE)) {302 return Timestamp.MIN_VALUE;303 } else {304 return this.not().add(Timestamp.ONE);305 }306};307/**308 * Returns the sum of this and the given Timestamp.309 *310 * @method311 * @param {Timestamp} other Timestamp to add to this one.312 * @return {Timestamp} the sum of this and the given Timestamp.313 */314Timestamp.prototype.add = function(other) {315 // Divide each number into 4 chunks of 16 bits, and then sum the chunks.316 var a48 = this.high_ >>> 16;317 var a32 = this.high_ & 0xffff;318 var a16 = this.low_ >>> 16;319 var a00 = this.low_ & 0xffff;320 var b48 = other.high_ >>> 16;321 var b32 = other.high_ & 0xffff;322 var b16 = other.low_ >>> 16;323 var b00 = other.low_ & 0xffff;324 var c48 = 0,325 c32 = 0,326 c16 = 0,327 c00 = 0;328 c00 += a00 + b00;329 c16 += c00 >>> 16;330 c00 &= 0xffff;331 c16 += a16 + b16;332 c32 += c16 >>> 16;333 c16 &= 0xffff;334 c32 += a32 + b32;335 c48 += c32 >>> 16;336 c32 &= 0xffff;337 c48 += a48 + b48;338 c48 &= 0xffff;339 return Timestamp.fromBits((c16 << 16) | c00, (c48 << 16) | c32);340};341/**342 * Returns the difference of this and the given Timestamp.343 *344 * @method345 * @param {Timestamp} other Timestamp to subtract from this.346 * @return {Timestamp} the difference of this and the given Timestamp.347 */348Timestamp.prototype.subtract = function(other) {349 return this.add(other.negate());350};351/**352 * Returns the product of this and the given Timestamp.353 *354 * @method355 * @param {Timestamp} other Timestamp to multiply with this.356 * @return {Timestamp} the product of this and the other.357 */358Timestamp.prototype.multiply = function(other) {359 if (this.isZero()) {360 return Timestamp.ZERO;361 } else if (other.isZero()) {362 return Timestamp.ZERO;363 }364 if (this.equals(Timestamp.MIN_VALUE)) {365 return other.isOdd() ? Timestamp.MIN_VALUE : Timestamp.ZERO;366 } else if (other.equals(Timestamp.MIN_VALUE)) {367 return this.isOdd() ? Timestamp.MIN_VALUE : Timestamp.ZERO;368 }369 if (this.isNegative()) {370 if (other.isNegative()) {371 return this.negate().multiply(other.negate());372 } else {373 return this.negate()374 .multiply(other)375 .negate();376 }377 } else if (other.isNegative()) {378 return this.multiply(other.negate()).negate();379 }380 // If both Timestamps are small, use float multiplication381 if (this.lessThan(Timestamp.TWO_PWR_24_) && other.lessThan(Timestamp.TWO_PWR_24_)) {382 return Timestamp.fromNumber(this.toNumber() * other.toNumber());383 }384 // Divide each Timestamp into 4 chunks of 16 bits, and then add up 4x4 products.385 // We can skip products that would overflow.386 var a48 = this.high_ >>> 16;387 var a32 = this.high_ & 0xffff;388 var a16 = this.low_ >>> 16;389 var a00 = this.low_ & 0xffff;390 var b48 = other.high_ >>> 16;391 var b32 = other.high_ & 0xffff;392 var b16 = other.low_ >>> 16;393 var b00 = other.low_ & 0xffff;394 var c48 = 0,395 c32 = 0,396 c16 = 0,397 c00 = 0;398 c00 += a00 * b00;399 c16 += c00 >>> 16;400 c00 &= 0xffff;401 c16 += a16 * b00;402 c32 += c16 >>> 16;403 c16 &= 0xffff;404 c16 += a00 * b16;405 c32 += c16 >>> 16;406 c16 &= 0xffff;407 c32 += a32 * b00;408 c48 += c32 >>> 16;409 c32 &= 0xffff;410 c32 += a16 * b16;411 c48 += c32 >>> 16;412 c32 &= 0xffff;413 c32 += a00 * b32;414 c48 += c32 >>> 16;415 c32 &= 0xffff;416 c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;417 c48 &= 0xffff;418 return Timestamp.fromBits((c16 << 16) | c00, (c48 << 16) | c32);419};420/**421 * Returns this Timestamp divided by the given one.422 *423 * @method424 * @param {Timestamp} other Timestamp by which to divide.425 * @return {Timestamp} this Timestamp divided by the given one.426 */427Timestamp.prototype.div = function(other) {428 if (other.isZero()) {429 throw Error('division by zero');430 } else if (this.isZero()) {431 return Timestamp.ZERO;432 }433 if (this.equals(Timestamp.MIN_VALUE)) {434 if (other.equals(Timestamp.ONE) || other.equals(Timestamp.NEG_ONE)) {435 return Timestamp.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE436 } else if (other.equals(Timestamp.MIN_VALUE)) {437 return Timestamp.ONE;438 } else {439 // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.440 var halfThis = this.shiftRight(1);441 var approx = halfThis.div(other).shiftLeft(1);442 if (approx.equals(Timestamp.ZERO)) {443 return other.isNegative() ? Timestamp.ONE : Timestamp.NEG_ONE;444 } else {445 var rem = this.subtract(other.multiply(approx));446 var result = approx.add(rem.div(other));447 return result;448 }449 }450 } else if (other.equals(Timestamp.MIN_VALUE)) {451 return Timestamp.ZERO;452 }453 if (this.isNegative()) {454 if (other.isNegative()) {455 return this.negate().div(other.negate());456 } else {457 return this.negate()458 .div(other)459 .negate();460 }461 } else if (other.isNegative()) {462 return this.div(other.negate()).negate();463 }464 // Repeat the following until the remainder is less than other: find a465 // floating-point that approximates remainder / other *from below*, add this466 // into the result, and subtract it from the remainder. It is critical that467 // the approximate value is less than or equal to the real value so that the468 // remainder never becomes negative.469 var res = Timestamp.ZERO;470 rem = this;471 while (rem.greaterThanOrEqual(other)) {472 // Approximate the result of division. This may be a little greater or473 // smaller than the actual value.474 approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));475 // We will tweak the approximate result by changing it in the 48-th digit or476 // the smallest non-fractional digit, whichever is larger.477 var log2 = Math.ceil(Math.log(approx) / Math.LN2);478 var delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);479 // Decrease the approximation until it is smaller than the remainder. Note480 // that if it is too large, the product overflows and is negative.481 var approxRes = Timestamp.fromNumber(approx);482 var approxRem = approxRes.multiply(other);483 while (approxRem.isNegative() || approxRem.greaterThan(rem)) {484 approx -= delta;485 approxRes = Timestamp.fromNumber(approx);486 approxRem = approxRes.multiply(other);487 }488 // We know the answer can't be zero... and actually, zero would cause489 // infinite recursion since we would make no progress.490 if (approxRes.isZero()) {491 approxRes = Timestamp.ONE;492 }493 res = res.add(approxRes);494 rem = rem.subtract(approxRem);495 }496 return res;497};498/**499 * Returns this Timestamp modulo the given one.500 *501 * @method502 * @param {Timestamp} other Timestamp by which to mod.503 * @return {Timestamp} this Timestamp modulo the given one.504 */505Timestamp.prototype.modulo = function(other) {506 return this.subtract(this.div(other).multiply(other));507};508/**509 * The bitwise-NOT of this value.510 *511 * @method512 * @return {Timestamp} the bitwise-NOT of this value.513 */514Timestamp.prototype.not = function() {515 return Timestamp.fromBits(~this.low_, ~this.high_);516};517/**518 * Returns the bitwise-AND of this Timestamp and the given one.519 *520 * @method521 * @param {Timestamp} other the Timestamp with which to AND.522 * @return {Timestamp} the bitwise-AND of this and the other.523 */524Timestamp.prototype.and = function(other) {525 return Timestamp.fromBits(this.low_ & other.low_, this.high_ & other.high_);526};527/**528 * Returns the bitwise-OR of this Timestamp and the given one.529 *530 * @method531 * @param {Timestamp} other the Timestamp with which to OR.532 * @return {Timestamp} the bitwise-OR of this and the other.533 */534Timestamp.prototype.or = function(other) {535 return Timestamp.fromBits(this.low_ | other.low_, this.high_ | other.high_);536};537/**538 * Returns the bitwise-XOR of this Timestamp and the given one.539 *540 * @method541 * @param {Timestamp} other the Timestamp with which to XOR.542 * @return {Timestamp} the bitwise-XOR of this and the other.543 */544Timestamp.prototype.xor = function(other) {545 return Timestamp.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);546};547/**548 * Returns this Timestamp with bits shifted to the left by the given amount.549 *550 * @method551 * @param {number} numBits the number of bits by which to shift.552 * @return {Timestamp} this shifted to the left by the given amount.553 */554Timestamp.prototype.shiftLeft = function(numBits) {555 numBits &= 63;556 if (numBits === 0) {557 return this;558 } else {559 var low = this.low_;560 if (numBits < 32) {561 var high = this.high_;562 return Timestamp.fromBits(low << numBits, (high << numBits) | (low >>> (32 - numBits)));563 } else {564 return Timestamp.fromBits(0, low << (numBits - 32));565 }566 }567};568/**569 * Returns this Timestamp with bits shifted to the right by the given amount.570 *571 * @method572 * @param {number} numBits the number of bits by which to shift.573 * @return {Timestamp} this shifted to the right by the given amount.574 */575Timestamp.prototype.shiftRight = function(numBits) {576 numBits &= 63;577 if (numBits === 0) {578 return this;579 } else {580 var high = this.high_;581 if (numBits < 32) {582 var low = this.low_;583 return Timestamp.fromBits((low >>> numBits) | (high << (32 - numBits)), high >> numBits);584 } else {585 return Timestamp.fromBits(high >> (numBits - 32), high >= 0 ? 0 : -1);586 }587 }588};589/**590 * Returns this Timestamp with bits shifted to the right by the given amount, with the new top bits matching the current sign bit.591 *592 * @method593 * @param {number} numBits the number of bits by which to shift.594 * @return {Timestamp} this shifted to the right by the given amount, with zeros placed into the new leading bits.595 */596Timestamp.prototype.shiftRightUnsigned = function(numBits) {597 numBits &= 63;598 if (numBits === 0) {599 return this;600 } else {601 var high = this.high_;602 if (numBits < 32) {603 var low = this.low_;604 return Timestamp.fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits);605 } else if (numBits === 32) {606 return Timestamp.fromBits(high, 0);607 } else {608 return Timestamp.fromBits(high >>> (numBits - 32), 0);609 }610 }611};612/**613 * Returns a Timestamp representing the given (32-bit) integer value.614 *615 * @method616 * @param {number} value the 32-bit integer in question.617 * @return {Timestamp} the corresponding Timestamp value.618 */619Timestamp.fromInt = function(value) {620 if (-128 <= value && value < 128) {621 var cachedObj = Timestamp.INT_CACHE_[value];622 if (cachedObj) {623 return cachedObj;624 }625 }626 var obj = new Timestamp(value | 0, value < 0 ? -1 : 0);627 if (-128 <= value && value < 128) {628 Timestamp.INT_CACHE_[value] = obj;629 }630 return obj;631};632/**633 * Returns a Timestamp representing the given value, provided that it is a finite number. Otherwise, zero is returned.634 *635 * @method636 * @param {number} value the number in question.637 * @return {Timestamp} the corresponding Timestamp value.638 */639Timestamp.fromNumber = function(value) {640 if (isNaN(value) || !isFinite(value)) {641 return Timestamp.ZERO;642 } else if (value <= -Timestamp.TWO_PWR_63_DBL_) {643 return Timestamp.MIN_VALUE;644 } else if (value + 1 >= Timestamp.TWO_PWR_63_DBL_) {645 return Timestamp.MAX_VALUE;646 } else if (value < 0) {647 return Timestamp.fromNumber(-value).negate();648 } else {649 return new Timestamp(650 (value % Timestamp.TWO_PWR_32_DBL_) | 0,651 (value / Timestamp.TWO_PWR_32_DBL_) | 0652 );653 }654};655/**656 * Returns a Timestamp representing the 64-bit integer that comes by concatenating the given high and low bits. Each is assumed to use 32 bits.657 *658 * @method659 * @param {number} lowBits the low 32-bits.660 * @param {number} highBits the high 32-bits.661 * @return {Timestamp} the corresponding Timestamp value.662 */663Timestamp.fromBits = function(lowBits, highBits) {664 return new Timestamp(lowBits, highBits);665};666/**667 * Returns a Timestamp representation of the given string, written using the given radix.668 *669 * @method670 * @param {string} str the textual representation of the Timestamp.671 * @param {number} opt_radix the radix in which the text is written.672 * @return {Timestamp} the corresponding Timestamp value.673 */674Timestamp.fromString = function(str, opt_radix) {675 if (str.length === 0) {676 throw Error('number format error: empty string');677 }678 var radix = opt_radix || 10;679 if (radix < 2 || 36 < radix) {680 throw Error('radix out of range: ' + radix);681 }682 if (str.charAt(0) === '-') {683 return Timestamp.fromString(str.substring(1), radix).negate();684 } else if (str.indexOf('-') >= 0) {685 throw Error('number format error: interior "-" character: ' + str);686 }687 // Do several (8) digits each time through the loop, so as to688 // minimize the calls to the very expensive emulated div.689 var radixToPower = Timestamp.fromNumber(Math.pow(radix, 8));690 var result = Timestamp.ZERO;691 for (var i = 0; i < str.length; i += 8) {692 var size = Math.min(8, str.length - i);693 var value = parseInt(str.substring(i, i + size), radix);694 if (size < 8) {695 var power = Timestamp.fromNumber(Math.pow(radix, size));696 result = result.multiply(power).add(Timestamp.fromNumber(value));697 } else {698 result = result.multiply(radixToPower);699 result = result.add(Timestamp.fromNumber(value));700 }701 }702 return result;703};704// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the705// from* methods on which they depend.706/**707 * A cache of the Timestamp representations of small integer values.708 * @type {Object}709 * @ignore710 */711Timestamp.INT_CACHE_ = {};712// NOTE: the compiler should inline these constant values below and then remove713// these variables, so there should be no runtime penalty for these.714/**715 * Number used repeated below in calculations. This must appear before the716 * first call to any from* function below.717 * @type {number}718 * @ignore719 */720Timestamp.TWO_PWR_16_DBL_ = 1 << 16;721/**722 * @type {number}723 * @ignore724 */725Timestamp.TWO_PWR_24_DBL_ = 1 << 24;726/**727 * @type {number}728 * @ignore729 */730Timestamp.TWO_PWR_32_DBL_ = Timestamp.TWO_PWR_16_DBL_ * Timestamp.TWO_PWR_16_DBL_;731/**732 * @type {number}733 * @ignore734 */735Timestamp.TWO_PWR_31_DBL_ = Timestamp.TWO_PWR_32_DBL_ / 2;736/**737 * @type {number}738 * @ignore739 */740Timestamp.TWO_PWR_48_DBL_ = Timestamp.TWO_PWR_32_DBL_ * Timestamp.TWO_PWR_16_DBL_;741/**742 * @type {number}743 * @ignore744 */745Timestamp.TWO_PWR_64_DBL_ = Timestamp.TWO_PWR_32_DBL_ * Timestamp.TWO_PWR_32_DBL_;746/**747 * @type {number}748 * @ignore749 */750Timestamp.TWO_PWR_63_DBL_ = Timestamp.TWO_PWR_64_DBL_ / 2;751/** @type {Timestamp} */752Timestamp.ZERO = Timestamp.fromInt(0);753/** @type {Timestamp} */754Timestamp.ONE = Timestamp.fromInt(1);755/** @type {Timestamp} */756Timestamp.NEG_ONE = Timestamp.fromInt(-1);757/** @type {Timestamp} */758Timestamp.MAX_VALUE = Timestamp.fromBits(0xffffffff | 0, 0x7fffffff | 0);759/** @type {Timestamp} */760Timestamp.MIN_VALUE = Timestamp.fromBits(0, 0x80000000 | 0);761/**762 * @type {Timestamp}763 * @ignore764 */765Timestamp.TWO_PWR_24_ = Timestamp.fromInt(1 << 24);766/**767 * Expose.768 */769module.exports = Timestamp;...

Full Screen

Full Screen

TimestampForm.js

Source:TimestampForm.js Github

copy

Full Screen

1import React, { Fragment } from 'react';2import { Form as FinalForm, Field } from 'react-final-form';3import { Button, Form, Header, Search } from 'semantic-ui-react';4import TextInput from '../../app/common/form/TextInput';5import { FORM_ERROR } from 'final-form';6import { formatDateTime, reverseFormatDateTime } from '../../app/common/util';7import { combineValidators, isRequired } from 'revalidate';8import ErrorMessage from '../../app/common/form/ErrorMessage';9import DateTimeCustomInput from '../../app/common/form/DateTimeCustomInput';10import { Timestamps, Jobsites } from '../../app/api/agent';11import { useModalDispatch } from '../../app/context/modal/modalContext';12import { useAlertDispatch } from '../../app/context/alerts/alertContext';13import { setAlert } from '../../app/context/alerts/alertActions';14import { useTimestampDispatch } from '../../app/context/timestamps/timestampContext';15const validate = combineValidators({16 username: isRequired('Username'),17 moniker: isRequired('Moniker'),18 clockedInStamp: isRequired('Clocked In Time'),19 clockedOutStamp: isRequired('Clocked Out Time'),20});21// modal - form used to add/edit a timestamp22//if editTimestamp is true, will load form with data and prevent changing jobsite23const TimestampForm = ({ username, editTimestamp = false }) => {24 const modalDispatch = useModalDispatch();25 const alertDispatch = useAlertDispatch();26 const timestampDispatch = useTimestampDispatch();27 const pageSize = 10;28 const [timestamp, setTimestamp] = React.useState({29 username: username,30 moniker: '',31 clockedInStamp: '',32 clockedOutStamp: '',33 });34 React.useEffect(() => {35 if (editTimestamp) {36 setTimestamp({37 username: username,38 moniker: editTimestamp.moniker,39 clockedInStamp: reverseFormatDateTime(editTimestamp.clockedInStamp),40 clockedOutStamp: reverseFormatDateTime(editTimestamp.clockedOutStamp),41 });42 setSelectionValue(editTimestamp.moniker);43 }44 }, [editTimestamp, username]);45 const handleFinalFormSubmit = async (values) => {46 try {47 //format values into a timestamp48 const timestamp = {49 username: values.username,50 moniker: values.moniker,51 clockedInStamp: formatDateTime(values.clockedInStamp),52 clockedOutStamp: formatDateTime(values.clockedOutStamp),53 };54 //editing timestamp requires only two fields55 if (editTimestamp) {56 const clockedStamps = {57 clockedInStamp: timestamp.clockedInStamp,58 clockedOutStamp: timestamp.clockedOutStamp,59 };60 await Timestamps.editTimestamp(61 editTimestamp.timestampId,62 clockedStamps63 );64 modalDispatch({ type: 'CLOSE_MODAL' });65 timestampDispatch({ type: 'REFRESH' });66 setAlert(alertDispatch, `Timestamp Updated`, 'update');67 } else {68 await Timestamps.addTimestamp(timestamp);69 modalDispatch({ type: 'CLOSE_MODAL' });70 timestampDispatch({ type: 'REFRESH' });71 setAlert(alertDispatch, `New Timestamp added`, 'success');72 }73 } catch (error) {74 return { [FORM_ERROR]: error };75 }76 };77 //Ccode here supports the job search bar component----------------78 const [results, setResults] = React.useState([]);79 const [loading, setLoading] = React.useState(false);80 const [selectionValue, setSelectionValue] = React.useState('');81 const handleSearchChange = async (e, { value }) => {82 setSelectionValue(value);83 setLoading(true);84 let searchResults = await Jobsites.listJobsites(value, pageSize, 1);85 searchResults = searchResults.data;86 let newResults = [];87 searchResults.forEach((jobsite) => {88 newResults.push({89 title: jobsite.moniker,90 description: `${jobsite.name} - ${jobsite.location.cityTown}`,91 });92 });93 setLoading(false);94 setResults(newResults);95 };96 const handleResultSelect = (e, { result }) => {97 setSelectionValue(result.title);98 setTimestamp({ ...timestamp, moniker: result.title });99 };100 // end of job search bar component -----------------------------101 return (102 <Fragment>103 <FinalForm104 onSubmit={handleFinalFormSubmit}105 validate={validate}106 initialValues={timestamp}107 render={({108 handleSubmit,109 submitting,110 submitError,111 invalid,112 pristine,113 dirtySinceLastSubmit,114 form,115 }) => (116 <Form onSubmit={handleSubmit} error>117 <Header118 as='h2'119 content={editTimestamp ? 'Edit Timestamp' : 'Add Timestamp'}120 color='teal'121 textAlign='center'122 />123 <Field124 name='username'125 component={TextInput}126 placeholder='Username'127 value={timestamp.username}128 disabled129 />130 {!editTimestamp && pristine && (131 <p style={{ fontStyle: 'italic', color: 'red' }}>132 Choose a jobsite first133 </p>134 )}135 <Search136 placeholder='Search jobsites...'137 loading={loading}138 onResultSelect={handleResultSelect}139 onSearchChange={handleSearchChange}140 results={results}141 value={selectionValue}142 disabled={editTimestamp ? true : false}143 />144 <Field145 name='moniker'146 component={TextInput}147 placeholder='Moniker'148 value={timestamp.moniker}149 style={{ display: 'none' }}150 />151 <Field152 name='clockedInStamp'153 value={timestamp.clockedInStamp}154 component={DateTimeCustomInput}155 placeholder='Clocked In Time'156 dateFormat='MM-DD-YYYY'157 clearable158 closable159 />160 <Field161 name='clockedOutStamp'162 value={timestamp.clockedOutStamp}163 component={DateTimeCustomInput}164 placeholder='Clocked Out Time'165 dateFormat='MM-DD-YYYY'166 clearable167 closable168 />169 {submitError && !dirtySinceLastSubmit && (170 <ErrorMessage error={submitError} />171 )}172 <Button173 disabled={(invalid && !dirtySinceLastSubmit) || pristine}174 loading={submitting}175 color='teal'176 content='Submit'177 fluid178 />179 {/* <pre>{JSON.stringify(form.getState(), null, 2)}</pre> */}180 </Form>181 )}182 />183 </Fragment>184 );185};...

Full Screen

Full Screen

App.js

Source:App.js Github

copy

Full Screen

...45 }46 insert_continue=(tx,event,lat1,long1,speed,bearing,timestamp,event_row)=>{47 tx.executeSql("Insert into Events "+event_query+" values('"+event+"',"+event_row.curr_timestamp+","+timestamp+",'"+event_row.curr_lat+"','"+lat1+"','"+event_row.curr_long+"','"+long1+"',"+event_row.curr_bearing+","+bearing+","+event_row.curr_speed+","+speed+");")48 }49 //insert event in non continious timestamp(next.current_timestamp == next.previous_timestamp)50 insert_new=(activity,timestamp,event_row,tx)=>{51 console.log("Incerting new")52 tx.executeSql("Insert into Events (activity,prev_timestamp,curr_timestamp,confidence) values('"+activity.type+"',"+timestamp+","+timestamp+","+activity.confidence+");")53 }54 componentDidMount(){55 //this.getLocation()56 }57 //extend the event58 update=(activity,timestamp,event_row,tx)=>{59 tx.executeSql("UPDATE Events set "+60 "activity ='"+activity.type+ "',"+61 "curr_timestamp ="+timestamp+ ","+62 "confidence ="+activity.confidence +63 " where id ="+event_row.id);...

Full Screen

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run freezegun automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

... View sample repo... View DocumentationSign up Free
›
_

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

...
Sign up with GoogleSign up with Email
Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful