Coder Social home page Coder Social logo

json_model's People

Contributors

wendux avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

json_model's Issues

windows子目录解析出现问题

目录结构

jsons/project/type.json
jsons/project/type_item.dart

最终的结果却是

export 'project\type.dart' ; 
export 'project\type_item.dart' ; 

Get dependencies报错

引入了最新版本的json_model和json_serializable,进行get dependencies出错:
image
Because json_model 0.0.2 depends on json_serializable ^2.0.0 and no versions of json_model match >0.0.2 <0.1.0, json_model ^0.0.2 requires json_serializable ^2.0.0.
So, because web_socket depends on both json_serializable ^3.2.2 and json_model ^0.0.2, version solving failed.

SDK版本不兼容

4Dart 2.12.0-29.10.beta is incompatible with your dependencies' SDK constraints. Please run "pub get" again.
pub finished with exit code 65

type 'String' is not a subtype of type 'Map<String, dynamic>' in type cast问题处理

希望作者有时间能处理下

"relist":"$[]Zdata",

上面的代码生成下面的代码

..relist = (json['relist'] as List) ?.map((e) => e == null ? null : Zdata.fromJson(e as Map<String, dynamic>)) ?.toList()

报错:
type 'String' is not a subtype of type 'Map<String, dynamic>' in type cast

把生成的代码改成:

..relist = (json['relist'] as List) ?.map((e) => e == null ? null : Zdata.fromJson(jsonDecode(e) as Map<String, dynamic>)) ?.toList()

问题解决。

感谢提供好工具

依赖报错

Because github_client_app depends on json_model ^0.0.2 which depends on json_serializable ^2.0.0, json_serializable ^2.0.0 is required.

吹一下,给作者打打气

下面这段是我使用json_model后,遇到的一些问题,我大约有100+个的json文件,下面这段是是写在我们项目里面的,也粘贴到这里来,希望对大家能有帮助

Model自动生成注意事项

  • Model自动生成使用了json_model,使用他的主要原因是:他使用了json_serializable,性能比较好,另外他需要自建一个jsons目录,将需要处理的json文件放到这个目录,除了生成model后,还有"备份"的效果,方便后续检查问题,例如经常会出现的搞不清楚到底是json数组,还是json对象,有了这个"备份",后面就很好定位问题
  • 使用:vscode->终端->项目根目录 执行 flutter packages pub run json_model 命令 将jsons目录下的文件生成对应的model
  • 因为 json_model 现在还有一些小的bug(大多和生成后import错误相关),所以需要手里处理一些和import相关的bug
  • 将生成完并确认没有问题的json文件名前面增加 "_", 避免下次执行 flutter packages pub run json_model 命令时,重新生成model又需要手动处理import的bug
  • 现在(2020/03/02) json_model 依赖json_serializable: ^2.0.0,和 json_annotation: ^2.0.0 如果目前pubspec.yaml中的配置高于这个版本号的话,需要手动修改为^2.0.0,生成完model后,在改回更高的版本
  • 瑕不掩瑜!虽然有一些bug, 但是在整理json文件的同时,对model也有了一个整体的规划,这个扩展非常棒!

希望更新 json_serializable 依赖

Because every version of json_model depends on json_serializable ^2.0.0 and flutter_todo depends on json_serializable ^3.2.5, json_model is forbidden.

So, because flutter_todo depends on json_model ^0.0.2, version solving failed.
pub get failed (1; So, because flutter_todo depends on json_model ^0.0.2, version solving failed.)

怎么使用json生产model的任意类型

{
"code": 0,
"data": "Value",
"message": "string",
"status": "success"
}
后台一般返回这种样式,data有多种类型,怎样修改json的data可以让生产的model是任意类型dynamic,或者生产的model可以是泛型的

When adding int or String not correctly specified

When adding the core types String or int, they must not be specified, but rather an example int or String should be written. Although the provided example shows that, it's not obvious given how the other fields work. This could be explicitly clarified.

lib/models没有生成文件

执行flutter packages pub run json_model后,lib/models并没有生成文件

PS E:\AndroidStudio\github_client_app> flutter packages pub run json_model
Unhandled exception:
FormatException: Unexpected character (at line 2, character 18)
"enable":true, // 是否启用缓存
^

