Проектирование и разработка web-сервиса для автоматического анализа результатов поисковых запросов к базе данных Madrid Monitor

dest: path.join(__dirname, 'public'),

indentedSyntax: true, // true = .sass and false = .scss

sourceMap: true

}));

//catch 404 and forward to error handler

this.app.use(function(err: any, req: express.Request, res: express.Response, next: express.NextFunction) {

err.status = 404;

next(err);

});

//error handling

this.app.use(errorHandler());

//use q promises

global.Promise = require("q").Promise;

}

/**

* Create router

* @class Server

* @method api

*/

public routes() {

let router: express.Router;

router = express.Router();

//IndexRouter

IndexRoute.create(router);

GetXMLFromMadrid.create(router);

FindByName.create(router);

//use router middleware

this.app.use(router);

}

}

Файл routes.ts:

'use strict'

import { NextFunction, Request, Response } from "express";

export class BaseRoute {

protected title: string;

private scripts: string[];

constructor(){

this.title = "Madrid Monitor";

this.scripts = [];

}

/**

* Add a JS external file to the request.

*

* @class BaseRoute

* @method addScript

* @param src {string} The src to the external JS file.

* @return {BaseRoute} Self for chaining

*/

public addScript(src: string): BaseRoute {

this.scripts.push(src);

return this;

}

/**

* Render a page.

*

* @class BaseRoute

* @method render

* @param req {Request} The request object.

* @param res {Response} The response object.

* @param view {String} The view to render.

* @param options {Object} Additional options to append to the view's local scope.

* @return void

*/

public render(req: Request, res: Response, view: string, options?: Object) {

//add constants

res.locals.BASE_URL = "/";

//add scripts

res.locals.scripts = this.scripts;

//add title

res.locals.title = this.title;

//render view

res.render(view, options);

}

}

Файл index.ts

import { NextFunction, Request, Response, Router } from "express";

import { BaseRoute } from "./routes";

/**

* route

*

* @class Application

*/

export class IndexRoute extends BaseRoute {

/**

* Create the routes.

*

* @class IndexRoute

* @method create

* @static

*/

public static create(router: Router) {

//log

console.log("[IndexRoute::create] Creating index route.");

//add home page route

router.get("/api/", (req: Request, res: Response, next: NextFunction) => {

new IndexRoute().index(req, res, next);

});

}

/**

* Constructor

*

* @class IndexRoute

* @constructor

*/

constructor(){

super();

}

/**

* The home page route.

*

* @class IndexRoute

* @method index

* @param req {Request} The express Request object.

* @param res {Response} The express Response object.

* @next {NextFunction} Execute the next method.

*/

public index(req: Request, res: Response, next: NextFunction) {

//set custom title

this.title = "Home | Madrid Monitor";

//set options

let options: Object = {

"message": "Welcome to the Madrid Monitor"

};

//render template

this.render(req, res, "index", options);

}

}

Файл getAppFromMadrid.ts

import { NextFunction, Request, Response, Router } from "express";

import { BaseRoute } from "./routes";

import * as http from "http";

import * as fs from "fs";

import * as request from "request";

import * as xmltojson from "xml2json";

import * as q from "q";

import { resolve } from "path";

/**

* / route

*

* @class GetXMLFromMadrid

*/

export class GetXMLFromMadrid extends BaseRoute {

/**

* Create the routes.

*

* @class GetXMLFromMadrid

* @method create

* @static

*/

public static create(router: Router) {

//log

console.log("[GetXMLFromMadrid::create] Creating GetAppFromMadrid route.");

//add home page route

router.get("/api/getappfrommadrid/:appnumber", (req: Request, res: Response) => {

new GetXMLFromMadrid().getInfo(req, res);

});

}

/**

* Constructor

*

* @class GetXMLFromMadrid

* @constructor

*/

constructor(){

super();

}

/**

* The home page route.

*

* @class GetXMLFromMadrid

* @method index

* @param req {Request} The express Request object.

* @param res {Response} The express Response object.

* @next {NextFunction} Execute the next method.

*/

public getInfo(req: Request, res: Response) {

this.getXML(req.params.appnumber)

.then(response => {

console.log('response');

console.log(typeof(response));

res.status(200);

res.json(JSON.parse(response));

})

.catch(err => {

console.log(err);

})

}

public getXML(num: any): Promise<any> {

return new Promise(function(resolve, reject){

request.get('http://www.wipo.int/madrid/monitor/jsp/data.jsp?qi=null&TYPE=DATA&FORMAT=ROMARIN&KEY=ROM.'+ num, function (error, response, body) { //0432453; 323210

if (!error && response.statusCode == 200) {

console.log(response.headers);

// console.log(body);

let str = body.replace('encoding="ISO-8859-1"', 'encoding="UTF-8"');

// console.log(str);

let json = xmltojson.toJson(str);

// console.log(json);

resolve(json);

}else{

reject(error);

}

});

});

}

}

Файл gruntfile.js

module.exports = function(grunt) {

"use strict";

grunt.initConfig({

copy: {

build: {

files: [

{

expand: true,

cwd: "./src/public",

src: ["**"],

dest: "./www/public"

},

{

expand: true,

cwd: "./src/views",

src: ["**"],

dest: "./www/views"

}

]

}

},

ts: {

app: {

files: [{

src: ["src/\*\*/\*.ts", "!src/.baseDir.ts"],

dest: "./www"

}],

options: {

experimentalDecorators: true,

module: "commonjs",

target: "es6",

sourceMap: false,

rootDir: "src"

}

}

},

watch: {

ts: {

files: ["src/\*\*/\*.ts"],

tasks: ["ts"]

},

views: {

files: ["src/views/**/*.pug"],

tasks: ["copy"]

}

}

});

grunt.loadNpmTasks("grunt-contrib-copy");

grunt.loadNpmTasks("grunt-contrib-watch");

grunt.loadNpmTasks("grunt-ts");

grunt.registerTask("default", [

"copy",

"ts"

]);

};

