Программная реализация надстройки над системой управления проектами "YouTrack"

Они могут быть комбинированы между друг другом при выводе конечному пользователю, и обладают возможностью скрытия любого элемента в режиме реального времени непосредственно пользователем для удобства разборки информации.

3.2 Результат разработки

Пользователь вводит свои данные и нажимает кнопку Log In. Происходит запрос к API системы YouTrack и при её успешном выполнении сохраняется cookie аутентификации. Код метода получения и сохранения cookie:

public YouTrackAuthCookie GetAuthenticationCookieFromYouTrack(string login, string password)

var request = new RestRequest("/rest/user/login", Method.POST);

request.AddParameter("login", login);

request.AddParameter("password", password);

var response = this._client.Execute(request);

this.EnsureOkResponseStatus(response, "Cannot authenticate user on YouTrack instance '{0}', login '{1}', status code {2}",

this._client.BaseUrl,

login,

response.StatusCode);

var authCookie = response.Cookies

.FirstOrDefault(cookie => cookie.Name == YOUTRACK_AUTH_COOKIE);

if (authCookie == null)

{

var message = string.Format("Cannot found YouTrack authentication cookie ({0}) in response to {1} for user {2}",

YOUTRACK_AUTH_COOKIE, this._client.BaseUrl,

login);

throw new ApplicationException(message);

}

var authCookieInfo = new YouTrackAuthCookie

{

Name = authCookie.Name,

Value = authCookie.Value,

Domain = authCookie.Domain,

Path = authCookie.Path,

HttpOnly = authCookie.HttpOnly,

Secure = authCookie.Secure,

Expires = authCookie.Expires

return authCookieInfo;

}

При успешном входе пользователь перенаправляется на главную страницу приложения (см. рис. 3.3). Если возникает ошибка авторизации, пользователю высвечивается уведомление об ошибке. Главная страница приложения содержит список поисковых запросов пользователя из YouTrack в боковой панели и список задач выбранного запроса.

В верхней панели добавлены кнопки создания новой задачи, переключения между списками задач и отчётов, выхода из приложения и поле поиска задачи, с префиксом проекта (сокращённое название проекта из YouTrack).

Запросы к Youtrack (youtrack.ts):

import * as $ from "jquery";

import { JsonCache } from "../helpers/jsonCache";

import { hashHistory } from 'react-router';

import { spaPatternUrls } from "../helpers/urlHelper";

import { Settings } from "../settings";