#0 _ChunkedJsonParser.fail (dart:convert-patch/convert_patch.dart:1405:5)
#1 _ChunkedJsonParser.parse (dart:convert-patch/convert_patch.dart:935:48)
#2 _parseJson (dart:convert-patch/convert_patch.dart:40:10)
#3 JsonDecoder.convert (dart:convert/json.dart:506:36)
#4 JsonCodec.decode (dart:convert/json.dart:157:41)
#5 generateModelClass. (file:///D:/flutter/.pub-cache/hosted/pub.flutter-io.cn/json_model-1.0.0/bin/json_model.dart:83:24)
#6 List.forEach (dart:core-patch/growable_array.dart:410:8)
#7 generateModelClass (file:///D:/flutter/.pub-cache/hosted/pub.flutter-io.cn/json_model-1.0.0/bin/json_model.dart:71:12)
#8 main (file:///D:/flutter/.pub-cache/hosted/pub.flutter-io.cn/json_model-1.0.0/bin/json_model.dart:46:14)
#9 _delayEntrypointInvocation. (dart:isolate-patch/isolate_patch.dart:295:32)
#10 _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:192:12)
pub finished with exit code 255

flutter运行命令后报错:RangeError: Value not in range: -1

Unhandled exception:
RangeError: Value not in range: -1
#0 _StringBase.substring (dart:core-patch/string_patch.dart:399:7)
#1 _parsePackageLocations (package:build_runner_core/src/package_graph/package_graph.dart:162:21)
#2 new PackageGraph.forPath (package:build_runner_core/src/package_graph/package_graph.dart:67:30)
#3 new PackageGraph.forThisPackage (package:build_runner_core/src/package_graph/package_graph.dart:98:57)
#4 new BuildCommandRunner (package:build_runner/src/entrypoint/runner.dart:27:37)
#5 run (file:///D:/A%20Program%20Files/flutter/.pub-cache/hosted/pub.flutter-io.cn/json_model-0.0.2/bin/build_runner.dart:25:23)#6 main (file:///D:/A%20Program%20Files/flutter/.pub-cache/hosted/pub.flutter-io.cn/json_model-0.0.2/bin/json_model.dart:19:5)
#7 _delayEntrypointInvocation. (dart:isolate-patch/isolate_patch.dart:281:32)
#8 _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:184:12)
pub finished with exit code 255

引依赖引不了啊。。。

C:\Users\xyz\AndroidStudioProjects\startup_namer\lib>flutter packages pub run json_model
Changing current working directory to: C:\Users\xyz\AndroidStudioProjects\startup_namer
Could not find package "json_model". Did you forget to add a dependency?
pub finished with exit code 65

自定义文件名和类名

目前as在文件命名上,如果是驼峰命名,整个文件会出现波浪纹。
警告类名为驼峰式;建议改为小写字母+‘_’;

但是我发现如果我的json文件名字为:小写字母+‘_’;那我类名与文件名是一致的。

希望能够添加命名配置,能够区分创建

遇到版本问题的同学可以用dependency_overrides先解决一下

我看到Pull requests里已经有人提交了修复,但是没有被合并,我试了了是可以用的
先把json_serializable的版本改成 ^3.5.0,然后加上下面的dependency_overrides配置,使用 @keda 的版本
yaml dependency_overrides: json_model: git: url: https://github.com/keda/json_model.git
image

@JsonKey and $[]List do together do not seem to work

{
   "@JsonKey(name: 'firebase_auth') firebaseAuth": "$[]firebaseAuth" 
}

creates:

@JsonKey(name: 'firebase_auth') firebaseAuth $[]firebaseAuth;

expected:

@JsonKey(name: 'firebase_auth') List<FirebaseAuth> firebaseAuth;

执行packages get的时候报错

image

json_serializable ^2.0.0, json_serializable ^2.0.0 is required.
So, because flutter_dayi depends on json_serializable ^3.0.0, version solving failed.
pub get failed (1)

你可能需要升级你的json_serializable版本了

How to deal with JSON index keys?

Hi there,

So, I have a JSON like this

{
    "groups": {
        "1": {
            "members": {
                "1": {
                    "id": "1",
                    "groupId": "1"
                }
            }
        },
        "2": {
            "members": {
                "1": {
                    "id": "1",
                    "groupId": "1"
                }
            }
        },
        "3": {
            "members": {
                "1": {
                    "id": "1",
                    "groupId": "1"
                }
            }
        },
        "4": {
            "members": {
                "1": {
                    "id": "1",
                    "groupId": "1"
                }
            }
        }
    }
}