Фрагменты клиентского приложения

Файл main.ts

import { enableProdMode } from '@angular/core';

import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';

import { AppModule } from './app/app.module';

import { environment } from './environments/environment';

if (environment.production) {

enableProdMode();

}

platformBrowserDynamic().bootstrapModule(AppModule)

.catch(err => console.log(err));

Файл index.ts

<!doctype html>

<html lang="en">

<head>

<meta charset="utf-8">

<title>MadridFront</title>

<base href="/">

<meta name="viewport" content="width=device-width, initial-scale=1">

<link rel="icon" type="image/x-icon" href="favicon.ico">

<link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">

<link href="~@angular/material/prebuilt-themes/indigo-pink.css" rel="stylesheet" >

</head>

<body>

<app-root></app-root>

</body>

</html>

Файл requests.service.ts:

'use strict';

import { Injectable } from '@angular/core';

import { Observable } from 'rxjs/Observable';

import { Http, Response, Headers, RequestOptions } from '@angular/http';

import 'rxjs/add/operator/map';

import 'rxjs/add/operator/catch';

import 'rxjs/add/observable/throw';

@Injectable()

export class RequestsService {

private apiUrl = 'http://nemirovich.pw/api/';

constructor (private http: Http) {}

getRequest(apiUrl, allParams): Observable<any> {

const requestOptions = new RequestOptions();

requestOptions.params = allParams;

const headers = new Headers({ 'Accept-Language': 'ru' });

requestOptions.headers = headers;

return this.http.get(apiUrl || this.apiUrl, requestOptions)

.map((res) => {

return res.json();

})

.catch((error: any) => {

return Observable.throw(error.json().message || 'Server error');

});

}

postBase(url, params) {

const headers = new Headers({

'Content-Type': 'application/x-www-form-urlencoded',

});

return this.http.post(url, params, {headers: headers})

.map((res) => {

return res.json();

})

.catch((error: any) => {

return Observable.throw(error.json().message || 'Server error');

});

}

}

Файл getxml.component.ts

import { Component, OnInit } from '@angular/core';

import { Router, ActivatedRoute, Params } from '@angular/router';

import { RequestsService } from './../../services/requests.service';

import 'rxjs/add/operator/map';

import 'rxjs/add/operator/catch';

import 'rxjs/add/observable/throw';

import { AppComponent } from './../../app/app.component';

import { environment } from '../../environments/environment';

import { isArray } from 'util';

import { element } from 'protractor';

@Component({

templateUrl: './getxml.component.html',

styleUrls: ['./getxml.component.scss'],

selector: 'get-xml'

})

