not sure what is here, should be something almost working

code/moya-angular/README.md

 
+
+
 # devausnoteja (tmp ohjeet)
 
 ## Devaus
@@ -30,6 +32,56 @@ Oma moduulinsa, joka tullaan jossain vaiheessa eriyttämään ja käyttämään
 ### Muuta
 Jos tulee muita järkeviä kokonaisuuksia, joita voi käyttää muualla, jaa omaan moduuliinsa.
 
+## Hakemistohierarkia
+
+* app
+  * pages `tämän alla on käytännössä "älykkäät" komponentit (stateful), eli componentit jotka tietää mitä dataa haetaan ja mistä. Käytännössä route -targetit`
+    * user  `Loppukäyttäjälle näkyvät jutut, ohjleman ns. main moduuli`
+      * pizzatilaus
+        * listOpen.component.ts  `avoimet pizzatilaukset joista voi tilata`
+        * own_orders.component.ts
+        * testit yms.
+    * admin  `moya asetukset, esim. tuotteet, korttipohjat, oma moduulinsa joka lazyloadataan`
+      * admin.module.ts
+      * pizzatilaus
+        * pizzaedit.component.ts `hallitse mitä pizzoja voi tilata ylipäätänsä`
+    * info  `tapahtumanaikana "infolaisen" toimesta tehtävät jutut, sisäänotto, käyttäjänhallinta jne. Oma moduulinsa joka lazyloadataan`
+      * info.module.ts
+      * viplist
+        * viplist.component.ts,html,jne
+        * viplist.service.ts
+      * pizzatilaus
+        * list.component.ts `listaa kaikki, ja lisää uusi pizzailaus`
+    * old-moya `Monessa paikassa käytettävät target -componentit tulevat omiksi kokonaisuudiksiin`
+      * old-moya.component.ts
+    * pizzatilaus `Jos halutaan lazyloadata jokin osa moyasta, tehdään siitä uusi päätason komponentti. Joka sitten laitetetaan user / admin yms. puolille route -targetiksi`
+      * pizzatilaus-route.module.ts
+      * pizza-user-order.component.ts
+  * menu  `menu on täällä`
+  * shared   `geneeriset, mihinkään osaan kuulumattomat jaetut modellit ja servicet tulevat tänne`
+    * models
+      * user.model.ts
+    * services
+      * moya-rest.service.ts
+      * session.service.ts
+  * widgets `tyhmät componponentit tulevat tänne`
+    * button
+      * html
+      * ts
+      * scss
+  * components `servicet sekä componenttien geneeriset tyhmät osat tulevat tämän hakemiston alle `
+    * viplist
+      * list.component.ts
+      * add.component.ts
+  * modules  `Kokonaiset, monessa paikassa olevt kokonaisuuksien tyhmät osat tulevat tänne. Sen verta isot että ne kannattaa tehdä moduuleiksi`
+    * pizzatilaus
+      * anna-pizza.component.ts
+      * list-pizzat.component.ts,html,jne
+      * listItem.component.ts
+      * edit.component.ts
+        * pizzatilaus.service.ts
+      * pizza-tilaus.module.ts
+
 
 
 

code/moya-angular/src/app/app.component.html

@@ -8,7 +8,6 @@
   <div id="contentarea">
     <div id="topbar">
       <top-menu></top-menu>
-      <!-- h1>{{"Testing"|i18n}}</h1 -->
     </div>
     <div id="content">
       <router-outlet></router-outlet>

code/moya-angular/src/app/app.module.ts

@@ -8,23 +8,23 @@ import {AlertModule} from 'ngx-bootstrap';
 
 
 import {RouterModule, Routes} from '@angular/router';
-import {OldMoyaComponent} from './old-moya/old-moya.component';
+import {OldMoyaComponent} from './pages/old-moya/old-moya.component';
 import {TestComponent} from './test/test.component';
 import {AdminMenuComponent} from './menu/admin-menu/admin-menu.component';
 import {TopMenuComponent} from './menu/top-menu/top-menu.component';
 import {LeftMenuComponent} from './menu/left-menu/left-menu.component';
 import {InfoMenuComponent} from './menu/info-menu/info-menu.component';
 import {UserMenuComponent} from './menu/user-menu/user-menu.component';