It is not exactly "JSON index keys", but it is a dynamic naming number. Sometimes it will have 1, sometimes it will have 100++. How do I config this?

It would be something like this?

{
  "@JsonKey(ignore: false) unknownEnumValue": "$group_obj"
}

From another tool I can get:

class State {
    String counter;
    Map<String, Group> groups;
    State({
        this.counter,
        this.groups
    });

  factory State.fromJson(Map<String, dynamic> json) => State(
        counter: json["counter"],
        groups: Map.from(json["groups"]).map((k, v) => MapEntry<String, Group>(k, Group.fromJson(v))),
    );

    Map<String, dynamic> toJson() => {
        "counter": counter,
        "groups": Map.from(groups).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
  };
}

class Group {
    Members members;

    Group({
        this.members
    });
    factory Group.fromJson(Map<String, dynamic> json) => Group(
        members: Members.fromJson(json["members"]),
    );

    Map<String, dynamic> toJson() => {
        "members": members.toJson(),
    };
}

//so on

下划线格式命名的文件名转换为 dart 类时,类名应该转换为驼峰命名

例如 user_entity.json 生成的 dart 类,类名应该是 UserEntity 而不是 User_entity,这样是不符合 dart 语法规范的,并且 AS 直接就警告语法有问题。

json 数据中的字段名转换规则应该也是一样的,例如键名 user_name 应该转换为 userName,而不是保持原名。

求大佬更新支持以上两个特性,不然每次运行命令生成文件都要自己手动改名字,而且因为每次运行命令都是重新生成文件,所以之前改好的文件还需要备份,再替换新文件,反而比使用其他插件手动生成 dart 类麻烦更多。

解析嵌套json数据出现问题

json代码示例

{
  "data":[
    {
      "desc":"Android高级进阶直播课免费学习",
      "id":22,
      "imagePath":"https://wanandroid.com/blogimgs/fbed8f14-1043-4a43-a7ee-0651996f7c49.jpeg",
      "isVisible":1,
      "order":0,
      "title":"Android高级进阶直播课免费学习",
      "type":0,
      "url":"https://url.163.com/4bj"
    },
    {
      "desc":"一起来做个App吧",
      "id":10,
      "imagePath":"https://www.wanandroid.com/blogimgs/50c115c2-cf6c-4802-aa7b-a4334de444cd.png",
      "isVisible":1,
      "order":2,
      "title":"一起来做个App吧",
      "type":0,
      "url":"http://www.wanandroid.com/blog/show/2"
    },
    {
      "desc":"",
      "id":4,
      "imagePath":"https://www.wanandroid.com/blogimgs/ab17e8f9-6b79-450b-8079-0f2287eb6f0f.png",
      "isVisible":1,
      "order":0,
      "title":"看看别人的面经,搞定面试~",
      "type":1,
      "url":"http://www.wanandroid.com/article/list/0?cid=73"
    },
    {
      "desc":"",
      "id":3,
      "imagePath":"https://www.wanandroid.com/blogimgs/fb0ea461-e00a-482b-814f-4faca5761427.png",
      "isVisible":1,
      "order":1,
      "title":"兄弟,要不要挑个项目学习下?",
      "type":1,
      "url":"http://www.wanandroid.com/project"
    },
    {
      "desc":"",
      "id":6,
      "imagePath":"https://www.wanandroid.com/blogimgs/62c1bd68-b5f3-4a3c-a649-7ca8c7dfabe6.png",
      "isVisible":1,
      "order":1,
      "title":"我们新增了一个常用导航Tab~",
      "type":1,
      "url":"http://www.wanandroid.com/navi"
    },
    {
      "desc":"",
      "id":18,
      "imagePath":"https://www.wanandroid.com/blogimgs/00f83f1d-3c50-439f-b705-54a49fc3d90d.jpg",
      "isVisible":1,
      "order":1,
      "title":"公众号文章列表强势上线",
      "type":1,
      "url":"http://www.wanandroid.com/wxarticle/list/408/1"
    },
    {
      "desc":"",
      "id":2,
      "imagePath":"https://www.wanandroid.com/blogimgs/90cf8c40-9489-4f9d-8936-02c9ebae31f0.png",
      "isVisible":1,
      "order":2,
      "title":"JSON工具",
      "type":1,
      "url":"http://www.wanandroid.com/tools/bejson"
    },
  ],
  "errorCode":0,
  "errorMsg":""
}