export class GetXMLComponent implements OnInit {

appNumber: string;

appData: any;

editedData: Array<any>;

tags: Object;

status: Object;

qz: any;

eventArray: Array<any>;

statusArray: any;

constructor(

private Requests: RequestsService

){

this.appNumber = '';

this.tags = environment.tags;

this.status = environment.status;

this.eventArray = new Array();

}

ngOnInit() {

}

getjson(number: string) {

this.appData = undefined;

this.Requests.getRequest('http://nemirovich.pw/api/getappfrommadrid/' + number, null) // 323210

.subscribe(response => {

this.appData = response;

this.eventArray = [];

this.editData(response.MARKGR);

});

}

editData(data){

let statusArray: {[key: string]: any} = {};

// создаем массив событий (только те, что описаны в конфиге)

for (const key in this.status) {

if (this.status.hasOwnProperty(key)) {

statusArray[key] = data[key];

}

}

// добавляем в глобальный массив только события связанные с россией

for (var key in statusArray) {

if (statusArray.hasOwnProperty(key)) {

if(!isArray(statusArray[key])) {

this.addEvent({

name: key,

[key]: statusArray[key]

})

}

else {

statusArray[key].forEach(element => {

if(!isArray(element)) {

this.addEvent({

name: key,

[key]: element

})

}

});

}

}

}

console.log(this.eventArray);

// сортировка массива событий по хронологии

this.eventArray = this.eventArray.sort((a, b) => {

var aDate, bDate;

for (const key in a) {

if (a.hasOwnProperty(key)) {

const element = a[key];

aDate = element.REGEDAT;

}

}

for (const key in b) {

if (b.hasOwnProperty(key)) {

const element = b[key];

bDate = element.REGEDAT;

}

}

return aDate - bDate

});

// добавляем тип событий

this.eventArray.forEach((value, i, arr) => {

let typeOfStatus = [];

for (const key in environment.typeOfStatus) {

if (environment.typeOfStatus.hasOwnProperty(key)) {

let type: any[] = environment.typeOfStatus[key];

if (type.includes(arr[i].name)) {

typeOfStatus.push(key);

}

}

}

arr[i].typeOfStatus = typeOfStatus;

});

this.analizeStatus();

}

analizeStatus() {

console.log(this.eventArray);

let basicInfo: any;

basicInfo = this.appData.MARKGR.CURRENT.BASICGS; // Изначальные классы

this.statusArray = basicInfo;

this.statusArray.isDeleteAll = false;

console.log('Изначальные классы');

console.log(basicInfo);

this.eventArray.forEach((event, i, arr)=>{

console.log('######################################################');

console.log('Событие: ' + event.name);

console.log('тип события: ' + event.typeOfStatus);

console.log(event);

this.partialRefusalDetails(event);

if (environment.typeOfStatus.START.some((e, i, arr)=>{

return e === event.name ? true : false;

})) {

this.statusArray.isDeleteAll = false;

} else if (environment.typeOfStatus.STOP.some((e, i, arr)=>{

return e === event.name ? true : false;

})) {

this.statusArray.isDeleteAll = true;

}

console.log('######################################################');

})

console.log(this.statusArray);

}

partialRefusalDetails(event: any) {

let status = event[event.name];

if (status['PRF']) {

let prf = status.PRF;

console.log(prf);

if (prf.hasOwnProperty('GSFOOTEN')) {

// Строка на английском начинаем искать совпадения

let isContain = environment.dictionaryAnalysis.GSFOOTEN.some((word, i, arr) => {

// console.log(word);

// console.log(prf.GSFOOTEN);

if (prf.GSFOOTEN.indexOf(word) !== -1) {

return true;

};

});

if (isContain) {

console.log('удалить соответствия');

if (prf.GSFOOTEN.indexOf('limited to class') !== -1){

let words = prf.GSFOOTEN.split(/(?:,| |\(|\)|\.)+/);

console.log(words);

let classNumbers = [];

words.forEach(element => {

if(!(/\D/.test(element))){

if (element.length === 1) {

classNumbers.push('0' + element);

} else {

classNumbers.push(element);

}

}

});

console.log(classNumbers);

let arr = [];

for (let i = 0; i < classNumbers.length; i++) {

for (let j = 0; j < this.statusArray.GSGR.length; j++) {

if(classNumbers[i] === this.statusArray.GSGR[j].NICCLAI){

arr.push(this.statusArray.GSGR[j]);

}

}

}

console.log(arr);

this.statusArray.GSGR = arr;

} else {

let words = prf.GSFOOTEN.split(/(?:,| |\(|\)|\.)+/);

console.log(words);

let classNumbers = [];

words.forEach(element => {

if(!(/\D/.test(element))){

if (element.length === 1) {

classNumbers.push('0' + element);

} else {

classNumbers.push(element);

}

}

});

console.log(classNumbers);

for (let i = 0; i < classNumbers.length; i++) {

for (let j = 0; j < this.statusArray.GSGR.length; j++) {

if(classNumbers[i] === this.statusArray.GSGR[j].NICCLAI){

this.statusArray.GSGR.splice(j, 1);

j--;

}

}

}

}

}

}

if(prf.hasOwnProperty('REMVD')){

let remvd = prf.REMVD;

// console.log('REMVD:');

// console.log(remvd);

for (let i = 0; i < remvd.length; i++) {

// console.log(remvd[i]);

for (let j = 0; j < this.statusArray.GSGR.length; j++) {

if(remvd[i].NICCLAI === this.statusArray.GSGR[j].NICCLAI) {

let words = remvd[i].GSTERMEN.split(/(?:,| |\(|\)|\.)+/);

// console.log(words);

// console.log(this.statusArray.GSGR[j].GSTERMEN);

words.forEach(element => {

// console.log(this.statusArray.GSGR[j].GSTERMEN.replace(new RegExp(element,'g'), ''));

this.statusArray.GSGR[j].GSTERMEN =

(this.statusArray.GSGR[j].GSTERMEN.toLowerCase()).replace(new RegExp(element.toLowerCase(),'g'), '');

});

console.log(this.statusArray);

}

}

}

}

if(prf.hasOwnProperty('LIMTO')){

let limto = prf.LIMTO;

for (let i = 0; i < limto.length; i++) {

for (let j = 0; j < this.statusArray.GSGR.length; j++) {

if(limto[i].NICCLAI === this.statusArray.GSGR[j].NICCLAI) {

this.statusArray.GSGR[j] = limto[i];

}

}

}

}

}

if(event.name === 'PCN'){

let pcn = status;

if(pcn.hasOwnProperty('GSHEADEN')){

let words = pcn.GSHEADEN.split(/(?:,| |\(|\)|\.)+/);

console.log(words);

let classNumbers = [];

words.forEach(element => {

if(!(/\D/.test(element))){

if (element.length === 1) {

classNumbers.push('0' + element);

} else {

classNumbers.push(element);

}

}

});

console.log(classNumbers);

for (let i = 0; i < classNumbers.length; i++) {

for (let j = 0; j < this.statusArray.GSGR.length; j++) {

if(classNumbers[i] === this.statusArray.GSGR[j].NICCLAI){

this.statusArray.GSGR.splice(j, 1);

}

}

}

}

};

}

objectToArray(object: Object){

let KeyArray: Array<string>;

KeyArray = Object.keys(object);

return KeyArray;

}

getDate(date: string) {

let newDate: Date = new Date( +date.substr(0, 4), +date.substr(4, 2) - 1, +date.substr(6, 2));

return newDate;

}

addEvent(event){

var country: string = 'RU';

var homeCountry: string = this.appData.MARKGR.OOCD;

console.log(homeCountry);

for (const key in event) {

if(event[key] && event.hasOwnProperty(key)){

// console.log(event[key]);

if(event[key].hasOwnProperty('INTOFF') && (key !== 'ENN')){

// console.log(event[key].INTOFF);

if (event[key].INTOFF === country){

this.eventArray.push(event);

return

}

}

if(event[key].hasOwnProperty('INTOFF') && (key === 'PCN')){

// console.log(event[key].INTOFF);

if ((event[key].INTOFF === country || (event[key].INTOFF === homeCountry))){

this.eventArray.push(event);

return

}

}

if (event[key].hasOwnProperty('DCPCD')){

if (isArray(event[key].DCPCD)){

if (event[key].DCPCD.indexOf(country) !== -1){

this.eventArray.push(event);

return

}

} else {

if (event[key].DCPCD === country){

this.eventArray.push(event);

return

}

}

}

if (event[key].hasOwnProperty('DESAG')){

if (isArray(event[key].DESAG.DCPCD)){

if (event[key].DESAG.DCPCD.indexOf(country) !== -1){

this.eventArray.push(event);

return

}

} else {

if (event[key].DESAG.DCPCD === country){

this.eventArray.push(event);

return

}

}

}

if (event[key].hasOwnProperty('DESPG')){

if (isArray(event[key].DESPG.DCPCD)){

if (event[key].DESPG.DCPCD.indexOf(country) !== -1){

this.eventArray.push(event);

return

}

} else {

if (event[key].DESPG.DCPCD === country){

this.eventArray.push(event);

return

}

}

}

if (event[key].hasOwnProperty('DESPG2')){

if (isArray(event[key].DESPG2.DCPCD)){

if (event[key].DESPG2.DCPCD.indexOf(country) !== -1){

this.eventArray.push(event);

return

}

} else {

if (event[key].DESPG2.DCPCD === country){

this.eventArray.push(event);

return

}

}

}

}

}

}

}

