I have a function in my smart contract that looks like this
index.ts
class MsgCode {
msg: string;
code: i32;
}
#nearBindgen
export class Contract {
getFoo(): MsgCode {
return {code: 0, msg: 'foo'};
}
getBar(): string {
return 'bar'
}
}
When I call this function through the near-api-js library like this, I'm not receiving anything from the result
contract = await new Contract(account, CONTRACT_NAME, {
viewMethods: ['getFoo', 'getBar'],
});
const getData = () => {
return contract.getFoo().then(res => console.log(res)); // prints nothing. Expect to print {msg:'foo', code:0}
return contract.getBar().then(res => console.log(res)); // prints bar
};
I'm expecting getFoo() to return {msg:'foo', code:0} when I call it on the client, but I receive nothing. What am I doing wrong?
The class type that we want to return from our function also needs to use the #nearBindgen annotation. Otherwise, it won't be serialized. https://docs.near.org/docs/develop/contracts/as/intro#models-define-new-types
#nearBindgen // Added annotation
class MsgCode {
msg: string;
code: i32;
}
I am using Alpine JS store() to make a global function available to toggle a modal status.
Module:
export default () => ({
/**
* #property isOpen - controls the state of the Contact Form Modal
*/
isOpen: false,
open() {
this.isOpen = true
},
close() {
this.isOpen = false
},
});
Then I use it like:
import modalContactForm from './alpine/modal-contact-form';
// Alpine.store sets data for GLOBAL usage
Alpine.store('modalContactForm', modalContactForm);
Alpine.start();
And with this HTML:
<button x-data #click="$store.modalContactForm.open()"></button>
But I get:
Alpine Expression Error: $store.modalContactForm.open is not a function
And I don't know how to debug this situation.
Interestingly, if I pass the object directly into Alpine.store(), it works.
Alpine.store('modalContactForm', {
isOpen: false,
open() {
this.isOpen = true
},
close() {
this.isOpen = false
},
});
Alpine.start();
In the external module file export the store as a simple object, not as an anonymous function:
const modalContactForm = {
/**
* #property isOpen - controls the state of the Contact Form Modal
*/
isOpen: false,
open() {
this.isOpen = true
},
close() {
this.isOpen = false
},
}
export default modalContactForm
There's probably a simple solution for this and I cannot figure it out. I have a simple script file I was trying to compile with Laravel mix. When I run npm run dev, it compiles and adds a ton of code that I have no idea where. I have a simple function to try to get it to fire:
function hello(){
console.log('hi');
}
The code that gets compiled is:
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
__webpack_require__(1);
module.exports = __webpack_require__(2);
/***/ }),
/* 1 */
/***/ (function(module, exports) {
/**
* This takes the AJAX error response and returns it in a readable format.
*/
function hello() {
console.log('hi');
}
/***/ }),
/* 2 */
/***/ (function(module, exports) {
// removed by extract-text-webpack-plugin
/***/ })
/******/ ]);
The function hello() is in there, but cannot be called. It says it's not defined. Here's my webpack.mix.js:
mix.js('resources/assets/js/page/page.js', 'public/js/')
.sass('resources/assets/sass/app.scss', 'public/css');
I found one article on a laracast about this, but it was a weird solution for them. Help?
UPDATE
For some odd reason, instead of .js, .scripts was needed in the webpack.mix.js file. I don't know why that worked only in this project.
I am facing problem where I have created an Injectable service class having static methods like:
declare let Granite: any;
#Injectable()
export class I18NService {
public static get(key:string):string {
return Granite.I18n.get(key);
}
}
and I am trying to test it using jasmine where I have written my test cases like:
export function main() {
fdescribe('Granite Service', () => {
class MockGraniteService {
get(st: string): string {
return '';
}
}
beforeEach(() => {
//spyOn(I18NService, 'get').and.callThrough();
TestBed.configureTestingModule({
providers: [{
provide: I18NService,
useClass: MockGraniteService
}]
});
});
it('should be granite processed value from Granite API', () => {
//Spy
spyOn(I18NService, 'get').and.callFake(() => {
return "Ship To";
});
let processedVal = I18NService.get('mkt.header.shipToLabel');
expect(processedVal).toBeTruthy();
expect(processedVal).toEqual('Ship To');
});
})
}
when I am spying on get() it is excluded from code coverage and when i directly call the function using callThrough(), it is making an actual call but not getting granite processed value. Any help?
Lets say I have a csv file like this:
a,b1,12,
a,b1,42,
d,e1,12,
r,12,33,
I want to use grep to return only only the rows where the third column = 12. So it would return:
a,b1,12,
d,e1,12,
but not:
r,12,33,
Any ideas for a regular expression that will allow me to do this?
I'd jump straight to awk to test the value exactly
awk -F, '$3 == 12' file.csv
This, and any regexp-based solution, assumes that the values of the first two fields do not contain commas
grep "^[^,]\+,[^,]\+,12," file.csv
Here's a variation:
egrep "^([^,]+,){2}12," file.csv
The advantage is that you can select the field simply by changing the number enclosed in curly braces without having to add or subtract literal copies of the pattern manually.
csvkit is a great toolkit for stuff like this, especially on the larger scale. After installing csvkit, follow these instructions to isolate the rows you want:
# Find rows that have the value 12 in the 3rd column
> csvgrep -c 3 -m 12 | csvlook
This should prettily print out the rows you want. The full documentation for csvkit (and a well-writen tutorial) can be found here.
when you have csv files, where you have distinct delimiters such as commas, use the splitting on field/delimiters approach, not regular expression. Tools to break strings up like awk, Perl/Python does the job easily for you (Perl/Python has support for csv modules for more complex csv parsing)
Perl,
$ perl -F/,/ -alne 'print if $F[2]==12;' file
a,b1,12,
d,e1,12,
$ awk -F"," '$3==12' file
a,b1,12,
d,e1,12,
or with just the shell
while IFS="," read a b c d
do
case "$c" in
12) echo "$a,$b,$c,$d"
esac
done <"file"
I don’t know about efficiency (would love to know), this works
cat path/to/file.csv | grep <some-text>
Linux tools cannot practically process csv, because quoted fields can contain newline characters according to rfc 1480 Most dedicated utilities are garbage for various reasons.
Here’s a Node.js v7.10+ single-file executable that “just works” and produces converted json objects, one per line. Should run Linux macOS Windows
Usage for a file with header line:
cat infinite.csv | csv1480json --header
{"some header": "field value"}
Without header line:
echo abc | csv1480json
{1: "abc"}
The grep becomes:
grep '3: "12"'
On the irect text you can do
Paste this as csv1480json accessible via your PATH and give executable permissions:
#!/usr/bin/env node
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _CsvJsonConverter = __webpack_require__(1);
var _CsvJsonConverter2 = _interopRequireDefault(_CsvJsonConverter);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
launch({ fn: _CsvJsonConverter2.default, getOptions, errorHandler }).catch(errorHandler);
function getOptions() {
const { argv } = process;
console.log('getOptions argv', argv);
const useHeader = argv[2] === '--header';
if (argv.length !== (useHeader ? 3 : 2)) throw new Error('usage: csv1480json [--header]');
return { readStream: process.stdin, writeStream: process.stdout, useHeader };
}
async function launch({ fn, getOptions, errorHandler }) {
process.on('uncaughtException', errorHandler).on('unhandledRejection', errorHandler);
new fn(_extends({}, getOptions(), { errorHandler }));
}
function errorHandler(e) {
console.error(e instanceof Error ? e /*TODO .message*/ : `errorHandler value: ${typeof e} ${e}`);
process.exit(1);
}
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _Pipeline = __webpack_require__(2);
var _Pipeline2 = _interopRequireDefault(_Pipeline);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// getField result
const FIELD_EOF = 1; // end of file
const FIELD_NONE = 2; // data for complete field not seen yet
const FIELD_RECORD = 3; // got a complete record
const separators = Array.from(',\r\n');
class CsvJsonConverter extends _Pipeline2.default {
constructor(o) {
super(o || false);
this.addData = string => this.csv += string;
this.isField = s => typeof s === 'string';
const { useHeader } = o || false;
this.useHeader = !!useHeader;
this.csv = '';
this.recordNo = 1;
console.log(this.useHeader, Object.keys(o || false));
}
getOutput(isEnd) {
if (isEnd) this.isEnd = true;
if (this.useHeader && !this.headers) if (!this.getHeader()) return;
let output = '';
for (let record; record = this.getRecord(); output += record + '\n');
return output || undefined;
}
getRecord() {
const fields = this.getFieldList();
if (fields) {
// got a record
const count = fields.length;
const { fieldCount, recordNo, useHeader, headers } = this;
if (!fieldCount) this.fieldCount = count;else if (count !== fieldCount) throw new Error(`Record ${recordNo} bad field count: ${count} expected ${fieldCount}`);
this.recordNo++;
return `{${fields.map((v, index) => `${useHeader ? headers[index] : index + 1}: ${JSON.stringify(v)}`).join(', ')}}`;
} else return false;
}
getHeader() {
const list = this.getFieldList();
if (list) {
this.headers = list.map(v => JSON.stringify(v));
this.fieldCount = list.length;
}
}
getFieldList() {
// array of string or false
let fields = this.fields || (this.fields = []);
let field;
while (this.isField(field = this.getField())) fields.push(field);
console.log('getFieldList end:', field, fields);
if (field === FIELD_RECORD) {
this.fields = null;
return fields;
} else return false; // need to wait for more data or end of records
}
getField() {
// string or FIELD_*
const { isEnd, recordNo } = this;
const fields = this.fields.length;
let { csv } = this;
let csvCh = csv[0];
if (csvCh === '\r' || csvCh === '\n') {
// skip the end of line terminating a previous record
if (csv.length < 2 && !isEnd) return FIELD_NONE; // must have two characters to find \r\n
const chs = csv.substring(0, 2) === '\r\n' ? 2 : 1;
this.csv = csv = csv.substring(chs);
return FIELD_RECORD; // we have a complete record
}
if (!csv && isEnd) return fields ? FIELD_RECORD : FIELD_EOF;
const m = `Record ${recordNo} field ${fields + 1}`;
if (fields) if (csvCh === ',') csvCh = (this.csv = csv = csv.substring(1))[0];else throw new Error(`${m} missing field-separating comma`); // TODO insert location
if (csvCh === '"') {
// double-quoted field
let quoteSearchIndex = this.quoteSearchIndex || 1; // where to start looking
let index;
for (;;) {
let index = csv.indexOf('"', quoteSearchIndex);
if (!~index) // no end-quote yet
if (!isEnd) {
this.quoteSearchIndex = quoteSearchIndex;
return FIELD_NONE; // no matching quote in data thus far
} else throw new Error(`${m} unmatched double quote`);
if (index - quoteSearchIndex < 2 || csv[index - 1] !== '\\') {
// found unescaped ending double quote
this.quoteSearchIndex = 0;
this.csv = csv.substring(index + 1);
return csv.substring(1, index);
}
quoteSearchIndex = index + 1; // skip escaped double quote
}
}
// it is an unquoted field
const index = separators.map(ch => csv.indexOf(ch)).reduce((r, index) => !~index ? r : !~r ? index : Math.min(r, index));
if (!~index) // none of the separators appeared
if (isEnd) {
this.csv = '';
return csv; // field is rest of line
} else return FIELD_NONE; // need more data
this.csv = csv.substring(index);
return csv.substring(0, index);
}
}
exports.default = CsvJsonConverter;
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _stream = __webpack_require__(3);
class PipeLine extends _stream.Transform {
constructor({ readStream, writeStream, errorHandler }) {
super({ decodeStrings: false, encoding: 'utf8' });
this._flush = callback => callback(null, this.getOutput(true));
const eh = typeof errorHandler;
if (eh !== 'function') throw new Error(`PipeLine: errorHandler not function: ${eh}`);
readStream.on('error', errorHandler).setEncoding('utf8').pipe(this.on('error', errorHandler)).pipe(writeStream.on('error', errorHandler));
}
_transform(chunk, encoding, callback) {
// callback(err, chunk)
if (chunk.length) this.addData(chunk);
callback(null, this.getOutput());
}
}
exports.default = PipeLine; /*
© 2017-present Harald Rudell <harald.rudell#gmail.com> (http://www.haraldrudell.com)
This source code is licensed under the ISC-style license found in the LICENSE file in the root directory of this source tree.
*/
/***/ }),
/* 3 */
/***/ (function(module, exports) {
module.exports = require("stream");
/***/ })
/******/ ]);
//# sourceMappingURL=csv1480json.js.map