运行flutter packages pub run json_model生成model示例

import 'package:json_annotation/json_annotation.dart';

part 'banner.g.dart';

@JsonSerializable()
class Banner {
    Banner();

    List data;
    num errorCode;
    String errorMsg;
    
    factory Banner.fromJson(Map<String,dynamic> json) => _$BannerFromJson(json);
    Map<String, dynamic> toJson() => _$BannerToJson(this);
}

type 'DynamicTypeImpl' is not a subtype of type 'InterfaceType'

经常碰到这个错误,有时候卡半天,有人碰到过吗?

Please file an issue with reproduction steps at https://github.com/dart-lang/build/issues                                
                                                                                                                         
                                                                                                                         
type 'DynamicTypeImpl' is not a subtype of type 'InterfaceType'                                                          
package:analyzer/src/summary/link.dart 5535:5                     TypeProviderForLink._buildInterfaceType                
package:analyzer/src/summary/link.dart 5503:23                    TypeProviderForLink.objectType                         
package:analyzer/src/summary/link.dart 925:67                     ClassElementForLink_Class._computeInterfaceType        
package:analyzer/src/summary/link.dart 823:27                     ClassElementForLink_Class.supertype                    
package:analyzer/src/task/strong_mode.dart 303:33                 InstanceMemberInferrer._inferClass                     
package:analyzer/src/task/strong_mode.dart 335:9                  InstanceMemberInferrer._inferClasses                   
package:analyzer/src/task/strong_mode.dart 56:5                   InstanceMemberInferrer.inferCompilationUnit            
package:analyzer/src/summary/link.dart 1627:7                     CompilationUnitElementInBuildUnit.link                 
package:analyzer/src/summary/link.dart 3840:12                    LibraryElementInBuildUnit.link                         
package:analyzer/src/summary/link.dart 3540:15                    LibraryCycleNode.link                                  
package:analyzer/src/summary/link.dart 3480:7                     LibraryCycleDependencyWalker.evaluate                  
package:analyzer/src/summary/link.dart 2213:13                    DependencyWalker.walk.strongConnect                    
package:analyzer/src/summary/link.dart 2232:18                    DependencyWalker.walk                                  
package:analyzer/src/summary/link.dart 3513:42                    LibraryCycleForLink.ensureLinked                       
package:analyzer/src/summary/link.dart 4045:35                    Linker.link                                            
package:analyzer/src/summary/link.dart 311:74                     _relink                                                
package:analyzer/src/summary/link.dart 125:3                      link                                                   

.........

多个@JsonKey使用,只有最后一个属性输出

`
{
"Euid": "sample string 1",

"Name": "sample string 2",

"DepartmentId": "sample string 3",

"@jsonkey(ignore: true) String":"Pinyin",

"@jsonkey(ignore: true) String":"firstName",

"@jsonkey(ignore: true) String":"tagIndex"
}
`
执行命令后输出如下

`@JsonSerializable()
class Employee {
Employee();

String Euid;
String Name;
String DepartmentId;
@JsonKey(ignore: true) String tagIndex;

factory Employee.fromJson(Map<String,dynamic> json) => _$EmployeeFromJson(json);
Map<String, dynamic> toJson() => _$EmployeeToJson(this);

}
`
带有@jsonkey的只输出了最后一个,希望可以解决,大佬!!!

不兼容json_serializable高版本

Because every version of json_model depends on json_serializable ^2.0.0 and flutter depends on json_serializable ^3.5.1, json_model is forbidden.
So, because flutter depends on json_model any, version solving failed.
pub get failed (1; So, because flutter depends on json_model any, version solving failed.)

建议(支持嵌套,类名/字段名适配驼峰命名,支持DateTime类型等)

以下是我修改的mo.dart,有############的地方是修改过的

import 'dart:convert';
import 'dart:io';
import 'package:path/path.dart' as path;

const TAG = "\$";
const SRC = "./json"; //JSON 目录
const DIST = "lib/models/"; //输出model目录

