Beispiel #1
1
// EncodeToStream serializes the provided object to the given writer. Overrides is ignored.
func (s *Serializer) EncodeToStream(obj runtime.Object, w io.Writer, overrides ...unversioned.GroupVersion) error {
	if s.yaml {
		json, err := json.Marshal(obj)
		if err != nil {
			return err
		}
		data, err := yaml.JSONToYAML(json)
		if err != nil {
			return err
		}
		_, err = w.Write(data)
		return err
	}

	if s.pretty {
		data, err := json.MarshalIndent(obj, "", "  ")
		if err != nil {
			return err
		}
		_, err = w.Write(data)
		return err
	}
	encoder := json.NewEncoder(w)
	return encoder.Encode(obj)
}
func JSONToYAMLOrDie(in []byte) []byte {
	data, err := yaml.JSONToYAML(in)
	if err != nil {
		panic(err)
	}
	return data
}
Beispiel #3
0
func testObjects(t *testing.T, list *api.List, fixtureFilename string) {
	filename := filepath.Join("../../../../test/fixtures/bootstrappolicy", fixtureFilename)
	expectedYAML, err := ioutil.ReadFile(filename)
	if err != nil {
		t.Fatal(err)
	}

	if err := runtime.EncodeList(api.Codecs.LegacyCodec(v1.SchemeGroupVersion), list.Items); err != nil {
		t.Fatal(err)
	}

	jsonData, err := runtime.Encode(api.Codecs.LegacyCodec(v1.SchemeGroupVersion), list)
	if err != nil {
		t.Fatal(err)
	}
	yamlData, err := yaml.JSONToYAML(jsonData)
	if err != nil {
		t.Fatal(err)
	}
	if string(yamlData) != string(expectedYAML) {
		fmt.Println("Bootstrap policy data does not match the test fixture in " + filename)
		fmt.Println("If the change is expected, update the fixture with this bootstrap policy data:")
		fmt.Println("-----------------------------------")
		fmt.Println(string(yamlData))
		fmt.Println("-----------------------------------")
		t.Errorf("Diff between bootstrap data and fixture data in %s:\n-------------\n%s", filename, util.StringDiff(string(yamlData), string(expectedYAML)))
	}
}
func jsonToYAML(j []byte) []byte {
	y, err := yaml.JSONToYAML(j)
	if err != nil {
		panic(fmt.Sprintf("json to yaml failed: %v", err))
	}
	return y
}
Beispiel #5
0
func jsonToYAML(j []byte) ([]byte, error) {
	y, err := yaml.JSONToYAML(j)
	if err != nil {
		return nil, fmt.Errorf("json to yaml failed: %v\n%v\n", err, j)
	}

	return y, nil
}
Beispiel #6
0
func json2Yaml(json []byte) (s string) {
	if y, err := yaml.JSONToYAML(json); err != nil {
		s = err.Error()
	} else {
		s = string(y)
	}
	return
}
// Write serializes the config to yaml.
// Encapsulates serialization without assuming the destination is a file.
func Write(config clientcmdapi.Config) ([]byte, error) {
	json, err := clientcmdlatest.Codec.Encode(&config)
	if err != nil {
		return nil, err
	}
	content, err := yaml.JSONToYAML(json)
	if err != nil {
		return nil, err
	}
	return content, nil
}
Beispiel #8
0
func JsonToYaml(inputBytes []byte) []byte {
	buffer, err := yaml.JSONToYAML(inputBytes)

	if err != nil {
		fmt.Println("JSON -> YAML convert error.")
		fmt.Printf("err: %v\n", err)
		os.Exit(1)
	}

	return buffer
}
Beispiel #9
0
func writeYAML(obj runtime.Object) ([]byte, error) {
	json, err := Codec.Encode(obj)
	if err != nil {
		return nil, err
	}

	content, err := yaml.JSONToYAML(json)
	if err != nil {
		return nil, err
	}
	return content, err
}
func ExampleMergingSomeWithConflict() {
	commandLineFile, _ := ioutil.TempFile("", "")
	defer os.Remove(commandLineFile.Name())
	envVarFile, _ := ioutil.TempFile("", "")
	defer os.Remove(envVarFile.Name())

	WriteToFile(testConfigAlfa, commandLineFile.Name())
	WriteToFile(testConfigConflictAlfa, envVarFile.Name())

	loadingRules := ClientConfigLoadingRules{
		CommandLinePath: commandLineFile.Name(),
		EnvVarPath:      envVarFile.Name(),
	}

	mergedConfig, err := loadingRules.Load()

	json, err := clientcmdlatest.Codec.Encode(mergedConfig)
	if err != nil {
		fmt.Printf("Unexpected error: %v", err)
	}
	output, err := yaml.JSONToYAML(json)
	if err != nil {
		fmt.Printf("Unexpected error: %v", err)
	}

	fmt.Printf("%v", string(output))
	// Output:
	// apiVersion: v1
	// clusters:
	// - cluster:
	//     server: http://cow.org:8080
	//   name: cow-cluster
	// - cluster:
	//     insecure-skip-tls-verify: true
	//     server: http://donkey.org:8080
	//   name: donkey-cluster
	// contexts:
	// - context:
	//     cluster: cow-cluster
	//     namespace: hammer-ns
	//     user: red-user
	//   name: federal-context
	// current-context: federal-context
	// kind: Config
	// preferences: {}
	// users:
	// - name: red-user
	//   user:
	//     token: red-token
	// - name: yellow-user
	//   user:
	//     token: yellow-token
}
Beispiel #11
0
// writeYAML writes the specified object to a byte array as yaml.
func writeYAML(obj runtime.Object) ([]byte, error) {
	json, err := runtime.Encode(api.Codecs.LegacyCodec(), obj)
	if err != nil {
		return nil, err
	}

	content, err := yaml.JSONToYAML(json)
	if err != nil {
		return nil, err
	}
	return content, err
}
Beispiel #12
0
func writeYAML(obj runtime.Object) ([]byte, error) {

	json, err := runtime.Encode(serializer.NewCodecFactory(internal.Scheme).LegacyCodec(v1.SchemeGroupVersion), obj)
	if err != nil {
		return nil, err
	}

	content, err := yaml.JSONToYAML(json)
	if err != nil {
		return nil, err
	}
	return content, err
}
Beispiel #13
0
// CmdShow implements the 'show' command
func CmdShow(c *cli.Context) {
	utils.CheckRequiredFlags(c, []string{"kubeware"})

	kubeware := os.Getenv("KDEPLOY_KUBEWARE")
	localKubePath, err := fetchers.Fetch(kubeware)
	if err != nil {
		log.Fatal(fmt.Errorf("Could not fetch kubeware: '%s' (%v)", kubeware, err))
	}

	log.Debugf("Going to parse kubeware in %s", localKubePath)

	metadata := template.ParseMetadata(localKubePath)
	defaults, err := metadata.AttributeDefaults()
	utils.CheckError(err)

	log.Debugf("Building attributes")
	attributes := template.BuildAttributes(os.Getenv("KDEPLOY_ATTRIBUTE"), defaults)

	log.Debugf("Parsing services")
	servicesSpecs, err := metadata.ParseServices(attributes)
	utils.CheckError(err)

	log.Debugf("Parsing controllers")
	controllersSpecs, err := metadata.ParseControllers(attributes)
	utils.CheckError(err)

	// print resolved resources
	for _, s := range servicesSpecs {
		y, err := gyml.JSONToYAML([]byte(s))
		utils.CheckError(err)
		fmt.Println(string(y))
	}
	for _, c := range controllersSpecs {
		y, err := gyml.JSONToYAML([]byte(c))
		utils.CheckError(err)
		fmt.Println(string(y))
	}
}
Beispiel #14
0
//go:generate goversion -major=1 -minor=0 -patch=0
func main() {

	bytes, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		log.Panicln(err)
	}

	json, err := yaml.JSONToYAML(bytes)
	if err != nil {
		log.Panicln(err)
	}

	print(string(json))
}
Beispiel #15
0
func Example_noMergingOnExplicitPaths() {
	commandLineFile, _ := ioutil.TempFile("", "")
	defer os.Remove(commandLineFile.Name())
	envVarFile, _ := ioutil.TempFile("", "")
	defer os.Remove(envVarFile.Name())

	WriteToFile(testConfigAlfa, commandLineFile.Name())
	WriteToFile(testConfigConflictAlfa, envVarFile.Name())

	loadingRules := ClientConfigLoadingRules{
		ExplicitPath: commandLineFile.Name(),
		Precedence:   []string{envVarFile.Name()},
	}

	mergedConfig, err := loadingRules.Load()

	json, err := runtime.Encode(clientcmdlatest.Codec, mergedConfig)
	if err != nil {
		fmt.Printf("Unexpected error: %v", err)
	}
	output, err := yaml.JSONToYAML(json)
	if err != nil {
		fmt.Printf("Unexpected error: %v", err)
	}

	fmt.Printf("%v", string(output))
	// Output:
	// apiVersion: v1
	// clusters:
	// - cluster:
	//     server: http://cow.org:8080
	//   name: cow-cluster
	// contexts:
	// - context:
	//     cluster: cow-cluster
	//     namespace: hammer-ns
	//     user: red-user
	//   name: federal-context
	// current-context: ""
	// kind: Config
	// preferences: {}
	// users:
	// - name: red-user
	//   user:
	//     token: red-token
}
Beispiel #16
0
func testObjects(t *testing.T, list *api.List, fixtureFilename string) {
	filename := filepath.Join("testdata", fixtureFilename)
	expectedYAML, err := ioutil.ReadFile(filename)
	if err != nil {
		t.Fatal(err)
	}

	if err := runtime.EncodeList(api.Codecs.LegacyCodec(v1.SchemeGroupVersion, rbacv1alpha1.SchemeGroupVersion), list.Items); err != nil {
		t.Fatal(err)
	}

	jsonData, err := runtime.Encode(api.Codecs.LegacyCodec(v1.SchemeGroupVersion, rbacv1alpha1.SchemeGroupVersion), list)
	if err != nil {
		t.Fatal(err)
	}
	yamlData, err := yaml.JSONToYAML(jsonData)
	if err != nil {
		t.Fatal(err)
	}
	if string(yamlData) != string(expectedYAML) {
		t.Errorf("Bootstrap policy data does not match the test fixture in %s", filename)

		const updateEnvVar = "UPDATE_BOOTSTRAP_POLICY_FIXTURE_DATA"
		if os.Getenv(updateEnvVar) == "true" {
			if err := ioutil.WriteFile(filename, []byte(yamlData), os.FileMode(0755)); err == nil {
				t.Logf("Updated data in %s", filename)
				t.Logf("Verify the diff, commit changes, and rerun the tests")
			} else {
				t.Logf("Could not update data in %s: %v", filename, err)
			}
		} else {
			t.Logf("Diff between bootstrap data and fixture data in %s:\n-------------\n%s", filename, diff.StringDiff(string(yamlData), string(expectedYAML)))
			t.Logf("If the change is expected, re-run with %s=true to update the fixtures", updateEnvVar)
		}
	}
}
func ExampleMergingEverythingNoConflicts() {
	commandLineFile, _ := ioutil.TempFile("", "")
	defer os.Remove(commandLineFile.Name())
	envVarFile, _ := ioutil.TempFile("", "")
	defer os.Remove(envVarFile.Name())
	currentDirFile, _ := ioutil.TempFile("", "")
	defer os.Remove(currentDirFile.Name())
	homeDirFile, _ := ioutil.TempFile("", "")
	defer os.Remove(homeDirFile.Name())

	WriteToFile(testConfigAlfa, commandLineFile.Name())
	WriteToFile(testConfigBravo, envVarFile.Name())
	WriteToFile(testConfigCharlie, currentDirFile.Name())
	WriteToFile(testConfigDelta, homeDirFile.Name())

	loadingRules := ClientConfigLoadingRules{
		CommandLinePath:      commandLineFile.Name(),
		EnvVarPath:           envVarFile.Name(),
		CurrentDirectoryPath: currentDirFile.Name(),
		HomeDirectoryPath:    homeDirFile.Name(),
	}

	mergedConfig, err := loadingRules.Load()

	json, err := clientcmdlatest.Codec.Encode(mergedConfig)
	if err != nil {
		fmt.Printf("Unexpected error: %v", err)
	}
	output, err := yaml.JSONToYAML(json)
	if err != nil {
		fmt.Printf("Unexpected error: %v", err)
	}

	fmt.Printf("%v", string(output))
	// Output:
	// 	apiVersion: v1
	// clusters:
	// - cluster:
	//     server: http://chicken.org:8080
	//   name: chicken-cluster
	// - cluster:
	//     server: http://cow.org:8080
	//   name: cow-cluster
	// - cluster:
	//     server: http://horse.org:8080
	//   name: horse-cluster
	// - cluster:
	//     server: http://pig.org:8080
	//   name: pig-cluster
	// contexts:
	// - context:
	//     cluster: cow-cluster
	//     namespace: hammer-ns
	//     user: red-user
	//   name: federal-context
	// - context:
	//     cluster: chicken-cluster
	//     namespace: plane-ns
	//     user: blue-user
	//   name: gothic-context
	// - context:
	//     cluster: pig-cluster
	//     namespace: saw-ns
	//     user: black-user
	//   name: queen-anne-context
	// - context:
	//     cluster: horse-cluster
	//     namespace: chisel-ns
	//     user: green-user
	//   name: shaker-context
	// current-context: ""
	// kind: Config
	// preferences: {}
	// users:
	// - name: black-user
	//   user:
	//     token: black-token
	// - name: blue-user
	//   user:
	//     token: blue-token
	// - name: green-user
	//   user:
	//     token: green-token
	// - name: red-user
	//   user:
	//     token: red-token
}
Beispiel #18
0
Datei: calls.go Projekt: kego/ke
func (s *Server) Save(request *shared.SaveRequest, response *shared.SaveResponse) error {
	if !s.auth.Auth([]byte(request.Path), request.Hash) {
		return kerr.New("GIONMMGOWA", "Auth failed")
	}
	pkg, err := pkghelp.Scan(s.ctx, request.Path)
	if err != nil {
		return kerr.Wrap("YKYVDSDGNV", err)
	}
	localContext := envctx.NewContext(s.ctx, pkg.Env)
	for _, info := range request.Files {

		// Check we only have yml, yaml or json extension.
		ext := filepath.Ext(info.File)
		if ext != ".json" && ext != ".yml" && ext != ".yaml" {
			return kerr.New("NDTPTCDOET", "Unsupported extension %s in %s", ext, info.File)
		}

		// Check the bytes are well formed json...
		o := &system.ObjectStub{}
		if err := system.Unmarshal(localContext, info.Bytes, o); err != nil {
			return kerr.Wrap("QISVPOXTCJ", err)
		}
		// Check type field exists
		if o.Type == nil {
			return kerr.New("PHINYFTGEC", "%s has no type", info.File)
		}
		// Check id field exists apart from system:package type.
		if o.Id == nil && *o.Type != *system.NewReference("kego.io/system", "package") {
			return kerr.New("NNOEQPRQXS", "%s has no id", info.File)
		}
		// Convert output to YAML if needed.
		output := info.Bytes
		if ext == ".yaml" || ext == ".yml" {
			var err error
			if output, err = yaml.JSONToYAML(output); err != nil {
				return kerr.Wrap("EAMEWSCAGB", err)
			}
		}

		var mode os.FileMode
		var full string

		file := pkg.File(info.File)
		if file != nil {
			// The file already exists, so we should use the existing filemode
			full = file.AbsoluteFilepath
			fs, err := os.Stat(full)
			if err != nil {
				return kerr.Wrap("VLIJSSVSXU", err)
			}
			mode = fs.Mode()
		} else {
			if full, err = pkghelp.Check(pkg.Env.Dir, info.File, pkg.Env.Recursive); err != nil {
				return kerr.Wrap("YSQEHPFIVF", err)
			}
			mode = 0644
			if _, err := os.Stat(full); err == nil || !os.IsNotExist(err) {
				return kerr.New("XOEPAUNCXB", "Can't overwrite %s - existing file is not a valid ke data file", info.File)
			}
		}

		if err := ioutil.WriteFile(full, output, mode); err != nil {
			return kerr.Wrap("KPDYGCYOYQ", err)
		}

		response.Files = append(response.Files, shared.SaveResponseFile{
			File: info.File,
			Hash: info.Hash,
		})
	}
	return nil
}
Beispiel #19
0
func yamlFormatter(data []byte) {
	out, err := yaml.JSONToYAML(data)
	Check(err)
	fmt.Print(string(out))
}
Beispiel #20
0
func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	flag.CommandLine.SetNormalizeFunc(util.WordSepNormalizeFunc)
	flag.Parse()

	if *rewrite != "" {
		*inputSource = *rewrite
		*outputDest = *rewrite
	}

	var in io.Reader
	if *inputSource == "-" {
		in = os.Stdin
	} else {
		f, err := os.Open(*inputSource)
		if err != nil {
			log.Fatalf("Couldn't open %q: %q", *inputSource, err)
		}
		defer f.Close()
		in = f
	}

	data, err := ioutil.ReadAll(in)
	if err != nil {
		log.Fatalf("Couldn't read from input: %q", err)
	}
	isYAML := isYAML(data)

	if isYAML {
		data, err = yaml.YAMLToJSON(data)
		if err != nil {
			log.Fatalf("Failed to convert YAML to JSON: %q", err)
		}
	}
	obj, err := api.Scheme.Decode(data)
	if err != nil {
		log.Fatalf("Couldn't decode input: %q", err)
	}

	outData, err := api.Scheme.EncodeToVersion(obj, *outputVersion)
	if err != nil {
		log.Fatalf("Failed to encode to version %q: %q", *outputVersion, err)
	}

	if isYAML {
		outData, err = yaml.JSONToYAML(outData)
		if err != nil {
			log.Fatalf("Failed to convert to YAML: %q", err)
		}
	} else if true {
		// TODO: figure out if input JSON was pretty.
		var buf bytes.Buffer
		err = json.Indent(&buf, outData, "", "  ")
		if err != nil {
			log.Fatalf("Failed to indent JSON: %q", err)
		}
		outData = buf.Bytes()
	}

	var out io.Writer
	if *outputDest == "-" {
		out = os.Stdout
	} else {
		f, err := os.Create(*outputDest)
		if err != nil {
			log.Fatalf("Couldn't open %q: %q", *outputDest, err)
		}
		defer f.Close()
		out = f
	}

	if _, err = out.Write(outData); err != nil {
		log.Fatalf("Failed to write: %q", err)
	}
}
Beispiel #21
0
func main() {

	viper.SetConfigType("yaml")
	viper.AddConfigPath(".")
	viper.SetConfigName("config") // name of config file (without extension)
	err := viper.ReadInConfig()   // Find and read the config file
	if err != nil {               // Handle errors reading the config file
		panic(fmt.Errorf("Fatal error config file: %s \n", err))
	}
	file2, err := ioutil.ReadFile(viper.GetString("yaml"))
	if err != nil { // Handle errors reading the config file
		panic(fmt.Errorf("Fatal error mangas file: %s \n", err))
	}
	mangas := &Mangas{}
	file, _ := yaml.YAMLToJSON(file2)
	json.Unmarshal(file, &mangas)

	var syncMalCmd = &cobra.Command{
		Use:   "syncMal",
		Short: "Sync MyAnimelist manga list with config file",
		Long: `Sync MyAnimelist manga list to config file in Yaml.
            It will make the difference between what alreay there.`,
		Run: func(cmd *cobra.Command, args []string) {
			c := mal.NewClient()
			c.SetCredentials(viper.GetString("myanimelist.login"), viper.GetString("myanimelist.password"))
			c.SetUserAgent(viper.GetString("myanimelist.apikey"))
			list, _, _ := c.Manga.List("Noriak")
			for _, manga := range list.Manga {
				if manga.MyStatus == 1 {
					mangaName := manga.SeriesTitle
					mangaId := manga.SeriesMangaDBID
					mangaIdString := strconv.Itoa(mangaId)

					malLastChapter := manga.MyReadChapters
					lastChapterRead := malLastChapter

					_, ok := mangas.Mangaseries[mangaIdString]
					mangaYaml := &Detail{}
					mangaYaml.Name = mangaName
					mangaYaml.Dir = mangaName
					mangaYaml.Lastchapterdownloaded = 0
					mangaYaml.Url = ""
					mangaYaml.RawUrl = ""
					mangaYaml.Reading = ""

					if ok {
						yamlLastChapterDownloaded := mangas.Mangaseries[mangaIdString].Lastchapterdownloaded
						mangaYaml.Lastchapterdownloaded = yamlLastChapterDownloaded
						yamlUrl := mangas.Mangaseries[mangaIdString].Url
						mangaYaml.Url = yamlUrl
						yamlRawUrl := mangas.Mangaseries[mangaIdString].RawUrl
						mangaYaml.RawUrl = yamlRawUrl
						yamlReading := mangas.Mangaseries[mangaIdString].Reading
						mangaYaml.Reading = yamlReading
						yamlDir := mangas.Mangaseries[mangaIdString].Dir
						if yamlDir != "" {
							mangaYaml.Dir = yamlDir
						}
						yamlLastChapterRead := mangas.Mangaseries[mangaIdString].Lastchapterread
						if yamlLastChapterRead > malLastChapter {
							//update mal
							lastChapterRead = yamlLastChapterRead
							_, err := c.Manga.Update(mangaId, mal.MangaEntry{Status: "reading", Chapter: lastChapterRead})
							if err != nil {
								fmt.Println("Error update chapter read to myanimelist")
							} else {
								fmt.Println(mangaName + " updated")
							}
						}
					}
					mangaYaml.Lastchapterread = lastChapterRead
					mangas.Mangaseries[mangaIdString] = *mangaYaml
				}
			}
			//Savetofile
			b, _ := json.Marshal(mangas)
			y, _ := yaml.JSONToYAML(b)
			ioutil.WriteFile(viper.GetString("yaml"), y, 0777)
		},
	}

	var downloadCmd = &cobra.Command{
		Use:   "download",
		Short: "Download new chapters",
		Long: `Try to see if there is new chapters and download them.
            It will possible to read them after.`,
		Run: func(cmd *cobra.Command, args []string) {

			// Var for mangadownloader
			//outFlag := flag.String("out", "", "Output directory")
			cbzFlag := flag.Bool("cbz", true, "CBZ")
			pageDigitCountFlag := flag.Int("pagedigitcount", 4, "Page digit count")
			httpRetryFlag := flag.Int("httpretry", 10, "Http retry")
			parallelChapterFlag := flag.Int("parallelchapter", 2, "Parallel chapter")
			parallelPageFlag := flag.Int("parallelpage", 4, "Parallel page")
			flag.Parse()
			//out := *outFlag

			options := &mangadownloader.Options{
				Cbz:             *cbzFlag,
				PageDigitCount:  *pageDigitCountFlag,
				ParallelChapter: *parallelChapterFlag,
				ParallelPage:    *parallelPageFlag,
			}

			md := mangadownloader.CreateDefaultMangeDownloader()
			md.HttpRetry = *httpRetryFlag

			for key, value := range mangas.Mangaseries {
				mangaName := value.Name
				mangaDir := value.Dir
				lastChapterDownloaded := value.Lastchapterdownloaded
				urlManga := value.Url
				if urlManga != "" {
					fmt.Println("Downloading " + mangaName)
					u, err := url.Parse(urlManga)
					if err != nil {
						panic(err)
					}
					o, err := md.Identify(u)
					if err != nil {
						panic(err)
					}
					dirOut := viper.GetString("downloadDir") + mangaDir + "/"
					_ = md.DownloadManga(o.(*mangadownloader.Manga), "./mangas/", options)
					files, _ := ioutil.ReadDir(dirOut)
					var cbzFiles []os.FileInfo
					for _, f := range files {
						if strings.Contains(f.Name(), ".cbz") {
							cbzFiles = append(cbzFiles, f)
						}
					}
					sort.Sort(byName(cbzFiles))
					newChapterCbz := ""
					for _, f := range cbzFiles {
						newChapterCbz = f.Name()
					}
					newChapter := strings.Split(newChapterCbz, ".")
					newChapterInt, _ := strconv.Atoi(newChapter[0])
					if newChapterInt > lastChapterDownloaded {
						lastChapterDownloaded = newChapterInt
					}
					value.Lastchapterdownloaded = lastChapterDownloaded
					mangas.Mangaseries[key] = value
					//Savetofile
					b, _ := json.Marshal(mangas)
					y, _ := yaml.JSONToYAML(b)
					ioutil.WriteFile(viper.GetString("yaml"), y, 0777)
					fmt.Println("Finish downloading " + mangaName)
				}
				if value.RawUrl != "" && value.Reading != "" {
					cmd := exec.Command("python2", "download_raw.py", value.RawUrl, value.Reading, viper.GetString("downloadDir"))
					if err := cmd.Start(); err != nil {
						panic(err)
					}
				}
			}
		},
	}

	var readCmd = &cobra.Command{
		Use:   "read",
		Short: "Read new downloaded chapter",
		Long: `Read new downloaded Mangas.
            It will also permit to save the new state of reading.`,
		Run: func(cmd *cobra.Command, args []string) {
			id := 1
			var listMangas []string
			for key, value := range mangas.Mangaseries {
				mangaName := value.Name
				lastChapterDownloaded := value.Lastchapterdownloaded
				lastChapterRead := value.Lastchapterread
				if lastChapterDownloaded != lastChapterRead {
					fmt.Printf("%3d | %3d/%3d | %s\n", id, lastChapterRead, lastChapterDownloaded, mangaName)
					listMangas = append(listMangas, key)
					id = id + 1
				}
			}
			fmt.Print("Enter id of Manga to read: ")
			var input int
			fmt.Scanln(&input)
			idMangaToRead := listMangas[input-1]
			manga := mangas.Mangaseries[idMangaToRead]
			mangaDir := manga.Dir
			lastChapter := manga.Lastchapterread
			lastChapter = lastChapter + 1
			lastChapterStr := fmt.Sprintf("%03d", lastChapter)
			linkChapter := viper.GetString("downloadDir") + mangaDir + "/" + lastChapterStr + ".cbz"
			//Exec Mcomix
			cmdMcomix := exec.Command("mcomix", "-w", linkChapter)
			if err := cmdMcomix.Start(); err != nil {
				panic(err)
			}
			fmt.Print("Enter last chapter read: ")
			var newLastChapter int
			fmt.Scanln(&newLastChapter)
			manga.Lastchapterread = newLastChapter
			mangas.Mangaseries[idMangaToRead] = manga
			//Savetofile
			b, _ := json.Marshal(mangas)
			y, _ := yaml.JSONToYAML(b)
			ioutil.WriteFile(viper.GetString("yaml"), y, 0777)

		},
	}

	var rootCmd = &cobra.Command{Use: "hikikomori"}
	rootCmd.AddCommand(syncMalCmd)
	rootCmd.AddCommand(downloadCmd)
	rootCmd.AddCommand(readCmd)
	rootCmd.Execute()
}