Файл getxml.component.html

<div class="main-block">

<div [ngClass]="{'no-content':!appData}">

<h1>Найти информацию о товарном знаке</h1>

<mat-card class="card-find">

<p>{{qz}}</p>

<form class="example-form">

<mat-form-field class="example-full-width">

<input matInput placeholder="Введите номер заявки" [(ngModel)]="appNumber" name="appNumber" type="number" />

</mat-form-field><br>

<button mat-raised-button color="primary" (click)="getjson(appNumber)">Найти</button>

</form>

</mat-card>

<mat-card class="card-content" *ngIf = "appData.MARKGR">

<h2>{{tags.MARKGR}}</h2>

<span>{{tags.INTREGN}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.INTREGN}}</span><br><br>

<span>{{tags.BILING}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.BILING}}</span><br><br>

<span>{{tags.OOCD}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.OOCD | country}}</span><br><br>

<span>{{tags.INTREGD}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.INTREGD | customDate}}</span><br><br>

<span>{{tags.EXPDATE}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.EXPDATE | customDate}}</span><br><br>

<span>{{tags.ORIGLAN}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.ORIGLAN | lang}}</span><br><br>

</mat-card>

<mat-card class="card-content" *ngIf = "appData.MARKGR && appNumber">

<img src="http://www.wipo.int/madrid/monitor/jsp/data.jsp?KEY=ROM_ACT.{{appNumber}}&TYPE=jpg">

</mat-card>

<mat-card class="card-content" *ngIf = "appData.MARKGR && eventArray">

<h2>События для РФ</h2>

<ol class="chrono-line">

<li *ngFor = "let event of eventArray">

<p class="diplome">{{event.name}}</p>

<span class="point"></span>

<p class="description">

{{event[event.name].REGEDAT | customDate}}

{{status[event.name]}}

</p>

</li>

</ol>

</mat-card>

<mat-card class="card-content" *ngIf = "appData.MARKGR && statusArray">

<h2>Текущий статус защиты в РФ</h2>

<p *ngIf="statusArray.isDeleteAll">Не защищается на територии РФ</p>

<ol *ngIf="!statusArray.isDeleteAll">

<li *ngFor = "let status of statusArray.GSGR">

<p>{{status.NICCLAI}}</p>

<p>{{status.GSTERMEN}}</p>

</li>

</ol>

</mat-card>

</div>

<div *ngIf = "appData.MARKGR">

<mat-card class="card-content" *ngIf = "appData.MARKGR.CURRENT">

<h2>{{tags.CURRENT}}</h2>

<mat-accordion *ngIf = 'appData.MARKGR.CURRENT.HOLGR'>

<mat-expansion-panel>

<mat-expansion-panel-header>

<mat-panel-title class="card-accordion-title">

{{tags.HOLGR}}

</mat-panel-title>

</mat-expansion-panel-header>

<span>{{tags.NAME}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.CURRENT.HOLGR.NAME.NAMEL}}</span><br><br>

<span>{{tags.ADDRESS}}:</span>

<span class="card-content-colorspan">

{{appData.MARKGR.CURRENT.HOLGR.ADDRESS.ADDRL[0]}},

{{appData.MARKGR.CURRENT.HOLGR.ADDRESS.ADDRL[1]}},

{{appData.MARKGR.CURRENT.HOLGR.ADDRESS.COUNTRY | country}}

</span>

<span *ngIf = 'appData.MARKGR.CURRENT.HOLGR.CORRIND !== undefind'>({{tags.CORRIND}})</span><br><br>

<span>{{tags.ENTNATL}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.CURRENT.HOLGR.ENTNATL | country}}</span>

</mat-expansion-panel>

</mat-accordion>

<mat-accordion *ngIf = 'appData.MARKGR.CURRENT.REPGR'>

<mat-expansion-panel>

<mat-expansion-panel-header>

<mat-panel-title class="card-accordion-title">

{{tags.REPGR}}

</mat-panel-title>

</mat-expansion-panel-header>

<span>{{tags.NAME}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.CURRENT.REPGR.NAME.NAMEL}}</span><br><br>

<span>{{tags.ADDRESS}}:</span>

<span class="card-content-colorspan">

{{appData.MARKGR.CURRENT.REPGR.ADDRESS.ADDRL[0]}},

{{appData.MARKGR.CURRENT.REPGR.ADDRESS.ADDRL[1]}},

{{appData.MARKGR.CURRENT.REPGR.ADDRESS.COUNTRY | country}}

</span>

<span *ngIf = 'appData.MARKGR.CURRENT.REPGR.CORRIND !== undefind'>({{tags.CORRIND}})</span><br><br>

<span>{{tags.ENTNATL}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.CURRENT.REPGR.ENTNATL | country}}</span>

</mat-expansion-panel>

</mat-accordion>