export class Youtrack {

private static _server: string;

constructor() {

}

private static _req(method, api_path, parametrs: string, callback, context, body?) {

const c = JsonCache.getItem<string>("authCookie");

let url = "/Proxy/" + method + Youtrack._paramsToUrl({ c: encodeURIComponent(c), p: encodeURIComponent(api_path) }) + (parametrs ? parametrs.replace("?", "&") : "");

var req = new XMLHttpRequest();

context = context || this;

req.onreadystatechange = function () {

if (req.readyState == 4) {

if (req.status == 200) {

let res = JSON.parse(req.responseText || "{}");

if (res && res.value && (res.value == "You are not logged in." || res.value == "User not found or you have no permission to read user.")) {

hashHistory.push(spaPatternUrls.auth());

}

else {

callback.call(context, res);

}

}

else {

callback.call(context, JSON.parse(req.responseText || "{}"));

}

}

};

method = method == "GET" || method == "POST" ? method : "GET";

req.open(method, url, true);

req.timeout = 40000;

if (req.setRequestHeader) {

req.setRequestHeader("Accept", "application/json");

}

req.send(body || "");

}

private static _getCurrentLogin() {

return JsonCache.getItem<string>("userLogin");

}

private static _paramsToUrl(dict) {

dict = dict ? dict : [];

const result = [];

for (let prop in dict) {

result.push("{0}={1}".replace("{0}", prop)

.replace("{1}", dict[prop]));

}

return result.length == 0 ? "" : `?${result.join("&")}`;

}

static search(query, callback, offset, context, limit) {

limit = limit || 1000;

Youtrack._req("GET",

"/rest/issue/search",

Youtrack._paramsToUrl({ y_filter: encodeURIComponent(query), y_after: encodeURIComponent(offset), y_max: encodeURIComponent(limit) }),

callback, context);

}

static getCurrentUser(callback, context) {

return this.getUserInfo("current", callback, context);

}

static getSavedSearches(callback, context) {

const login = Youtrack._getCurrentLogin();

Youtrack._req("GET",

"/rest/user/" + login + "/filter", null,

callback, context);

}

static getUserInfo(login, callback, context) {

login = login || Youtrack._getCurrentLogin() || "current";

Youtrack._req("GET",

"/rest/user/" + login, null,

callback, context);

}

static getIssues(query, callback, context) {

Youtrack._req("GET", "/rest/issue", Youtrack._paramsToUrl({ y_filter: encodeURIComponent(query) }),

callback, context);

}

static getIssue(id, callback, context) {

Youtrack._req("GET",

"/rest/issue/" + id, Youtrack._paramsToUrl({ y_wikifyDescription: true }),

callback, context);

}

static getIssuesCount(query, callback, context) {

Youtrack._req("GET", "rest/issue/count", Youtrack._paramsToUrl({ y_filter: encodeURIComponent(query) }),

callback, context);

}

static downloadAttach(link: string, callback, context) {

link = link.replace(Settings.YoutrackServer + "/_persistent/", "");

let y_file = link.split("?")[1].split("&")[0].split("=")[1];

let y_c = link.split("?")[1].split("&")[1].split("=")[1];

link = link.split("?")[0];

window.open("Attach/Get" + Youtrack._paramsToUrl({

c: encodeURIComponent(JsonCache.getItem<string>("authCookie")),

f: encodeURIComponent(link.split("?")[0]),

y_file: encodeURIComponent(y_file),

y_c: encodeURIComponent(y_c)

}), "_black");

}

static updateIssue(data: { issueId: string; title: string; description: string; }, callback, context) {

Youtrack._req("POST", "/rest/issue/" + data.issueId,

Youtrack._paramsToUrl({ y_summary: encodeURIComponent(data.title), y_description: encodeURIComponent(data.description) }),

callback, context, );

}

static executeCommand(issueId, dict, callback, context) {

let command = "";

for (let item in dict) {

command += item + " " + dict[item] + " ";

}

Youtrack._req("POST", "/rest/issue/" + issueId + "/execute", null,

callback, context, "command=" + encodeURIComponent(command));

}

static createIssue(title, description, callback, context) {

Youtrack._req("CreateIssue",

"/rest/issue",

Youtrack._paramsToUrl({ y_project: encodeURIComponent(Settings.ProjectId), y_summary: encodeURIComponent(title), y_description: encodeURIComponent(description) }),

callback, context);

}

static getIssueChanges(id, callback, context) {

Youtrack._req("GET",

"/rest/issue/" + id + "/changes", null,

callback, context);

}

static getIssueLinks(id, callback, context) {

Youtrack._req("GET",

"/rest/issue/" + id + "/link", null,

callback, context);

}

}

Кэширование данных (jsonCache.ts):

interface CacheItem<TEntity> {

value: TEntity;

userKey: number;

}

export class JsonCache {

private static _getKey(key?) {

if (!key)

key = "JsonCache";

return `JsonCache.${key}`;

}

private static _getStorage() {

return window.localStorage;

}

static removeItem(key) {

const sessionKey = this._getKey(key);

const storage = this._getStorage();

const result = storage[sessionKey] ? true : false;

storage.removeItem(sessionKey);

return result;

}

private static _getUserKey() {

return -1;

}

static getItem<TEntity>(key) {

const sessionKey = this._getKey(key);

const storage = this._getStorage();

const storageItemValue = storage.getItem(sessionKey);

const storageItemValueObject: CacheItem<TEntity> = storageItemValue && JSON.parse(storageItemValue);

let result = storageItemValueObject && storageItemValueObject.value;

if (storageItemValueObject) {

if (storageItemValueObject.userKey !== this._getUserKey()) {

this.removeItem(key);

result = null;

}

}

return result;

}

static setItem<TEntity>(key: string, value: TEntity) {

const sessionKey = this._getKey(key);

const storage = this._getStorage();

const result: CacheItem<TEntity> = { value: value, userKey: this._getUserKey() };

storage.setItem(sessionKey, JSON.stringify(result));

}

}

Работа с задачами (IssueHelper.ts):

import { Issue } from "../base";

import { Settings } from "../settings";

