.forChild() usage with lazy loading routes #425

dhardtke · 2017-02-11T03:15:31Z

I'm submitting a ... (check one with "x")

[ ] bug report => check the FAQ and search github for a similar issue or PR before submitting
[x] support request => check the FAQ and search github for a similar issue before submitting
[ ] feature request

Current behavior
AppModule

export function createTranslateLoader(http: Http) {
    return new TranslateHttpLoader(http, "/i18n/", "/index.json");
}
imports: [
    TranslateModule.forRoot({
            loader: {
                provide: TranslateLoader,
                useFactory: createTranslateLoader,
                deps: [Http]
            }
        }),
]

SharedModule

imports: [
    //TranslateModule
],
exports: [
    //TranslateModule,
]

AdminModule

export function createTranslateLoader(http: Http) {
    return new TranslateHttpLoader(http, "/i18n/", "/admin.json");
}
imports: [
    TranslateModule.forChild({
            loader: {
                provide: TranslateLoader,
                useFactory: createTranslateLoader,
                deps: [Http]
            }
        }),
]

Expected/desired behavior
I would like to load additional JSON files per component / module, i.e. an admin.json for the administration panel of our app.
I would like to import one TranslateModule inside of SharedModule and configure it allow all modules that don't explicite call .forChild().

Both doesn't work, it simply doesn't load the admin.json and hence doesn't translate strings defined in that file.

Please tell us about your environment:

ngx-translate version: 6.0.0-beta.1
Angular version: 2.4.7
Browser: [Firefox 51.0.1]
Language: [TypeScript 2.0]

The text was updated successfully, but these errors were encountered:

neolanders · 2017-02-21T19:47:40Z

Since I didn't found any plunker working with ngx-translate librairy and I also had some difficulties to manage to make it work with LoadChildren,
I've setup a way that work pretty well for me:

I've created two SharedModules, (one for lazyLoading and one for the other part of my application)

SharedLazyModule for lazy loading content:

@NgModule({
  imports: [
    HttpModule,
    CommonModule,
    TranslateModule.forChild({}),
  ],
  exports: [
    CommonModule,
    TranslateModule
  ]
})
export class SharedLazyModule {}

SahredModule for App

// AoT requires an exported function for factories
export function HttpLoaderFactory(http: Http) {
   return new TranslateHttpLoader(http, './assets/i18n/', '.json');
}

@NgModule({
    imports: [
      HttpModule,
      CommonModule,
      TranslateModule.forRoot({
           provide: TranslateLoader,
           useFactory: HttpLoaderFactory,
           deps: [Http],
         })
    ],
    exports: [
      CommonModule,
      TranslateModule
    ]
})
export class SharedModule {
    
     constructor(private translate: TranslateService) {
                  
        translate.addLangs(["en", "fr"]);
        translate.setDefaultLang('en');

        let browserLang = translate.getBrowserLang();
        translate.use(browserLang.match(/en|fr/) ? browserLang : 'en');
    }
}

See Plunker:
https://plnkr.co/LVmIuI1Xw9vFn0IuC2jW

mebibou · 2017-09-20T12:21:45Z

@neolanders your answer does not relate to the question, you are posting the solution explained in the README for SharedModule.

I'm trying to create a module on top of the TranslateModule where each module could put in his translations, but so far not successful

dhardtke · 2017-09-20T18:55:33Z

I believe ngx-translate is broken in regards to its "Lazy loading feature" and since ocombe is now part of the Angular core team, it will probably never get fixed.

Most likely, people will have to switch to Angular's i18n functionality once it becomes more rich in regards to its features.

Tuizi · 2017-09-23T15:41:54Z

I wrote a article about how to have 1 json file per lazy loaded module without having to write a new Custom Loader etc... it's quiet simple, only the documentation is not clear in fact:
https://medium.com/@TuiZ/how-to-split-your-i18n-file-per-lazy-loaded-module-with-ngx-translate-3caef57a738f

mebibou · 2017-09-24T09:01:47Z