<mat-accordion *ngIf = 'appData.MARKGR.CURRENT.PHOLGR'>

<mat-expansion-panel>

<mat-expansion-panel-header>

<mat-panel-title class="card-accordion-title">

{{tags.PHOLGR}}

</mat-panel-title>

</mat-expansion-panel-header>

<span>{{tags.NAME}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.CURRENT.PHOLGR.NAME.NAMEL}}</span><br><br>

<span>{{tags.ADDRESS}}:</span>

<span class="card-content-colorspan">

{{appData.MARKGR.CURRENT.PHOLGR.ADDRESS.ADDRL[0]}},

{{appData.MARKGR.CURRENT.PHOLGR.ADDRESS.ADDRL[1]}},

{{appData.MARKGR.CURRENT.PHOLGR.ADDRESS.COUNTRY | country}}

</span>

<span *ngIf = 'appData.MARKGR.CURRENT.PHOLGR.CORRIND !== undefind'>({{tags.CORRIND}})</span><br><br>

<span>{{tags.ENTNATL}}:</span><span class="card-content-colorspan"> {{appData.MARKGR.CURRENT.PHOLGR.ENTNATL | country}}</span>

</mat-expansion-panel>

</mat-accordion>

</mat-card>

</div>

</div>

Файл getxml.component.scss

.main-block{

width: calc(100% - 60px);

display: inline-block;

padding: 30px;

h1{

color: white;

width: 100%;

text-align: center;

margin: 25px 0;

}

.left-block{

display: inline-block;

width: 50%;

float: left;

position: fixed;

}

.no-content{

width: 100%;

h1{

margin-top: 200px;

}

.card-find{

width: 30%;

}

}

.right-block{

display: inline-block;

width: 50%;

float: right;

padding-top: 87px;

}

.card{

&-find{

width: 90%;

margin: 0 auto;

text-align: center;

margin-bottom: 15px;

}

&-content{

width: 90%;

margin: 0 auto;

text-align: center;

margin-bottom: 15px;

&-colorspan{

color: #3f51b5;

}

ol.chrono-line {

position: relative;

display: block;

margin: 100px;

height: 4px;

background: #3f51b5;

}

ol.chrono-line::before,

ol.chrono-line::after {

content: "";

position: absolute;

top: -8px;

display: block;

width: 0;

height: 0;

border-radius: 10px;

border: 10px solid #3f51b5;

}

ol.chrono-line::before {

left: -5px;

}

ol.chrono-line::after {

right: -10px;

border: 10px solid transparent;

border-right: 0;

border-left: 20px solid #3f51b5;

border-radius: 3px;

}

/* ---- Timeline elements ---- */

.chrono-line li {

position: relative;

display: inline-block;

float: left;

width: 100px;

font: bold 14px arial;

height: 50px;

}

.chrono-line li .diplome {

position: absolute;

top: -47px;

left: 36%;

color: #000000;

}

.chrono-line li .point {

content: "";

top: -4px;

left: 43%;

display: block;

width: 6px;

height: 6px;

border: 4px solid #3f51b5;

border-radius: 10px;

background: #fff;

position: absolute;

}

.chrono-line li .description {

display: none;

background-color: #f4f4f4;

padding: 10px;

margin-top: 20px;

position: relative;

font-weight: normal;

z-index: 1;

}

.chrono-line .description::before {

content: '';

width: 0;

height: 0;

border-left: 5px solid transparent;

border-right: 5px solid transparent;

border-bottom: 5px solid #f4f4f4;

position: absolute;

top: -5px;

left: 43%;

}

/* ---- Hover effects ---- */

.chrono-line li:hover {

cursor: pointer;

color: #3f51b5;

}

.chrono-line li:hover .description {

display: block;

}

}

&-accordion-title{

text-align: center;

display: block;

font-size: 16px;

font-weight: bold;

}

}

}

Файл country.pipe.ts

import { Pipe, PipeTransform } from '@angular/core';

import { environment } from '../environments/environment';

@Pipe({

name: 'country'

})

export class CountryPipe implements PipeTransform {

transform(value: string, args?: any): string {

return environment.countries[value];

}

}

Файл custom-date.pipe.ts

import { Pipe, PipeTransform } from '@angular/core';

import { environment } from '../environments/environment';

@Pipe({

name: 'customDate'

})

export class CustomDatePipe implements PipeTransform {

transform(value: string, args?: any): string {

const month = value.substr(4, 1) === '0' ? value.substr(5, 1) : value.substr(4, 2);

return value.substr(6, 2) + ' ' + environment.months[+month - 1] + ' ' + value.substr(0, 4) + ' года';

}

}

Файл language.pipe.ts

import { Pipe, PipeTransform } from '@angular/core';

import { environment } from '../environments/environment';

@Pipe({

name: 'customDate'

})

export class CustomDatePipe implements PipeTransform {

transform(value: string, args?: any): string {

const month = value.substr(4, 1) === '0' ? value.substr(5, 1) : value.substr(4, 2);

return value.substr(6, 2) + ' ' + environment.months[+month - 1] + ' ' + value.substr(0, 4) + ' года';

}

}

Файл app.module.ts

import { BrowserModule } from '@angular/platform-browser';

import { NgModule } from '@angular/core';

import { HttpModule } from '@angular/http';

import { BrowserAnimationsModule } from '@angular/platform-browser/animations';

import { MatInputModule } from '@angular/material/input';

import { MatCardModule } from '@angular/material/card';

import { MatButtonModule } from '@angular/material/button';

import { MatExpansionModule } from '@angular/material/expansion';

import { FormsModule } from '@angular/forms';

import { LZStringStatic } from 'lz-string';

//pipes

import { CustomDatePipe } from '../pipes/custom-date.pipe';

import { CountryPipe } from '../pipes/country.pipe';