export class issueHelper {

static _parseDateTime(dateTime) {

let createdDate = new Date(parseInt(dateTime)).toUTCString();

return createdDate = createdDate.substring(createdDate.indexOf(",") + 2, createdDate.lastIndexOf(":"));

}

static _getDefaultValueIfEmpty(name: string, nullIfEmpty?: boolean) {

if (nullIfEmpty) return "";

return "No " + name.toLowerCase();

}

static getIssueFieldValueByName(issue: Issue, name: string, nullIfEmpty?: boolean): any {

let result;

if (!issue) return this._getDefaultValueIfEmpty(name, nullIfEmpty);

if (name == RequiredFields.id) {

return issue && issue.id || this._getDefaultValueIfEmpty(name);

}

var field = issue.field.filter(function (item) {

return item.name == name;

})[0];

if (!field) return this._getDefaultValueIfEmpty(name, nullIfEmpty);

if (name == RequiredFields.updated || name == RequiredFields.created) {

result = this._parseDateTime(field.value)

}

if (name == "Assignee") {

result = JSON.parse(JSON.stringify(field.value[0])).fullName;

}

if (name == "Estimation" || name == "Estimation DB" || name == "Estimation Web" || name == "Estimation Testing") {

result = JSON.parse(JSON.stringify(field)).valueId[0];

}

return result || field && field.value || "";

}

static getValuesForRequiredFields(issue: Issue): {

id: string;

summary: string;

description: string;

created: string;

updated: string;

reporterFullName: string;

updaterFullName: string;

attachments: string;

return {

id: this.getIssueFieldValueByName(issue, RequiredFields.id, true),

summary: this.getIssueFieldValueByName(issue, RequiredFields.summary, true),

description: this.getIssueFieldValueByName(issue, RequiredFields.description, true),

created: this.getIssueFieldValueByName(issue, RequiredFields.created, true),

updated: this.getIssueFieldValueByName(issue, RequiredFields.updated, true),

reporterFullName: this.getIssueFieldValueByName(issue, RequiredFields.reporterFullName),

updaterFullName: this.getIssueFieldValueByName(issue, RequiredFields.updaterFullName),

attachments: this.getIssueFieldValueByName(issue, RequiredFields.attachments)

}

}

static getSettingsField(fieldName: string) {

return Settings.IssueFields.filter((item) => { return item.youtrackId == fieldName })[0];

}

static isNeedToShowField(fieldName: string): boolean {

let field = this.getSettingsField(fieldName);

return !!(field && field.show);

}

static isCanBeEditField(fieldName: string): boolean {

let field = this.getSettingsField(fieldName);

return !!(field && field.edit);

}

static getFileldDisplayName(fieldName: string): string {

let field = this.getSettingsField(fieldName);

return (field && field.displayName) || fieldName;

}

static getFileldWorkflow(fieldName: string): string {

let field = this.getSettingsField(fieldName);

return (field && field.workflow) || null;

}

static getFileldDafaultValue(fieldName: string): string {

let field = this.getSettingsField(fieldName);

return (field && field.default) || this._getDefaultValueIfEmpty(fieldName);

}

}

export var RequiredFields = {

id: "id",

summary: "summary",

description: "description",

created: "created",

updated: "updated",

updaterFullName: "updaterFullName",

reporterFullName: "reporterFullName",

attachments: "attachments"

};

Извлечение значений полей (FieldsHelper.cs):

using System;

using System.Collections.Generic;

using System.Linq;

namespace Helpers