void walk() {
  //遍历JSON目录生成模板
  var src = new Directory(SRC);
  var list = src.listSync();
  /// #############################
  /// 调整了下格式问题,生成的model不用再格式化了
  var template = "import 'package:json_annotation/json_annotation.dart';\r\n%t\npart '%s.g.dart';\r\n\r\n@JsonSerializable()\r\nclass %s {\r\n  %s();\r\n\r\n  %sfactory %s.fromJson(Map<String, dynamic> json) => _\$%sFromJson(json);\r\n\r\n  Map<String, dynamic> toJson() => _\$%sToJson(this);\r\n}\r\n";
  File file;
  list.forEach((f) {
    if (FileSystemEntity.isFileSync(f.path)) {
      file = new File(f.path);
      var paths = path.basename(f.path).split(".");
      String name = paths.first;
      if (paths.last.toLowerCase() != "json" || name.startsWith("_")) return;
      if (name.startsWith("_")) return;
      //下面生成模板
      var map = json.decode(file.readAsStringSync());
      //为了避免重复导入相同的包,我们用Set来保存生成的import语句。
      var set = new Set<String>();
      StringBuffer attrs = new StringBuffer();
      (map as Map<String, dynamic>).forEach((key, v) {
        if (key.startsWith("_")) return;
        /// #############################
        ///处理key包含"_"时,转为驼峰并加上@JsonKey(name="key")
        if (key.contains("_")) {
          attrs.write('@JsonKey(name: "$key")');
          attrs.write("\r\n  ");
          attrs.write(getType(v, set, name));
          attrs.write(" ");
          attrs.write(changeToCamelCase(key, false));
          attrs.writeln(";");
          attrs.write("\r\n  ");
        } else {
          attrs.write(getType(v, set, name));
          attrs.write(" ");
          attrs.write(key);
          attrs.writeln(";");
          attrs.write("\r\n  ");
        }
      });
      String className = "";
      /// #############################
      ///处理有"_"时class不是驼峰命名
      if (name.contains("_")) {
        className = changeToCamelCase(name, true);
      } else {
        className = name[0].toUpperCase() + name.substring(1);
      }
      var dist = format(template, [
        name,
        className,
        className,
        attrs.toString(),
        className,
        className,
        className
      ]);
      var _import = set.join(";\r\n");
      _import += _import.isEmpty ? "" : ";";
      dist = dist.replaceFirst("%t", _import);
      //将生成的模板输出
      new File("$DIST$name.dart").writeAsStringSync(dist);
    }
  });
}
/// #############################
///转为驼峰命名
///big 是否大驼峰
String changeToCamelCase(String word, bool big) {
  if (word.contains("_")) {
    String result = "";
    List<String> words = word.split("_");
    for (var value in words) {
      result += (value[0].toUpperCase() + value.substring(1).toLowerCase());
    }
    return big ? result : (result[0].toLowerCase() + result.substring(1));
  } else {
    return big
        ? word[0].toUpperCase() + word.substring(1)
        : word[0].toLowerCase() + word.substring(1);
  }
}

String changeFirstChar(String str, [bool upper = true]) {
  return (upper ? str[0].toUpperCase() : str[0].toLowerCase()) +
      str.substring(1);
}

//将JSON类型转为对应的dart类型
String getType(v, Set<String> set, String current) {
  current = current.toLowerCase();
  if (v is bool) {
    return "bool";
  } else if (v is num) {
    return "num";
  } else if (v is Map) {
    return "Map<String,dynamic>";
  } else if (v is List) {
    return "List";
  } else if (v is String) {
    /// #############################
    ///添加DateTime类型
    try {
      DateTime dateTime = DateTime.parse(v);
      if (dateTime != null) {
        return "DateTime";
      }
    } catch (e) {}

    //处理特殊标志
    if (v.startsWith("$TAG[]")) {
      var className = changeFirstChar(v.substring(3), false);
      if (className.toLowerCase() != current) {
        set.add('import "$className.dart"');
      }
      /// #############################
      /// 自定义model类型名字大驼峰命名
      return "List<${changeToCamelCase(className, true)}>";
    } else if (v.startsWith(TAG)) {
      var fileName = changeFirstChar(v.substring(1), false);
      if (fileName.toLowerCase() != current) {
        set.add('import "$fileName.dart"');
      }
      /// #############################
      /// 自定义model类型名字大驼峰命名
      return changeToCamelCase(fileName, true);
    }
    return "String";
  } else {
    return "String";
  }
}