import { LanguagePipe } from '../pipes/language.pipe';

//components

import { AppComponent } from './app.component';

import { GetXMLComponent } from './../pages/getxml/getxml.components';

//routing

import { routing } from './app.routing';

//services

import { RequestsService } from './../services/requests.service';

@NgModule({

declarations: [

AppComponent,

GetXMLComponent,

CustomDatePipe,

CountryPipe,

LanguagePipe

],

imports: [

BrowserModule,

routing,

HttpModule,

BrowserAnimationsModule,

MatInputModule,

MatCardModule,

MatButtonModule,

MatExpansionModule,

FormsModule

],

providers: [

RequestsService

],

bootstrap: [AppComponent]

})

export class AppModule { }

Файл enviroment.ts -- содержит словари и данные конфигурации

export const environment = {

production: false,

tags: {

MARKGR: 'Детали товарного знака',

INTREGN: 'Международный регистрационный номер',

BILING: 'BILING',

OOCD: 'Организация или страна регистрации',

INTREGD: 'Начальная дата регистрации знака',

EXPDATE: 'Срок окончания защиты',

ORIGLAN: 'Язык оригинала',

CURRENT: 'Текущее состояние знака',

HOLGR: 'Детали владельца',

CLID: 'Идентификатор клиента',

NOTLANG: 'Язык уведомлений',

NAME: 'Имя',

ADDRESS: 'Адрес',

ENTNATL: 'Гражданство заявителя, получателя или держателя',

CORRIND: 'Адресс для корреспонденции',

REPGR: 'Данные представителя',

PHOLGR: 'Данные предыдущего владельца'

},

lang: {

1: 'Английский',

3: 'Французский',

4: 'Испанский'

},

countries: {

'AL': 'Албания',

'AP': 'Африканская Региональная Организация интеллектуальной собственности',

'AR': 'Аргентина',

'AT': 'Австрия',

'BA': 'Босния и Герцеговина',

'BG': 'Болгария',

'BR': 'Бразилия',

'BX': 'Ведомство Бенилюкса по интеллектуальной собственности',

'CA': 'Канада',

'CH': 'Швейцария',

'CO': 'Колумбия',

'CY': 'Кипр',

'CZ': 'Чехия',

'DE': 'Германия',

'DK': 'Дания',

'EE': 'Эстония',

'ES': 'Испания',

'FI': 'Финляндия',

'FR': 'Франция',

'GB': 'Великобритания',

'GE': 'Грузия',

'GR': 'Греция',

'HR': 'Хорватия',

'HU': 'Венгрия',

'IE': 'Ирландия',

'IN': 'Индия',

'IS': 'Исландия',

'IT': 'Италия',

'JP': 'Япония',

'KH': 'Камбоджа',

'KR': 'Южная Корея',

'LT': 'Литва',

'LV': 'Латвия',

'MA': 'Морокко',

'MD': 'Молдавия',

'MK': 'Македония',

'MT': 'Мальта',

'MX': 'Мексика',

'MY': 'Малазия',

'NO': 'Норвегия',

'PE': 'Перу',

'PH': 'Филипины',

'PL': 'Польша',

'PT': 'Португалия',

'RO': 'Румыния',

'RS': 'Сербия',

'RU': 'Россия',

'SE': 'Швеция',

'SI': 'Словения',

'SK': 'Словакия',

'TN': 'Тунис',

'TR': 'Турция',

'US': 'США',

'EM': 'Бюро интеллектуальной собственности Европейского союза',

'WO': 'Всемирная организация интеллектуальной собственности (ВОИС)'

},

months: [

'Января',

'Февраля',

'Марта',

'Апреля',

'Мая',

'Июня',

'Июля',

'Августа',

'Сентября',

'Октября',

'Ноября',

'Декабря',

],

typeOfStatus: {

START: ['ENN', 'EXN'],

STOP: ['RFNT', 'FINT', 'R18NT'],

Restrict: ['LIN', 'PCN', 'CBNP', 'CPN', 'FINO', 'HRN'],

Birth: ['ENN', 'EXN', 'CPN', 'FUN', 'OBN'],

Death: ['RAN', 'REN2', 'CBNT', 'RNN', 'CPN', 'FUN', 'P2N'],

Prolong: ['REN', 'RCN'],

NewName: ['MTN', 'TRN', 'MAN', 'LIN', 'PCN', 'DBN'],

Created: ['ENN', 'CPN'],

Processed: ['REN', 'RCN', 'TRN', 'EXN', 'OBN', 'LIN', 'PCN', 'RNN', 'DBN', 'CBNP',

'CBNT', 'CEN', 'CBN1', 'CBN2', 'HRN', 'EEN1', 'FUN', 'FBN', 'RTN', 'MAN', 'MTN',

'RAN', 'CPN', 'OPN', 'RIN', 'GPN', 'GPON', 'GP2N', 'APNE', 'APNW', 'APNL', 'RFNT',

'RFNP', 'FINC', 'FINV', 'FINO', 'FINP', 'FINT', 'INNP', 'INNT', 'DIN', 'NLC', 'LLC',

'LNN', 'R18NP', 'R18NV', 'R18NT', 'FDNP', 'FDNV', 'FDNT', 'ISN'],

LicenceBirth: ['NLC'],

LicenceNewname: ['LLC'],

Paid: ['P2P'],

IRREGROUP: ['EN', 'AP', 'CB', 'CE', 'DI', 'EX', 'FI', 'GP', 'IN', 'LI', 'MA',

'MB', 'MT', 'OP', 'PC', 'RA', 'RC', 'RF', 'RN', 'RT', 'TR']

},

status: {

APNE: 'Истек срок рассмотрения или апелляции',

APNL: 'Request for review or appeal lapsed',

APNW: 'Request for review or appeal withdrawn',

CBN1: 'Judicial actions or proceedings under rule 22(1)(b) which are taking place in the Office of Origin',

CBNO: 'Other ceasing of effect of basic registration',

CBNP: 'Partial ceasing of effect of basic registration', // 2

CBNT: 'Total ceasing of effect of basic registration', // 2

CEN: 'Продолжение эффекта',

CLCN: 'Cancellation of a licence',

CPN: 'Partial Transfer of owenership', // 5

DBN: 'Division or Merger of Basic registration details', // 2

DIN: 'Disclaimer',

EEN: 'Renewal of Contracting Parties under Rule 40.3',

EENN: 'Non Renewal of Contracting Parties under Rule 40.3',

ENN: 'Новая Международная Регистрация',

EXN: 'Последующее обозначение', // 2

FBN: 'Replacement of a National Registration by an International Registration',

FDNP: 'Further decision under Rule 18 garanting partial protecton',

FDNT: 'Further decision under rule 18 refusing all of the goods and services',

FDNV: 'Further decision under Rule 18 reversing the original refusal',

FINC: 'Окончательное решение, подтверждающее первоначальный отказ',

FINO: 'Другое окончательное решение (обычно частичная отмена)',

FINT: 'Окончательное решение об отказе во всех товарах и услугах',

FINV: 'Окончательное решение об отмене первоначального отказа',

FUN: 'Merger (fusion)', // 3

GP18N: 'Предоставление защиты в соответствии с правилом 18bis (1)',

GP18NA: 'Предоставление защиты в соответствии с правилом 18bis (1)(a)',

GPN: 'Предоставление защиты',

GPON: 'Grant of protection subject to Opposition',

HRN: 'Restriction of Holders right of disposal', // 2

INNP: 'частичное аннулирование',

INNT: 'Общее аннулирование',

ISN: 'Intermediate status regarding protection',

LIN: 'Ограничение',

LNN: 'Declaration that a limitation has no effect',

MAN: 'Appointment of a representative',

MTN: 'Change of Holders Name and/or Address',

NLCN: 'New Licence',

OBN: 'Subsequent Designation resulting from conversion', // 2

OPN: 'Уведомление о возможном возражении после 18 месяцев',

PCN: 'частичное аннулирование',

R18NP: 'Окончательное решение в соответствии с правилом 18, предусматривающим частичную защиту',

R18NT: 'Окончательное решение в соответствии с правилом 18, отклоняющим все товары и услуги',

R18NV: 'Окончательное решение в соответствии с правилом 18 отменяет первоначальный отказ',

R18NVD: 'Окончательное решение в соответствии с правилом 18 отменяет первоначальный отказ от ответственности',

RAN: 'Total Cancellation (Radiation)',

RCN: 'Complementaty Renewal',

REN: 'Продление',

REN2: 'Non Renewal of International Trademark',

REN3: 'Отказ от продления некоторых Договаривающихся Сторон',

RFNP: 'Частичный Отказ',

RFNT: 'Полный отказ',

RNN: 'Renunciation of protection',

RTN: 'Refusal of transfer of ownership',

SEN: 'Payment of fees for second period of 10 years',

LIMTO: 'Goods and Services limited to:',

// ADDRESS: 'Address',

// ADDRL: 'Line of address',

// AFFCP: 'Affected Contracting Party',

// BASAPPD: 'Basic application date',

// BASAPPGR: 'Basic application details',

// BASAPPN: 'Basic Application Number',

// BASGR: 'Basic registration details',

// BASICGS: 'Basic Goods and services details',

// BASREGD: 'Basic Registration Date',

// BASREGGR: 'Basic Registration details',

// BASREGN: 'Basic registration Number',

// COLCLAEN: 'Colours claimed (English)',

// COLCLAES: 'Colours claimed (Spanish)',

// COLCLAFR: 'Colours Claimed (French)',

// COLCLAGR: 'Colours claimed details',

// COLMARI: 'Colour Mark indicator',

// COLPAREN: 'Parts of mark in colour (English)',

// COLPARES: 'Parts of mark in colour (Spanish)',

// COLPARFR: 'Parts of mark in colour (French)',

// CORRGR: 'Correspondence details',

// CORRIND: 'Correspondence Indicator',

// COUNTRY: 'Address Country code',

// CPCD: 'Contracting Party Code',

// CURRENT: 'Current status of the mark.',

// DCPCD: 'Designated Contracting Party Code',

// DESAG: 'Designations under the Agreement',

// DESPG: 'Designations under the Protocol',

// DESPG2: 'Designations under the Protocol by virtue of Article 9sexies',

// DISCLAIMEREN: 'Disclaimer (English)',

// DISCLAIMERES: 'Disclaimer (Spanish)',

// DISCLAIMERFR: 'Disclaimer (French)',

// DISCLAIMGR: 'Disclaimer',

// DURTNEN: 'Licence Duration (English)',

// DURTNES: 'Licence Duration (Spanish)',

// DURTNFR: 'Licence Duration (French)',

// ENTADDR: 'Entitlement Address.',

// ENTDOM: 'Entitlement: Domiciled',

// ENTEST: 'Entitlement: establishment',

// ENTNATL: 'Entitlement: Nationality',

// FACTS: 'Facts and decisions under rule 22(1)(a) and(c)',

// FACTSEN: 'Facts and decisions under rule 22(1)(a) and(c)',

// FACTSES: 'Facts and decisions under rule 22(1)(a) and(c)',

// FACTSFR: 'Facts and decisions under rule 22(1)(a) and(c)',

// FILINGDATE: 'Seniority filing date',

// FILINGNUMBER: 'Seniority filing number',

// FINCD: 'Final decision confirming the original disclaimer',

// FINVD: 'Final decision reversing the original disclaimer',

// GSCPSET: 'Licence Goods and Services/Contracting Party Group',

// GSFOOTEN: 'Goods and services footer (English)',

// GSFOOTES: 'Goods and services footer (Spanish)',

// GSFOOTFR: 'Goods and services footer (French)',

// GSGR: 'Goods and services details',

// GSHEADEN: 'Goods and services header (English)',

// GSHEADES: 'Goods and services header (Spanish)',

// GSHEADFR: 'Goods and services header (French)',

// GSTERMEN: 'Goods and services term (English)',

// GSTERMES: 'Goods and services term (Spanish)',

// GSTERMFR: 'Goods and services term (French)',

// HOLGR: 'Holder detilas',

// IMAGE: 'Trademark image',

// INTENTG: 'Intent to use group',

// INTREGG: 'International Registration Number details',

// INTREGN: 'International Registration Number',

// LCSEEGR: 'Licencee Details',

// LEGNATT: 'Legal Nature',

// LEGNATU: 'Legal Nature details',

// LICDCPCD: 'Designated Contracting Parties for which the licence is granted',

// LICDURTN: 'Licence Duration',

// LIMGR: 'Limitation details',

// LLCN: 'Licencee name and/or address change',

// MARCOLI: 'Mark in colour indicator',

// MARDESEN: 'Mark description (English)',

// MARDESES: 'Mark description (Spanish)',

// MARDESFR: 'Mark description (French)',

// MARDESGR: 'Mark description from the national Office',

// MARDUR: 'Mark Duration',

// MARKGR: 'Mark Details',

// MARKVE: 'Mark verbal elements',

// MARTRAN: 'Mark Transliteration',

// MARTREN: 'Mark Translation (English)',

// MARTRES: 'Mark Translation (Spanish)',

// MARTRFR: 'Mark Translation (French)',

// MARTRGR: 'Mark translation details',

// NAME: 'Name',

// NAMEL: 'Name line',

// NAMETR: 'Translitteration of Name',

// NATDECEN: 'National Declaration (English)',

// NATDECES: 'National Declaration (Spanish)',

// NATDECFR: 'National declaration (French)',

// NATDECGR: 'National Declaration',

// NATFDAT: 'National Filing Date',

// NATGR: 'National Mark Group',

// NATLTY: 'Nationality',

// NATPDAT: 'National Mark Priority Date',

// NATRDAT: 'National Mark Registration Date',

// NATRNUM: 'National Mark Registration Number',

// NEWREGN: 'New International Registration Number',

// OPPERE: 'Opposition Period End date',

// OPPERS: 'Opposition Period Start date',

// P2N: 'Second part fee has not been paid',

// PHOLGR: 'Previous holder details',

// PLAINCO: 'Place incorporated',

// PLCSEEGR: 'Previous Licencee Details',

// PREREGD: 'Previous registration date',

// PREREGG: 'Previous registration details',

// PREREGN: 'Previous registration number',

// PRF: 'Partial Refusal details',

// PRIAPPD: 'Paris Priority application date',

// PRIAPPN: 'Paris Priority Application Number',

// PRICP: 'Paric Priority Country code',

// PRIDATE: 'Seniority Priority date',

// PRIGR: 'Paris Priority details',

// PRIGS: 'Priority Goods and services',

// REFDAT: 'Date of Refusal',

// REFTYPE: 'Type of refusal',

// REGDATE: 'Seniority Registration date',

// REGNUMBER: 'Seniority Registration number',

// REMVD: 'Details of goods and services for which the protection has been removed',

// REPCANI: 'Representative cancelled indicator',

// REPGR: 'Representative details',

// RLCN: 'Refusal of a licence',

// ROMARIN: 'Full Electronic notification',

// SENGRP: 'Seniority Group',

// SENID: 'Seniority Id number',

// SIGVRBL: 'Verbal elements of the mark',

// SNNA: 'Seniority details added to International Registration',

// SNNR: 'Seniority details removed from International Registration',

// SOUMARI: 'Sound Mark indicator',

// STDMIND: 'Mark in standard characters indicator',

// TERRREEN: 'Territory in a Designated Contracting Parties for which the licence is granted (English)',

// TERRREES: 'Territory in a Designated Contracting Parties for which the licence is granted (Spanish)',

// TERRREFR: 'Territory in a Designated Contracting Parties for which the licence is granted (French)',

// TEXTEN: 'Free text description (English)',

// TEXTES: 'Free text description (Spanish)',

// TEXTFR: 'Free text description (French)',

// THRDMAR: 'Three dimensional mark indicator',

// TRN: 'Total Transfer of ownership',

// TYPE: 'Seniority Type',

// TYPMARI: 'Type of mark indicator',

// UFINO: 'Unpublished Other Final decision (usually a partial reversal)',

// ULIMTO: 'Goods and Services limited to:',

// UPRF: 'Partial Refusal details',

// UREMVD: 'Details of goods and services for which the protection has been removed, but for which translation and publication have not been done',

// URFNP: 'Unpublished Partial Refusal',

// VIECLA3: '3 level Vienna class',

// VIECLAI: 'Vienna class',

// VIENNAGR: 'Vienna Classification',

// VOLDESEN: 'Voluntary Mark description (English)',

// VOLDESES: 'Voluntary Mark description (Spanish)',

// VOLDESFR: 'Voluntary Mark description (French)',

// VOLDESGR: 'Voluntary Mark description from the applicant',

// VRBLNOT: 'The words contained in the mark have no meaning'

},

dictionaryAnalysis: {

GSFOOTEN: [

'limit',

'Refus',

'cancell',

'cancelled',

'subsequent',

'delete',

'deleted'

]

}

};

Размещено на Allbest.ru

...