@Tuizi your solution is a workaround, since you are basically creating TranslateModule in every lazy loaded module, and you need something in between to keep the selected lang synced. The problem we are talking about is that it should work without this workaround that we all have to do for now

Tuizi · 2017-09-26T14:01:07Z

@mebibou I'm curious about what contributors think about that. For me it's not a workaround has I simply follow what the documentation say (paragraph "lazy loaded module")

mebibou · 2017-09-26T14:05:57Z

@Tuizi no I'm saying that's not the point of the issue here. We want to have lazy loading modules being in sync with the master modules, without having to push the changes of lang from master to slave everytime. It should basically work without needing to use isolate: true and adding some code (your this.store.dispatch and all)

pieterdegraeuwe · 2017-10-06T12:44:42Z

any progress on this? is Tuizi's solution is indead a work-around. Anyone found a real solution / fix?

Tuizi · 2017-10-06T13:41:53Z

What would be a real solution?

I have time to work on a PR and I would like to try to solve this problem, which seems to impact many people.

What do you think of that?

Core Module

export function createTranslateLoader(http: HttpClient) {
  // We may need a new loader? To define the folder where i18n's files are, and the extension
  return new LazyTranslateHttpLoader(http, './assets/i18n/', '.json');
}

TranslateModule.forRoot({
  loader: {
      provide: TranslateLoader,
      useFactory: (createTranslateLoader),
      deps: [HttpClient]
  }
})

Lazy loaded Module: admin

  TranslateModule.forChild({lazy: 'admin'})

When admin module is loaded, the file ./assets/i18n/admin/en.json will be requested.

What do you think of that?

mebibou · 2017-10-06T14:07:11Z

I wouldn't mind having to create different translateLoader per module, just without using isolate: true should work, something along:

// app.module.ts
export function HttpLoaderFactory(http: Http) {
   return new TranslateHttpLoader(http, './assets/i18n/app/', '.json');
}

@NgModule({
    imports: [
      TranslateModule.forChild({
        loader: {
          provide: TranslateLoader,
           useFactory: HttpLoaderFactory,
           deps: [Http]
        }
     })
   ]
})
export class AppModule {}

// in a lazy-loaded page's module
// pages/home/page.module.ts
export function HttpLoaderFactory(http: Http) {
   return new TranslateHttpLoader(http, './assets/i18n/home/', '.json');
}

@NgModule({
    imports: [
      TranslateModule.forChild({
        loader: {
          provide: TranslateLoader,
           useFactory: HttpLoaderFactory,
           deps: [Http]
        }
     })
   ]
})
export class HomePageModule {}

mebibou · 2017-10-06T14:10:49Z

@Tuizi taken from the README:

Otherwise, by default, it will share its data with other instances of the service (but you can still use a different loader/compiler/parser/handler even if you don't isolate the service).

I don't think that is true, when I don't use isolate: true, my custom translate loader (like in example above) does not load the translation at all, nothing happens

Tuizi · 2017-10-06T14:12:37Z

Thank you are right. I will check that

Almar · 2017-12-07T15:05:56Z

If I understand correctly, the OP wants to lazily load translations along with his lazily loaded modules. We did managed to load translations lazily but used a slightly different approach. All our translations are defined in 'namespaces' and every translation key is prefixed with the namespace (for instance 'validations.required'). Our translations are loaded with a MissingTranslationHandler. The MissingTranslationHandler uses the namespace to determine which translation file to load.

So, we're not lazily loading our translations per (lazily loaded) module but per translation namespace. By prefixing your translation keys with your module name you could of course get the required effect.

Gist with our MissingTranslationHandler

Hope this can help someone.

gate3 · 2017-12-25T13:09:22Z

Seems the best thing you can do right now is use namespacing, with the -f namespaced-json flag. Seems to be the only solution for modularity. The problem i would like to solve now is a way to globally load the pipe once in a lazy loading environment. I have to use a sharedmodule to load 'TranslateModule.forRoot()' in all my modules for it to work right now, not very efficient.

Mokto · 2018-03-28T12:33:05Z

@Almar Thanks !! That's a great solution for now.

Dunos · 2018-04-03T10:43:53Z

@ocombe are you planning to fix/support this any time soon?

emmano3h · 2018-06-12T15:46:16Z

I tried forchild solution but it is not working. Could we have any plunk working well ?
ngx-translate version: 6.0.0-beta.1

Angular version: 6.0.3

Browser: [Chrome Version 67.0.3396.79 (Official Build) (64-bit)]

Language: [TypeScript 2.7.2]

ocombe · 2018-06-12T15:48:20Z

If you use Angular v6, you have to use ngx translate version >= 10

emmano3h · 2018-06-12T16:03:49Z

@ocombe here my configs:

"@ngx-translate/core": "^10.0.2",
"@ngx-translate/http-loader": "^3.0.1",

wilker7ribeiro · 2018-06-22T20:02:34Z

Same here

YaroslavLyzlov · 2018-08-21T07:31:05Z

Same here (angular 6.1.3, ngx-translate 10.0.2)

erperejildo · 2018-08-29T12:48:02Z

don't get this... do we need to keep .forChild and .forRoot together? I get an error if I don't add the second one:

Could not find IonicModule.forRoot call in "imports"

cdskill · 2018-09-14T08:07:57Z

Personnaly I still have a issue for getting all my translations... my scenario is :
a main application calling
a lazy loaded module
where is a container module
where the translation is used.
Everything works expect the translation :-/

If I dont lazy load I get my translations.

There is a sample:
app.module

// Http loader for ngx-translate.
export function createTranslateLoader(http: HttpClient, settings: GlobalAppSettings) {
  return new TranslationLoader(http, settings);
}

@NgModule({
  declarations: [
....
  ],
  imports: [
....

    // Other external modules.
    TranslateModule.forRoot({
      loader: { provide: TranslateLoader, useFactory: (createTranslateLoader), deps: [HttpClient, GlobalAppSettings] }, isolate: true
....
  ],
  bootstrap: [AppComponent]
})
export class AppModule { }

app-routing.module

imports....
export const routes: Routes = [
...
    {
        path: 'unemployment-info',
        canActivate:[OAuthGuardService],
        loadChildren: './unemployment.module#UnemploymentModule',
        data: { id: 4, title:'tabs.eDossier' }
    
    }
...
];

@NgModule({
    imports: [RouterModule.forRoot(routes, {preloadingStrategy: PreloadAllModules, enableTracing:false})],
    exports: [RouterModule]
})
export class AppRoutingModule { }

unemployment.module

export const routes: Routes = [{ path: '', component: UnemploymentInfoComponent }];
// Http loader for ngx-translate.
export function createTranslateLoader(httpClient: HttpClient, settings: GlobalAppSettings) {
  return new TranslationLoader(httpClient, settings);
}

@NgModule({
  imports: [
    CommonModule,
    RouterModule.forChild(routes),
    EDossierContainerModule,
    TranslateModule.forChild({
      loader: { provide: TranslateLoader, useFactory: (createTranslateLoader), deps: [HttpClient, 
GlobalAppSettings] }
    }),
  ], exports: [],
  declarations: [...]
})
export class UnemploymentModule { }

e-dossier-container.module

// Http loader for ngx-translate.
export function createTranslateLoader(httpClient: HttpClient, settings: GlobalAppSettings) {
  return new TranslationLoader(httpClient, settings);
}

@NgModule({
  imports: [
    ....
    // Translate
    TranslateModule.forChild({
      loader: { provide: TranslateLoader, useFactory: (createTranslateLoader), deps: [HttpClient, GlobalAppSettings] }
    }),
    ....
  ],
  declarations: [
   ....
  ],
  exports: [HomeMenuComponent],
  providers: [
...
  ]
})
export class EDossierContainerModule { }

stemda · 2019-04-25T10:47:54Z

My case was:

Have a global translation file loaded with the main application
Lazy load several feature modules, each with their own translation files
Extend the core translations only when needed

I solved my problem by adding an option extend , which allows lazy loaded modules to extend the translations for a given language instead of ignoring them, if already present.

TranslateModule.forChild({
      loader: {
        provide: TranslateLoader,
        useFactory: (createTranslateLoader),
        deps: [HttpClient]
      },
      extend: true
    }),

If you're interested, you can get it here:

https://github.com/stemda/ngx-translate

Probably not good enough for a PR but maybe it helps some of you...

monkeycatdog · 2019-05-09T16:12:57Z

Hi all, I trying to use this example, but its not working? Why for lazy module translation dictionary not merged with module forRoot?

I wouldn't mind having to create different translateLoader per module, just without using isolate: true should work, something along:

// app.module.ts
export function HttpLoaderFactory(http: Http) {
   return new TranslateHttpLoader(http, './assets/i18n/app/', '.json');
}

@NgModule({
    imports: [
      TranslateModule.forChild({
        loader: {
          provide: TranslateLoader,
           useFactory: HttpLoaderFactory,
           deps: [Http]
        }
     })
   ]
})
export class AppModule {}

// in a lazy-loaded page's module
// pages/home/page.module.ts
export function HttpLoaderFactory(http: Http) {
   return new TranslateHttpLoader(http, './assets/i18n/home/', '.json');
}

@NgModule({
    imports: [
      TranslateModule.forChild({
        loader: {
          provide: TranslateLoader,
           useFactory: HttpLoaderFactory,
           deps: [Http]
        }
     })
   ]
})
export class HomePageModule {}

stemda · 2019-05-10T07:59:47Z

I posted a possible solution for your problem above. If you dont want to check out the fork, just download a patch

https://github.com/foo/bar/commit/${SHA}.patch

https://github.com/stemda/ngx-translate/commit/f54bc5303124ec35a5e2ab4f51e59cf9920f5cd8.patch

and try it out.

monkeycatdog · 2019-05-10T08:34:48Z

@stemda omg, nice! I just few minutes already forked for same patch. :)
Are you can create PR for resolve this issue?

stemda · 2019-05-10T13:36:05Z

@iamruslanbakirov okay, I just started a pull request.
btw. I decided against overwriting already present translations within the merge since that could lead to very confusing behaviour. the result would depend on the loading sequence of the modules, which isn't really great I think.

Tolitech · 2019-05-11T13:29:16Z

Hello.

If I understand correctly, with "extend" it will be possible to use a shared.json and a module.json file (by lazy loading module) and the "extend" will not overwrite but make an append with shared.json?

Would be perfect.
I'm really in need of this to better organize the translations and still make GET just the necessary one used in the module (lazy-loading).

Thanks.

stemda · 2019-05-20T08:48:24Z

Hey, @Tolitech, sorry for my late response. Yes, that's excactly what the patch does.

Tolitech · 2019-05-20T11:38:23Z

@stemda
thank you.
I'll wait for this feature.

jansowinski · 2019-05-31T12:06:44Z

@ocombe what we can do for you to speed up merging @stemda changes?

akiik · 2019-06-27T06:24:06Z

Hey!

I'm facing the same issue here and @stemda changes will fix the problem. I'm really looking forward to this PR being merged.

Thank you.

Tuizi · 2019-09-23T16:18:05Z

@pvkrijesh a working example updated to Angular 8:
https://github.com/Tuizi/i18n-split-example

Tolitech · 2019-09-25T17:54:20Z

@pvkrijesh a working example updated to Angular 8:
https://github.com/Tuizi/i18n-split-example

@Tuizi

This example does not work exactly.

The problem is not just detaching each module into a new json file.

But if you have a shared json with 10 translations for example, it cannot be used by others and always has to be copied again, which makes using this way bad.

kristofdegrave · 2020-01-20T10:34:46Z

Based on the solution @Almar provided, I'm also using the MissingTranslationHandler to determine if additional translations need to be fetched. The parts that I've changed compared to @Almar solution is that I make use of the loader configured inside the translation service. Because a new instance of the TranslationService is created when using the forChild method, this is nicely isolated, the same counts for the missinghandler that is configured.

https://gist.github.com/kristofdegrave/64863e249bbc8768fe33fc666dfa8bf5

Fixes ngx-translate#425

Eyasserk · 2020-07-01T11:20:13Z

I¡ve developed a lazy loading per module solution through a factory.

create a folder assets/i18n/modulexxx for every module
add the language json en.json, fr.json..etc in that folder and the shared ones in assets/i18n
Add the TranslateLoder factory (e.g shared/i18n/TranslateLoader.ts)

import { TranslateLoader } from '@ngx-translate/core';
import { Observable, from, merge } from 'rxjs';

const appAvailableLanguages = ['ar', 'en', 'es', 'fr'];
const defaultLanguage = 'en';

export class TranslateLoaderFactory {
    static forModule(module: string): any {
        return class LazyTranslateLoader implements TranslateLoader {
            getTranslation(lang: string): Observable<any> {
                if (!appAvailableLanguages.includes(lang)) {
                    return merge(
                        from(import(`../../../assets/i18n/${defaultLanguage}.json`)),
                        from(import(`../../../assets/i18n/${module}/${defaultLanguage}.json`))
                    );
                }
                return merge(
                    from(import(`../../../assets/i18n/${lang}.json`)),
                    from(import(`../../../assets/i18n/${module}/${lang}.json`))
                );
            }
        }
    }
}

Use in in your root and lazy loaded modules as:

root:

TranslateModule.forRoot({
          loader: {
              provide: TranslateLoader,
              useClass: TranslateLoaderFactory.forModule('main'),
              deps: [HttpClient]
          }
      }),

lazy loaded module:

TranslateModule.forChild({
          loader: {
              provide: TranslateLoader,
              useClass: TranslateLoaderFactory.forModule('mymodule'),
              deps: [HttpClient]
          }
      }),

Hope that helps

jlopezjuy · 2020-07-04T12:31:59Z

I¡ve developed a lazy loading per module solution through a factory.

create a folder assets/i18n/modulexxx for every module
add the language json en.json, fr.json..etc in that folder and the shared ones in assets/i18n
Add the TranslateLoder factory (e.g shared/i18n/TranslateLoader.ts)

import { TranslateLoader } from '@ngx-translate/core';
import { Observable, from, merge } from 'rxjs';

const appAvailableLanguages = ['ar', 'en', 'es', 'fr'];
const defaultLanguage = 'en';

export class TranslateLoaderFactory {
    static forModule(module: string): any {
        return class LazyTranslateLoader implements TranslateLoader {
            getTranslation(lang: string): Observable<any> {
                if (!appAvailableLanguages.includes(lang)) {
                    return merge(
                        from(import(`../../../assets/i18n/${defaultLanguage}.json`)),
                        from(import(`../../../assets/i18n/${module}/${defaultLanguage}.json`))
                    );
                }
                return merge(
                    from(import(`../../../assets/i18n/${lang}.json`)),
                    from(import(`../../../assets/i18n/${module}/${lang}.json`))
                );
            }
        }
    }
}

Use in in your root and lazy loaded modules as:

root:

TranslateModule.forRoot({
          loader: {
              provide: TranslateLoader,
              useClass: TranslateLoaderFactory.forModule('main'),
              deps: [HttpClient]
          }
      }),

lazy loaded module:

TranslateModule.forChild({
          loader: {
              provide: TranslateLoader,
              useClass: TranslateLoaderFactory.forModule('mymodule'),
              deps: [HttpClient]
          }
      }),

Hope that helps

Hi, could you share a github project working? i have testest but not work.

appstore-redphoenix · 2020-09-03T12:58:16Z

one more workaround to trigger language change globally including lazy modules

  export class SharedModule {
    constructor(
      private languageService: LanguageService,
      private translateService: TranslateService
    ) {
      this.languageService.language.subscribe((lang) => {
        this.translateService.use(lang);
      });
    }
  }

Totot0 · 2020-11-15T16:10:02Z

I am the same problem. Isolet true not working for me. Do you have a solution ?
I use Angular 9

isamely1990 · 2021-04-29T14:13:38Z

After a few days searching, reading and trying other solutions, I found that in my case, my team and I, we had a bad implementation of lazy loading in the routing, we had the component declared in the route, and in the pages module, causing that we only receive the translation in just 1 module instead of all modules where we used TranslateModule.forChild with isolate: true

So maybe works to check if the lazy load is ok in your project, the component mus be declare only in each anycomponent-module.ts

path: 'clients',
// component: ClientsComponent, *shouldn't be here*
canActivate: [AuthGuard],
loadChildren: () => import('./clients/clients.module').then(m => m.ClientsModule)

brianmriley · 2021-05-10T21:14:35Z

@Juusmann's solution works for me as well. To be extremely specific and to add clarity to anyone still wondering how it all fits together, I have the following setup (using abbreviated module definitions):

AppModule

...
// AoT requires an exported function for factories.
export function HttpLoaderFactory(http: HttpClient): TranslateHttpLoader {
    return new TranslateHttpLoader(http, './assets/i18n/', '.json');
}

...

imports: [
   ...
   // NOTE: Normally we'd stick TranslateModule in `CoreModule` but the ability to lazy load
   // module translations and extend the main one only works if you set it up in the root `AppModule`.
   // Use the TranslateModule's config param "isolate: false" to allow child, lazy loaded modules to 
   // extend the parent or root module's loaded translations.
   TranslateModule.forRoot({
        defaultLanguage: 'en',
        loader: {
            provide: TranslateLoader,
            useFactory: HttpLoaderFactory,
            deps: [HttpClient]
        },
        isolate: false
    }),
]

SharedModule

@NgModule({
    declarations: DECLARATIONS,
    imports: [
        ...MODULES,
        ...TranslateModule
    ],
    exports: [
        ...MODULES,
        ...TranslateModule
        ...DECLARATIONS,
    ]
})
export class SharedModule {
}

LazyLoadedModule

...
// AoT requires an exported function for factories.
export function HttpLoaderFactory(http: HttpClient): TranslateHttpLoader {
    return new TranslateHttpLoader(http, './assets/i18n/'lazy-load, '.json');
}

...

imports: [
   ...
   // Use the TranslateModule's config param "extend: true" to extend the parent or root module's
   // loaded translations.
   TranslateModule.forChild({
        defaultLanguage: 'en',
        loader: {
            provide: TranslateLoader,
            useFactory: HttpLoaderFactory,
            deps: [HttpClient]
        },
        extend: true
    }),
]
export class LazyLoadedModule {
    constructor(protected translateService: TranslateService) {
        const currentLang = translateService.currentLang;
        translateService.currentLang = '';
        translateService.use(currentLang);
    }
}

Key Points

Use the TranslateModule's method forRoot() with config param isolate: false in AppModule to allow child, lazy loaded modules to extend the parent or root module's loaded translations.
Use the TranslateModule's method forChild() with config param extend: true in LazyLoadedModule to extend the parent or root module's loaded translations.
DO NOT attempt to move the TranslateModule setup and configuration from AppModule to a CoreModule as it won't allow the root translations and only works when setup directly in AppModule.
Force TranslateModule to load the LazyLoadedModule's child translations by setting the locale on the TranslateService in its constructor.

eulersson · 2021-07-15T09:26:17Z

Still having this issue. I can't understand why this issue is closed. The extend option does not seem to respect the parent module translations. Does anyone have a StackBlitz showing the extend doing what it's supposed to do for lazy loaded modules that load .json files from another subfolder?

niroshank · 2021-08-14T18:46:58Z

LazyLoadedModule - isolated : true -> Main translations file is loaded
LazyLoadedModule - isolated : false -> Feature translations file is loaded
I also have added the translateService in its constructor.

KevinKallin · 2023-10-02T13:20:06Z

@brianmriley
OMG thank you!

Me and another colleague have worked a couple of days trying to solve this and your solution did work perfectly fine! :)

sdedieu · 2024-05-20T15:30:37Z

Hey @brianmriley !
I did your instructions but end up with translateService.currentLang as undefined (instead of the chosen language) in the lazy loaded Module contructor.
Any idea why ?

dhardtke mentioned this issue Feb 21, 2017

Setup for non-root modules #434

Closed

dhardtke mentioned this issue Feb 24, 2017

Lazy loaded module is not adding the new custom translateLoader #444

Closed

mebibou mentioned this issue Oct 9, 2017

Fix service configuration with isolate = true #531

Open

ocombe added Type: bug Priority: critical labels May 8, 2018

This was referenced Nov 29, 2018

Ngx translate with shared/lazy loading modules #966

Closed

not working in nested lazy loading module #925

Open

kopach mentioned this issue Mar 20, 2019

.forRoot() usage with lazy loading routes with child components #1020

Open

stemda mentioned this issue May 10, 2019

feat(core): add option for lazy loaded modules to extend translations #1070

Merged

This comment has been minimized.

Sign in to view

ocombe pushed a commit to stemda/ngx-translate that referenced this issue Feb 5, 2020

feat(core): add option for lazy loaded modules to extend translations

c914152

Fixes ngx-translate#425

ocombe closed this as completed in 6b675d6 Feb 5, 2020

dfmeretzki mentioned this issue Jan 20, 2022

fix(TranslateService): load translations if they have not been loaded before (#1193)(#1266) #1361

Open

.forChild() usage with lazy loading routes #425

.forChild() usage with lazy loading routes #425

Comments

dhardtke commented Feb 11, 2017

neolanders commented Feb 21, 2017 • edited Loading

mebibou commented Sep 20, 2017 • edited Loading

dhardtke commented Sep 20, 2017

Tuizi commented Sep 23, 2017

mebibou commented Sep 24, 2017

Tuizi commented Sep 26, 2017

mebibou commented Sep 26, 2017

pieterdegraeuwe commented Oct 6, 2017

Tuizi commented Oct 6, 2017

mebibou commented Oct 6, 2017

mebibou commented Oct 6, 2017

Tuizi commented Oct 6, 2017

Almar commented Dec 7, 2017

gate3 commented Dec 25, 2017 • edited Loading

Mokto commented Mar 28, 2018

Dunos commented Apr 3, 2018

emmano3h commented Jun 12, 2018

ocombe commented Jun 12, 2018 via email

emmano3h commented Jun 12, 2018

wilker7ribeiro commented Jun 22, 2018

YaroslavLyzlov commented Aug 21, 2018

erperejildo commented Aug 29, 2018

cdskill commented Sep 14, 2018

stemda commented Apr 25, 2019 • edited Loading

monkeycatdog commented May 9, 2019

stemda commented May 10, 2019

monkeycatdog commented May 10, 2019

stemda commented May 10, 2019

Tolitech commented May 11, 2019

stemda commented May 20, 2019

Tolitech commented May 20, 2019

jansowinski commented May 31, 2019

akiik commented Jun 27, 2019

This comment has been minimized.

Tuizi commented Sep 23, 2019

Tolitech commented Sep 25, 2019

kristofdegrave commented Jan 20, 2020

Eyasserk commented Jul 1, 2020 • edited Loading

jlopezjuy commented Jul 4, 2020

appstore-redphoenix commented Sep 3, 2020

Totot0 commented Nov 15, 2020

isamely1990 commented Apr 29, 2021 • edited Loading

brianmriley commented May 10, 2021

eulersson commented Jul 15, 2021

niroshank commented Aug 14, 2021

KevinKallin commented Oct 2, 2023

sdedieu commented May 20, 2024

neolanders commented Feb 21, 2017 •

edited

Loading

mebibou commented Sep 20, 2017 •

edited

Loading

gate3 commented Dec 25, 2017 •

edited

Loading

stemda commented Apr 25, 2019 •

edited

Loading

Eyasserk commented Jul 1, 2020 •

edited

Loading

isamely1990 commented Apr 29, 2021 •

edited

Loading