{

using System.Net;

using RestSharp;

public class FieldsHelper : BaseRestSharpHelper

{

private readonly RestClient _client;

private readonly string _youtrackUrl;

private string _authCookieValue;

private JsonConfigHelper _config;

private const string ENUM_TYPE = "enum[1]";

private const string USER_TYPE = "user[1]";

private const string VERSION_BUNDLE = "version[1]";

private const string STATE_BUNDLE = "state[1]";

private readonly string[] _supportedTypes = new string[] { ENUM_TYPE ,

USER_TYPE,

VERSION_BUNDLE,

STATE_BUNDLE };

public FieldsHelper(string youtrackUrl, JsonConfigHelper configHelper)

{

this._client = new RestClient(youtrackUrl);

_youtrackUrl = youtrackUrl;

this._client.CookieContainer = new CookieContainer();

this._config = configHelper;

}

public List<string> GetFieldValues(string projectId, string fieldName)

{

string fieldType;

string bundleName = GetEnumBundleName(projectId, fieldName, out fieldType);

List<string> filedValues = new List<string>();

if (fieldType == ENUM_TYPE)

{

filedValues = GetBundleValues(bundleName);

}

else if (fieldType == USER_TYPE)

{

filedValues = fieldName == "Assignee" ? GetAssignees(projectId) : GetUserBundleValues(bundleName);

}

else if (fieldType == VERSION_BUNDLE)

{

filedValues = fieldName == "Sprints"? null : GetVersionBundleValues(bundleName);

}

else if (fieldType == STATE_BUNDLE)

{

filedValues = GetStateBundleValues(bundleName);

}

return filedValues;

}

private List<string> GetStateBundleValues(string stateBundleName)

{

List<string> values = new List<string>();

var request = new RestRequest("/rest/admin/customfield/stateBundle/{bundleName}", Method.GET);

request.AddUrlSegment("bundleName", stateBundleName);

string authCookie = GetAdminAuthCookieValue();

AuthHelper.AddAuthCookie(request, authCookie);

var response = this._client.Execute<dynamic>(request);

this.EnsureOkResponseStatus(response, "Cannot get values for state bundle '{0}', status code {1}",

stateBundleName,

response.StatusCode);

foreach (dynamic v in response.Data["state"])

{

values.Add(v["value"]);

}

return values;

}

public string GetAdminAuthCookieValue()

{

if (!string.IsNullOrEmpty(this._authCookieValue))

{

return this._authCookieValue;

}

AuthHelper authHelper = new AuthHelper(_youtrackUrl);

var authCookie = authHelper.GetAuthenticationCookieFromYouTrack(

_config.SuperUserLogin,

_config.SuperUserPassword);

this._authCookieValue = authCookie.Value;

return this._authCookieValue;

}

private List<string> GetSprints(string versionBundleName)

{

List<string> values = new List<string>();

var request = new RestRequest("/rest/admin/customfield/versionBundle/{bundleName}", Method.GET);

request.AddUrlSegment("bundleName", versionBundleName);

string authCookie = GetAdminAuthCookieValue();

AuthHelper.AddAuthCookie(request, authCookie);

var response = this._client.Execute<dynamic>(request);

this.EnsureOkResponseStatus(response, "Cannot get values for version bundle '{0}', status code {1}",

versionBundleName,

response.StatusCode);

foreach (dynamic v in response.Data["version"])

{

values.Add(v["value"]);

}

return values;

}

private List<string> GetVersionBundleValues(string versionBundleName)

{

List<string> values = new List<string>();

var request = new RestRequest("/rest/admin/customfield/versionBundle/{bundleName}", Method.GET);

request.AddUrlSegment("bundleName", versionBundleName);

string authCookie = GetAdminAuthCookieValue();

AuthHelper.AddAuthCookie(request, authCookie);

var response = this._client.Execute<dynamic>(request);

this.EnsureOkResponseStatus(response, "Cannot get values for version bundle '{0}', status code {1}",

versionBundleName,

response.StatusCode);

foreach (dynamic v in response.Data["version"])

{

values.Add(v["value"]);

}

return values;

}

private List<string> GetAssignees(string projectName)

{

List<string> values = new List<string>();

var request = new RestRequest("/rest/admin/project/{projectName}/assignee", Method.GET);

request.AddUrlSegment("projectName", projectName);

string authCookie = GetAdminAuthCookieValue();

AuthHelper.AddAuthCookie(request, authCookie);

var response = this._client.Execute<dynamic>(request);

this.EnsureOkResponseStatus(response, "Cannot get values for user bundle '{0}', status code {1}",

projectName,

response.StatusCode);

foreach (dynamic v in response.Data["assignees"])

{

values.Add(v["login"]);

}

return values;

}

private List<string> GetUserBundleValues(string userBundleName)

{

List<string> values = new List<string>();

var request = new RestRequest("/rest/admin/customfield/userBundle/{bundleName}", Method.GET);

request.AddUrlSegment("bundleName", userBundleName);

string authCookie = GetAdminAuthCookieValue();

AuthHelper.AddAuthCookie(request, authCookie);

var response = this._client.Execute<dynamic>(request);

this.EnsureOkResponseStatus(response, "Cannot get values for user bundle '{0}', status code {1}",

userBundleName,

response.StatusCode);

foreach (dynamic v in response.Data["user"])

{

values.Add(v["login"]);

}

return values;

}

private List<string> GetBundleValues(string bundleName)

{

List<string> values = new List<string>();

var request = new RestRequest("/rest/admin/customfield/bundle/{bundleName}", Method.GET);

request.AddUrlSegment("bundleName", bundleName);

string authCookie = GetAdminAuthCookieValue();

AuthHelper.AddAuthCookie(request, authCookie);

var response = this._client.Execute<dynamic>(request);

this.EnsureOkResponseStatus(response, "Cannot get values for bundle '{0}', status code {1}",

bundleName,

response.StatusCode);

foreach (dynamic v in response.Data["value"])

{

values.Add(v["value"]);

}

return values;

}

private string GetEnumBundleName(string projectId, string fieldName, out string fieldType)

{

var request = new RestRequest("/rest/admin/project/{projectId}/customfield/{customFieldName}", Method.GET);

request.AddUrlSegment("projectId", projectId);

request.AddUrlSegment("customFieldName", fieldName);

string authCookie = GetAdminAuthCookieValue();

AuthHelper.AddAuthCookie(request, authCookie);

var response = this._client.Execute<dynamic>(request);

this.EnsureOkResponseStatus(response, "Cannot get values for field '{0}', status code {1}",

fieldName,

response.StatusCode);

fieldType = response.Data["type"];

if (!_supportedTypes.Contains(fieldType))

{

string message = string.Format("Only fields with type {0} can be returned, but {1} was returned",

string.Join(", ", _supportedTypes),

response.Data["type"]);

throw new InvalidOperationException(message);

}

return response.Data["param"][0]["value"];

}

}

}

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