//替换模板占位符
String format(String fmt, List<Object> params) {
  int matchIndex = 0;
  String replace(Match m) {
    if (matchIndex < params.length) {
      switch (m[0]) {
        case "%s":
          return params[matchIndex++].toString();
      }
    } else {
      throw new Exception("Missing parameter for string format");
    }
    throw new Exception("Invalid format string: " + m[0].toString());
  }

  return fmt.replaceAllMapped("%s", replace);
}

void main() {
  walk();
}

多层嵌套怎么玩

如:{
"code": 200,
"message": "",
"data": {
"total": 14,
"list": [
{
"id": 30,
"user_id": 50,
"title": "撒旦发射点",
"content": "士大夫士大夫士大夫",
"type": "routine",
"book_name": "",
"hide_flag": 0,
"status": 1,
"ptime": "2020-01-02 15:10:52",
"mtime": "2020-01-02 15:10:52",
"members": [
{
"id": 50,
"account": "qqqqqq",
"user_name": "qqqqqq",
"user_abbr": "qq",
"user_backcolor": "#FF7765",
"user_headicon": "data:image/png;base64,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",
"ptime": "2019-12-24 16:21:18"
}
],
"creator": {
"id": 50,
"account": "qqqqqq",
"user_name": "qqqqqq",
"user_abbr": "qq",
"user_backcolor": "#FF7765",
"user_headicon": "data:image/png;base64,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",
"ptime": "2019-12-24 16:21:18"
}
},
{
"id": 24,
"user_id": 5,
"title": "test title",
"content": "test summary",
"type": "routine",
"book_name": "",
"hide_flag": 0,
"status": 1,
"ptime": "2019-12-31 15:54:05",
"mtime": "2020-01-02 14:42:51",
"members": [
{
"id": 5,
"account": "cc",
"user_name": "ccpp",
"user_abbr": "cc",
"user_backcolor": "#FFB800",
"user_headicon": "data:image/png;base64,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",
"ptime": "2019-06-25 14:06:36"
}
],
"creator": {
"id": 5,
"account": "cc",
"user_name": "ccpp",
"user_abbr": "cc",
"user_backcolor": "#FFB800",
"user_headicon": "data:image/png;base64,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",
"ptime": "2019-06-25 14:06:36"
}
},
{
"id": 7,
"user_id": 52,
"title": "dfgdfg",
"content": "gfhghf",
"type": "book",
"book_name": "左手老子右手孔子——感悟**式智慧",
"hide_flag": 0,
"status": 1,
"ptime": "2019-12-31 11:44:50",
"mtime": "2019-12-31 17:27:43",
"members": [
{
"id": 8,
"account": "chenzhen",
"user_name": "mmuf",
"user_abbr": "mm",
"user_backcolor": "#169BD5",
"user_headicon": "",
"ptime": "2019-07-01 17:13:14"
},
{
"id": 52,
"account": "yyyyy",
"user_name": "yyyyy",
"user_abbr": "yy",
"user_backcolor": "#FF7765",
"user_headicon": "",
"ptime": "2019-12-31 11:39:31"
}
],
"creator": {
"id": 52,
"account": "yyyyy",
"user_name": "yyyyy",
"user_abbr": "yy",
"user_backcolor": "#FF7765",
"user_headicon": "",
"ptime": "2019-12-31 11:39:31"
}
},
{
"id": 27,
"user_id": 8,
"title": "dfgdffg",
"content": "dfgdfggjhgjg",
"type": "book",
"book_name": "电报与**近代史:触电的帝国",
"hide_flag": 0,
"status": 1,
"ptime": "2019-12-31 16:28:47",
"mtime": "2019-12-31 16:28:47",
"members": [
{
"id": 52,
"account": "yyyyy",
"user_name": "yyyyy",
"user_abbr": "yy",
"user_backcolor": "#FF7765",
"user_headicon": "",
"ptime": "2019-12-31 11:39:31"
},
{
"id": 8,
"account": "chenzhen",
"user_name": "mmuf",
"user_abbr": "mm",
"user_backcolor": "#169BD5",
"user_headicon": "",
"ptime": "2019-07-01 17:13:14"
}
],
"creator": {
"id": 8,
"account": "chenzhen",
"user_name": "mmuf",
"user_abbr": "mm",
"user_backcolor": "#169BD5",
"user_headicon": "",
"ptime": "2019-07-01 17:13:14"
}
},
{
"id": 26,
"user_id": 8,
"title": "dfgdfgd",
"content": "dfgdfgdfg",
"type": "book",
"book_name": "**绘画史(**绘画界的“国家宝藏”)",
"hide_flag": 0,
"status": 1,
"ptime": "2019-12-31 16:25:38",
"mtime": "2019-12-31 16:25:38",
"members": [
{
"id": 8,
"account": "chenzhen",
"user_name": "mmuf",
"user_abbr": "mm",
"user_backcolor": "#169BD5",
"user_headicon": "",
"ptime": "2019-07-01 17:13:14"
}
],
"creator": {
"id": 8,
"account": "chenzhen",
"user_name": "mmuf",
"user_abbr": "mm",
"user_backcolor": "#169BD5",
"user_headicon": "",
"ptime": "2019-07-01 17:13:14"
}
}
]
}
}
这样的