-import {UserComponent} from './user/user.component';
-import {InfoComponent} from './info/info.component';
-import {AdminComponent} from './admin/admin.component';
+import {UserComponent} from './pages/user/user.component';
+import {InfoComponent} from './pages/info/info.component';
+import {AdminComponent} from './pages/admin/admin.component';
 import {HttpClientModule, HttpHandler } from '@angular/common/http';
 import { HttpModule } from '@angular/http';
 import {StaticInjector} from "@angular/core/src/di/injector";
 import {CommonModule} from "@angular/common";
 import {CacheService} from "./shared/services/cache.service";
 import {MoyaRestModule} from "./moya-rest";
-import {SafePipe} from "./pipes/safe.pipe";
+import {SafePipe} from "./shared/pipes/safe.pipe";
 
 const appRoutes: Routes = [
   {

code/moya-angular/src/app/moya-rest/moya-rest.module.js

+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var core_1 = require('@angular/core');
+var common_1 = require('@angular/common');
+var http_1 = require("@angular/http");
+var moya_rest_service_1 = require("../shared/services/moya-rest.service");
+var viplist_service_1 = require("../shared/services/viplist.service");
+var cache_service_1 = require("../shared/services/cache.service");
+var user_service_1 = require("../shared/services/user.service");
+var MoyaRestModule = (function () {
+    function MoyaRestModule() {
+    }
+    MoyaRestModule.forRoot = function () {
+        return {
+            ngModule: MoyaRestModule,
+            providers: [
+                moya_rest_service_1.MoyaRestService,
+                viplist_service_1.ViplistService,
+                cache_service_1.CacheService,
+                user_service_1.UserService
+            ]
+        };
+    };
+    MoyaRestModule = __decorate([
+        core_1.NgModule({
+            imports: [
+                common_1.CommonModule,
+                http_1.HttpModule
+            ],
+            declarations: []
+        })
+    ], MoyaRestModule);
+    return MoyaRestModule;
+}());
+exports.MoyaRestModule = MoyaRestModule;

code/moya-angular/src/app/shared/models/user.model.js

+/**
+ * Created by tuukka on 15/02/17.
+ */
+"use strict";
+// vim magic: %s/^\s*\w\+\s\+\(\w\+\)\s\+\(\w\+\)\s*.*;$/  \2: \L\1;/
+(function (UserGender) {
+    UserGender[UserGender["MALE"] = 0] = "MALE";
+    UserGender[UserGender["FEMALE"] = 1] = "FEMALE";
+    UserGender[UserGender["UNSPECIFIED"] = 2] = "UNSPECIFIED";
+})(exports.UserGender || (exports.UserGender = {}));
+var UserGender = exports.UserGender;
+var User = (function () {
+    function User() {
+    }
+    return User;
+}());
+exports.User = User;

code/moya-angular/src/app/shared/models/vip-product-delivery.model.js

+/**
+ * Created by tuukka on 04/02/17.
+ */
+"use strict";
+var VipProductDelivery = (function () {
+    function VipProductDelivery() {
+    }
+    return VipProductDelivery;
+}());
+exports.VipProductDelivery = VipProductDelivery;

code/moya-angular/src/app/shared/models/vip-product.model.js

+"use strict";
+/**
+ * Created by tuukka on 04/02/17.
+ */
+var VipProduct = (function () {
+    function VipProduct() {
+    }
+    return VipProduct;
+}());
+exports.VipProduct = VipProduct;

code/moya-angular/src/app/shared/models/vip.model.js

+"use strict";
+/**
+ * Created by tuukka on 04/02/17.
+ */
+var Vip = (function () {
+    function Vip() {
+    }
+    return Vip;
+}());
+exports.Vip = Vip;

code/moya-angular/src/app/shared/services/cache.service.js

+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var core_1 = require("@angular/core");
+var rxjs_1 = require("rxjs");
+var DEFAULT_EXPIRE_MS = 300000; // 5min
+var CachedItem = (function () {
+    function CachedItem(moduleName, path, value, isObservable) {
+        this.moduleName = moduleName;
+        this.path = path;
+        this.value = value;
+        this.expires = new Date();
+        this.expires.setTime(Date.now() + DEFAULT_EXPIRE_MS);
+        this.isObservable = isObservable;
+    }
+    CachedItem.prototype.isExpired = function () {
+        return this.expires.getTime() < Date.now();
+    };
+    return CachedItem;
+}());
+/**
+ * Basic cacheService.
+ *
+ * First this was part of moyaRestService, but I thinked that if cache is too easy to use, someone will kill this application with it.
+ * So let's make it litlebit harder
+ */
+var CacheService = (function () {
+    // TODO: timed clearup for cache to save memory
+    function CacheService(zone) {
+        this.zone = zone;
+        this.cache = new Map();
+        this.timerObservable = rxjs_1.Observable.timer(30000, 30000); // afther 0.5min, every 0.5min.
+    }
+    /**
+     * This will return observable with value from cache, or cache value from your observable and return it in observable.
+     *
+     * example: return cacheService.cacheObservable("mymodule",<url>, http.get(<url>).map(v => v.json()));
+     *
+     * @param moduleName
+     * @param cachePath
+     * @param source: {Observable<any>} Observable where the values, which are cached, is coming from
+     * @return {Observable<any>}: if value is in cache, this is observable made from this value. Otherwise this is source observable.
+     */
+    CacheService.prototype.cacheObservable = function (moduleName, cachePath, source) {
+        var _this = this;
+        var cacheName = this.generateCachename(moduleName, cachePath);
+        if (this.cache.has(cacheName) && this.cache.get(cacheName).expires.getTime() < Date.now()) {
+            console.log(cacheName, " Expired version in cache");
+            this.cache.delete(cacheName);
+        }
+        if (!this.cache.has(cacheName)) {
+            /*
+             not in cache, let's change source to hot -observable, and return one instance from it
+             problem is, that before this observable is runned, there can be queries for this value from cache.
+             So, let's change this to hot-observable, and put that hot-observable into the cache.
+             And in first run, we change this hot observable to it's value.
+      
+             Javascript is asynchronous, so there is no need to worry some weird things that could happen in multithreaded languages.
+             */
+            console.log(cacheName, " not in cache");
+            var hotSource = source
+                .do(function (val) { return _this.cache.set(cacheName, new CachedItem(moduleName, cachePath, val)); })
+                .publishLast().refCount();
+            this.cache.set(cacheName, new CachedItem(moduleName, cachePath, hotSource, true));
+            this.checkCleanTimer();
+            return hotSource;
+        }
+        var cacheItem = this.cache.get(cacheName);
+        // if value is hotObservable, return it, otherwise create observable from value
+        if (cacheItem.isObservable) {
+            console.log(cacheName, " hot observable in cache ");
+            return cacheItem.value;
+        }
+        console.log(cacheName, " value in cache");
+        this.checkCleanTimer();
+        return rxjs_1.Observable.of(cacheItem.value);
+    };
+    CacheService.prototype.clean = function () {
+        this.cache.clear();
+        this.checkCleanTimer();
+    };
+    CacheService.prototype.cleanExpired = function () {
+        var _this = this;
+        this.cache.forEach(function (v, k) {
+            if (v.isExpired()) {
+                console.log(k, " Cache expired");
+                _this.cache.delete(k);
+            }
+        });
+        this.checkCleanTimer();
+    };
+    CacheService.prototype.checkCleanTimer = function () {
+        var _this = this;
+        if (this.cache.size > 0) {
+            if (!this.timerSubscription) {
+                console.log("adding clearing timer");
+                this.zone.runOutsideAngular(function () {
+                    _this.timerSubscription = _this.timerObservable.subscribe(function (v) {
+                        _this.cleanExpired();
+                    });
+                });
+            }
+        }
+        else {
+            if (this.timerSubscription) {
+                console.log("removing clearing timer");
+                this.timerSubscription.unsubscribe();
+            }
+        }
+    };
+    /**
+     *
+     * @param moduleName
+     * @param cachePath
+     * @param value
+     */
+    CacheService.prototype.set = function (moduleName, cachePath, value) {
+        var cacheName = this.generateCachename(moduleName, cachePath);
+        this.cache.set(cacheName, new CachedItem(moduleName, cachePath, value));
+    };
+    /**
+     * Get one value from cache.
+     *
+     * Now when there is this observablethingy. Make public afther rethinking this.
+     *
+     * @param moduleName
+     * @param cachePath
+     * @return {any|null} Null if nothing is in cache.
+     */
+    CacheService.prototype.get = function (moduleName, cachePath) {
+        var cacheName = this.generateCachename(moduleName, cachePath);
+        if (this.cache.has(cacheName) && this.cache.get(cacheName).expires.getTime() < Date.now()) {
+            this.cache.delete(cacheName);
+        }
+        if (this.cache.has(cacheName)) {
+            return this.cache.get(cacheName);
+        }
+        return null;
+    };
+    CacheService.prototype.generateCachename = function (moduleName, cachePath) {
+        return moduleName + "::" + cachePath;
+    };
+    CacheService = __decorate([
+        core_1.Injectable()
+    ], CacheService);
+    return CacheService;
+}());
+exports.CacheService = CacheService;

code/moya-angular/src/app/shared/services/user.service.js

+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var core_1 = require("@angular/core");
+var rxjs_1 = require("rxjs");
+var UserService = (function () {
+    function UserService(moyaRest, cacheService) {
+        this.moyaRest = moyaRest;
+        this.cacheService = cacheService;
+    }
+    UserService.prototype.get = function (id) {
+        if (!id || id < 0) {
+            return rxjs_1.Observable.throw("There should be userid");
+        }
+        var path = "v2/user/" + id;
+        return this.cacheService.cacheObservable("moya:UserService", path, this.moyaRest.get(path)
+            .do(function (v) { console.log("getting user outside of cache", path); })
+            .map(function (res) { return (res.json()); }));
+    };
+    UserService = __decorate([
+        core_1.Injectable()
+    ], UserService);
+    return UserService;
+}());
+exports.UserService = UserService;

code/moya-angular/src/app/shared/services/viplist.service.js

+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+var core_1 = require('@angular/core');
+var rxjs_1 = require("rxjs");
+var ViplistService = (function () {
+    function ViplistService(moyaRestService, userService) {
+        this.moyaRestService = moyaRestService;
+        this.userService = userService;
+    }
+    /**
+     * get vips
+     * @param searchString: searchString, skip to return all vips
+     */
+    ViplistService.prototype.get = function (searchString) {
+        var _this = this;
+        if (!searchString) {
+            return this.moyaRestService.get("v3/vip/all")
+                .switchMap(function (res) { return rxjs_1.Observable.forkJoin.apply(rxjs_1.Observable, res.json().map(function (apiRow) { return _this.hostPopulator(apiRow); })); });
+        }
+        return this.moyaRestService.get("v3/vip/search/" + searchString)
+            .switchMap(function (v) { return rxjs_1.Observable.forkJoin.apply(rxjs_1.Observable, v.json().map(function (x) { return _this.hostPopulator(x); })); });
+    };
+    /**
+     * Delete vip.
+     *
+     * @param vip
+     * @return Observable
+     */
+    ViplistService.prototype.delete = function (vip) {
+        return __awaiter(this, void 0, Promise, function* () {
+            if (!vip.id)
+                throw new Error("TODO: errori, tyhmä vippi");
+            var res = yield this.moyaRestService.delete("v3/vip/" + vip.id)
+                .first()
+                .toPromise();
+            return res.ok;
+        });
+    };
+    /*
+      public deleteProm(vip: Vip): Promise<boolean> {
+    
+        if (!vip.id)
+          throw new Error("TODO: errori, tyhmä vippi");
+    
+        return this.moyaRestService.delete("v3/vip/" + vip.id)
+          .first()
+          .toPromise()
+          .then(r => r.ok);
+    
+      }
+    
+    */
+    ViplistService.prototype.getWithId = function (id) {
+        return this.moyaRestService.get("v3/vip/" + id)
+            .map(function (v) { return v.json(); });
+    };
+    ViplistService.prototype.create = function (vip) {
+        return this.moyaRestService.post("v3/vip/create", vip)
+            .map(function (v) { return v.json(); });
+    };
+    ViplistService.prototype.hostPopulator = function (rawVip) {
+        return this.userService.get(rawVip.hostId)
+            .map(function (u) { rawVip.host = u; return rawVip; });
+    };
+    ViplistService = __decorate([
+        core_1.Injectable()
+    ], ViplistService);
+    return ViplistService;
+}());
+exports.ViplistService = ViplistService;

code/moya-angular/tuotantomoya.conf.json

+{
+  "/MoyaWeb": {
+    "target": "https://kauppa.insomnia.fi",
+    "secure": true
+  }
+}