mobx_codegen: ^1.0.3 与 json_model: ^0.0.2存在 build_runner版本冲突

And because mobx_codegen >=0.1.3 depends on build ^1.1.4 and mobx_codegen >=0.4.2 depends on build_resolvers ^1.3.2, mobx_codegen >=0.4.2 requires build ^1.2.0.
And because json_model 0.0.2 depends on build >=1.0.0 <1.2.0 and no versions of json_model match >0.0.2 <0.1.0, mobx_codegen >=0.4.2 is incompatible with json_model ^0.0.2.
So, because network depends on both json_model ^0.0.2 and mobx_codegen ^1.0.3, version solving failed.
pub get failed (1; So, because network depends on both json_model ^0.0.2 and mobx_codegen ^1.0.3, version solving failed.)
exit code 1

生成的model没有 xx.g.dart的问题的解决方法

1、pubspec.yaml中添加依赖为:

dependencies:
json_annotation: ^2.0.0 --- 版本号必须是2.0.0

dev_dependencies:
flutter_test:
sdk: flutter
json_model: ^0.0.2
build_runner: ^1.0.0 --- 版本号必须是1.0.0
json_serializable: ^2.0.0 --- 版本号必须是2.0.0

在Terminal中运行 flutter packages pub run json_model ,若不成功,再看下一步。

2、(1) 运行Flutter Clean,点击 Tools - Flutter - Flutter Clean, 目的是删除 .dart_tool文件夹。
(2)运行Flutter packages get,点击 Tools - Flutter - Flutter packages get 。
(3)在Terminal中运行 flutter packages pub run json_model ,此时会报下面的错,不用管,继续下一步:
Failed to precompile json_model:build_runner:
Dart_LoadScriptFromKernel: The binary program does not contain 'main'.
(4)继续在Terminal中运行 flutter packages pub run json_model,此时就可成功。
(5)若上一步还没有成功,建议:新建一个项目,把lib, jsons, images 等复制到新项目中,在运行
flutter packages pub run json_model,然后删除原项目。

版本不兼容

And because uuid >=3.0.0 depends on crypto ^3.0.0, cached_network_image >=3.0.0 requires crypto ^3.0.0.
And because every version of json_model depends on build >=1.0.0 <1.2.0 which depends on crypto >=0.9.2 <3.0.0, cached_network_image >=3.0.0 is incompatible with json_model.
So, because groupbuy depends on both cached_network_image ^3.0.0 and json_model any, version solving failed.
pub get failed (1; So, because groupbuy depends on both cached_network_image ^3.0.0 and json_model any, version solving failed.)
exit code 1

运行`flutter packages pub run json_model` 命令报错

The method 'cleanFor' isn't defined for the class 'CleanCommand'.

  • 'CleanCommand' is from 'file:///Users/canday/.pub-cache/hosted/pub.flutter-io.cn/json_model-0.0.2/bin/src/commands/clean.dart'.
    Try correcting the name to the name of an existing method, or defining a method named 'cleanFor'.
    await cleanFor(assetGraphPathFor(scriptLocation), logger);

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.