snek-intel-0.2.0-rc.2.tgz

package/COPYING000644 0000000301 3560116604 010305 0ustar00000000 000000 The snek-intel is provided under:

	SPDX-License-Identifier: EUPL-1.2

Being under the terms of the European Union Public Licence version 1.2 only,
according with:

	LICENSES/preferred/EUPL-1.2package/LICENSES/preferred/EUPL-1.2000644 0000034315 3560116604 013437 0ustar00000000 000000 Valid-License-Identifier: EUPL-1.2
SPDX-URL: https://spdx.org/licenses/EUPL-1.2.html
Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'European Union Public Licence (EUPL) version 1.2 only' use:
    SPDX-License-Identifier: EUPL-1.2
License-Text:

European Union Public Licence
V. 1.2

Copyright © 2019-2020 Simon Prast

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

This Software, Data and, or Configurations are distributed under the terms of the "European Union Public Licence V. 1.2".

EUPL © the European Union 2007, 2016

This European Union Public Licence (the ‘EUPL’) applies to the Work (as
defined below) which is provided under the terms of this Licence. Any use of
the Work, other than as authorised under this Licence is prohibited (to the
extent such use is covered by a right of the copyright holder of the Work).

The Work is provided under the terms of this Licence when the Licensor (as
defined below) has placed the following notice immediately following the
copyright notice for the Work: “Licensed under the EUPL”, or has expressed by
any other means his willingness to license under the EUPL.

1. Definitions

In this Licence, the following terms have the following meaning:
— ‘The Licence’: this Licence.
— ‘The Original Work’: the work or software distributed or communicated by the
  ‘Licensor under this Licence, available as Source Code and also as
  ‘Executable Code as the case may be.
— ‘Derivative Works’: the works or software that could be created by the
  ‘Licensee, based upon the Original Work or modifications thereof. This
  ‘Licence does not define the extent of modification or dependence on the
  ‘Original Work required in order to classify a work as a Derivative Work;
  ‘this extent is determined by copyright law applicable in the country
  ‘mentioned in Article 15.
— ‘The Work’: the Original Work or its Derivative Works.
— ‘The Source Code’: the human-readable form of the Work which is the most
  convenient for people to study and modify.

— ‘The Executable Code’: any code which has generally been compiled and which
  is meant to be interpreted by a computer as a program.
— ‘The Licensor’: the natural or legal person that distributes or communicates
  the Work under the Licence.
— ‘Contributor(s)’: any natural or legal person who modifies the Work under
  the Licence, or otherwise contributes to the creation of a Derivative Work.
— ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of
  the Work under the terms of the Licence.
— ‘Distribution’ or ‘Communication’: any act of selling, giving, lending,
  renting, distributing, communicating, transmitting, or otherwise making
  available, online or offline, copies of the Work or providing access to its
  essential functionalities at the disposal of any other natural or legal
  person.

2. Scope of the rights granted by the Licence

The Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
sublicensable licence to do the following, for the duration of copyright
vested in the Original Work:

— use the Work in any circumstance and for all usage,
— reproduce the Work,
— modify the Work, and make Derivative Works based upon the Work,
— communicate to the public, including the right to make available or display
  the Work or copies thereof to the public and perform publicly, as the case
  may be, the Work,
— distribute the Work or copies thereof,
— lend and rent the Work or copies thereof,
— sublicense rights in the Work or copies thereof.

Those rights can be exercised on any media, supports and formats, whether now
known or later invented, as far as the applicable law permits so.

In the countries where moral rights apply, the Licensor waives his right to
exercise his moral right to the extent allowed by law in order to make
effective the licence of the economic rights here above listed.

The Licensor grants to the Licensee royalty-free, non-exclusive usage rights
to any patents held by the Licensor, to the extent necessary to make use of
the rights granted on the Work under this Licence.

3. Communication of the Source Code

The Licensor may provide the Work either in its Source Code form, or as
Executable Code. If the Work is provided as Executable Code, the Licensor
provides in addition a machine-readable copy of the Source Code of the Work
along with each copy of the Work that the Licensor distributes or indicates,
in a notice following the copyright notice attached to the Work, a repository
where the Source Code is easily and freely accessible for as long as the
Licensor continues to distribute or communicate the Work.

4. Limitations on copyright

Nothing in this Licence is intended to deprive the Licensee of the benefits
from any exception or limitation to the exclusive rights of the rights owners
in the Work, of the exhaustion of those rights or of other applicable
limitations thereto.

5. Obligations of the Licensee

The grant of the rights mentioned above is subject to some restrictions and
obligations imposed on the Licensee. Those obligations are the following:

Attribution right: The Licensee shall keep intact all copyright, patent or
trademarks notices and all notices that refer to the Licence and to the
disclaimer of warranties. The Licensee must include a copy of such notices and
a copy of the Licence with every copy of the Work he/she distributes or
communicates. The Licensee must cause any Derivative Work to carry prominent
notices stating that the Work has been modified and the date of modification.

Copyleft clause: If the Licensee distributes or communicates copies of the
Original Works or Derivative Works, this Distribution or Communication will be
done under the terms of this Licence or of a later version of this Licence
unless the Original Work is expressly distributed only under this version of
the Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee
(becoming Licensor) cannot offer or impose any additional terms or conditions
on the Work or Derivative Work that alter or restrict the terms of the
Licence.

Compatibility clause: If the Licensee Distributes or Communicates Derivative
Works or copies thereof based upon both the Work and another work licensed
under a Compatible Licence, this Distribution or Communication can be done
under the terms of this Compatible Licence. For the sake of this clause,
‘Compatible Licence’ refers to the licences listed in the appendix attached to
this Licence. Should the Licensee's obligations under the Compatible Licence
conflict with his/her obligations under this Licence, the obligations of the
Compatible Licence shall prevail.

Provision of Source Code: When distributing or communicating copies of the
Work, the Licensee will provide a machine-readable copy of the Source Code or
indicate a repository where this Source will be easily and freely available
for as long as the Licensee continues to distribute or communicate the Work.

Legal Protection: This Licence does not grant permission to use the trade
names, trademarks, service marks, or names of the Licensor, except as required
for reasonable and customary use in describing the origin of the Work and
reproducing the content of the copyright notice.

6. Chain of Authorship

The original Licensor warrants that the copyright in the Original Work granted
hereunder is owned by him/her or licensed to him/her and that he/she has the
power and authority to grant the Licence.

Each Contributor warrants that the copyright in the modifications he/she
brings to the Work are owned by him/her or licensed to him/her and that he/she
has the power and authority to grant the Licence.

Each time You accept the Licence, the original Licensor and subsequent
Contributors grant You a licence to their contributions to the Work, under the
terms of this Licence.

7. Disclaimer of Warranty

The Work is a work in progress, which is continuously improved by numerous
Contributors. It is not a finished work and may therefore contain defects or
‘bugs’ inherent to this type of development.

For the above reason, the Work is provided under the Licence on an ‘as is’
basis and without warranties of any kind concerning the Work, including
without limitation merchantability, fitness for a particular purpose, absence
of defects or errors, accuracy, non-infringement of intellectual property
rights other than copyright as stated in Article 6 of this Licence.

This disclaimer of warranty is an essential part of the Licence and a
condition for the grant of any rights to the Work.

8. Disclaimer of Liability

Except in the cases of wilful misconduct or damages directly caused to natural
persons, the Licensor will in no event be liable for any direct or indirect,
material or moral, damages of any kind, arising out of the Licence or of the
use of the Work, including without limitation, damages for loss of goodwill,
work stoppage, computer failure or malfunction, loss of data or any commercial
damage, even if the Licensor has been advised of the possibility of such
damage. However, the Licensor will be liable under statutory product liability
laws as far such laws apply to the Work.

9. Additional agreements

While distributing the Work, You may choose to conclude an additional
agreement, defining obligations or services consistent with this Licence.
However, if accepting obligations, You may act only on your own behalf and on
your sole responsibility, not on behalf of the original Licensor or any other
Contributor, and only if You agree to indemnify, defend, and hold each
Contributor harmless for any liability incurred by, or claims asserted against
such Contributor by the fact You have accepted any warranty or additional
liability.

10. Acceptance of the Licence

The provisions of this Licence can be accepted by clicking on an icon ‘I
agree’ placed under the bottom of a window displaying the text of this Licence
or by affirming consent in any other similar way, in accordance with the rules
of applicable law. Clicking on that icon indicates your clear and irrevocable
acceptance of this Licence and all of its terms and conditions.

Similarly, you irrevocably accept this Licence and all of its terms and
conditions by exercising any rights granted to You by Article 2 of this
Licence, such as the use of the Work, the creation by You of a Derivative Work
or the Distribution or Communication by You of the Work or copies thereof.

11. Information to the public

In case of any Distribution or Communication of the Work by means of
electronic communication by You (for example, by offering to download the Work
from a remote location) the distribution channel or media (for example, a
website) must at least provide to the public the information requested by the
applicable law regarding the Licensor, the Licence and the way it may be
accessible, concluded, stored and reproduced by the Licensee.

12. Termination of the Licence

The Licence and the rights granted hereunder will terminate automatically upon
any breach by the Licensee of the terms of the Licence. Such a termination
will not terminate the licences of any person who has received the Work from
the Licensee under the Licence, provided such persons remain in full
compliance with the Licence.

13. Miscellaneous

Without prejudice of Article 9 above, the Licence represents the complete
agreement between the Parties as to the Work.

If any provision of the Licence is invalid or unenforceable under applicable
law, this will not affect the validity or enforceability of the Licence as a
whole. Such provision will be construed or reformed so as necessary to make it
valid and enforceable.

The European Commission may publish other linguistic versions or new versions
of this Licence or updated versions of the Appendix, so far this is required
and reasonable, without reducing the scope of the rights granted by the
Licence. New versions of the Licence will be published with a unique version
number.

All linguistic versions of this Licence, approved by the European Commission,
have identical value. Parties can take advantage of the linguistic version of
their choice.

14. Jurisdiction

Without prejudice to specific agreement between parties,
— any litigation resulting from the interpretation of this License, arising
  between the European Union institutions, bodies, offices or agencies, as a
  Licensor, and any Licensee, will be subject to the jurisdiction of the Court
  of Justice of the European Union, as laid down in article 272 of the Treaty
  on the Functioning of the European Union,
— any litigation arising between other parties and resulting from the
  interpretation of this License, will be subject to the exclusive
  jurisdiction of the competent court where the Licensor resides or conducts
  its primary business.

15. Applicable Law

Without prejudice to specific agreement between parties,
— this Licence shall be governed by the law of the European Union Member State
  where the Licensor has his seat, resides or has his registered office,
— this licence shall be governed by Belgian law if the Licensor has no seat,
  residence or registered office inside a European Union Member State.

Appendix

‘Compatible Licences’ according to Article 5 EUPL are:
— GNU General Public License (GPL) v. 2, v. 3
— GNU Affero General Public License (AGPL) v. 3
— Open Software License (OSL) v. 2.1, v. 3.0
— Eclipse Public License (EPL) v. 1.0
— CeCILL v. 2.0, v. 2.1
— Mozilla Public Licence (MPL) v. 2
— GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
— Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for
  works other than software
— European Union Public Licence (EUPL) v. 1.1, v. 1.2
— Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or
  Strong Reciprocity (LiLiQ-R+)

— The European Commission may update this Appendix to later versions of the
  above licences without producing a new version of the EUPL, as long as they
  provide the rights granted in Article 2 of this Licence and protect the
  covered Source Code from exclusive appropriation.
— All other changes or additions to this Appendix require the production of a
  new EUPL version.
package/lib/utils/upload/anonfiles.js000644 0000002236 3560116604 014771 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getDownloadUrl = exports.uploadFile = void 0;
const snek_client_1 = require("snek-client");
async function getDownloadUrl(url) {
    const webClient = new snek_client_1.WebClient(url);
    let dom = await webClient.scraper.getDom("");
    return dom.getElementsByTagName("a")[1].getAttribute("href");
}
exports.getDownloadUrl = getDownloadUrl;
async function uploadFile(file) {
    let webClient = new snek_client_1.WebClient("https://api.anonfiles.com/");
    let data = new FormData();
    data.append("file", file);
    const response = await webClient.scraper.post("upload", data);
    const downloadUrl = await getDownloadUrl(response.data.file.url.short);
    const talk = {
        name: response.data.file.metadata.name,
        displayUrl: downloadUrl,
        downloadUrl: downloadUrl,
        html_url: response.data.file.url.short,
        path: "",
        repository: {
            name: "",
            full_name: "",
            html_url: "",
            owner: {
                avatar_url: "",
            },
        },
    };
    return talk;
}
exports.uploadFile = uploadFile;
package/lib/reducer/database/helper/calendar.js000644 0000003553 3560116604 016617 0ustar00000000 000000 "use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.fillCalendarWithColors = exports.generateCalendarStructure = void 0;
const moment_1 = __importDefault(require("moment"));
function generateCalendarStructure(startDate, endDate) {
    let weeks = [{ days: [] }];
    for (let m = moment_1.default(startDate); m.diff(endDate, "days") <= 0; m.add(1, "days")) {
        if (weeks[weeks.length - 1].days.length > 6) {
            weeks.push({
                days: [],
            });
        }
        let day = {
            date: m.format("YYYY-MM-DD"),
            color: "#ebedf0",
            total: 0,
        };
        weeks[weeks.length - 1].days.push(day);
    }
    let calendar = {
        startDate: moment_1.default(startDate),
        endDate: moment_1.default(endDate),
        weeks,
    };
    return calendar;
}
exports.generateCalendarStructure = generateCalendarStructure;
function fillCalendarWithColors(calendar, busiestDayTotal) {
    calendar.weeks.forEach((week) => {
        week.days.forEach((day) => {
            const precision = day.total / busiestDayTotal;
            switch (true) {
                case precision > 0.8:
                    day.color = "#196127";
                    break;
                case precision > 0.6:
                    day.color = "#239a3b";
                    break;
                case precision > 0.4:
                    day.color = "#7bc96f";
                    break;
                case precision > 0:
                    day.color = "#c6e48b";
                    break;
                default:
                    day.color = "#ebedf0";
            }
        });
    });
    return calendar;
}
exports.fillCalendarWithColors = fillCalendarWithColors;
package/lib/reducer/database/osm/statements/calendar.js000644 0000003047 3560116604 020323 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.dayByDate = exports.busiestDayBetweenDate = exports.betweenDate = exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS calendar;

CREATE TABLE IF NOT EXISTS calendar
  ( 
     id         INT NOT NULL auto_increment,
     date       DATE NOT NULL,
     total      INT NOT NULL,
     platformId INT NOT NULL REFERENCES platform (id),
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO calendar
            (date,
             total,
             platformId)
VALUES      (?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   calendar
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   calendar
ORDER BY date
`;
exports.all = all;
const betweenDate = `
SELECT *
FROM   calendar
WHERE  date >= ?
       AND date <= ?
ORDER BY date
`;
exports.betweenDate = betweenDate;
const busiestDayBetweenDate = (from, to) => `
SELECT total,
       date,
       platformId
FROM   calendar
WHERE  date >= "${from}"
       AND date <= "${to}"
       AND total IN (SELECT Max(total)
                     FROM   calendar
                     WHERE  date >= "${from}"
                            AND date <= "${to}")
`;
exports.busiestDayBetweenDate = busiestDayBetweenDate;
const dayByDate = `
SELECT id, 
       Sum(total) AS total, 
       date, 
       platformId 
FROM   calendar 
WHERE  date = ? 
GROUP  BY date 
`;
exports.dayByDate = dayByDate;
package/lib/reducer/helper/calendar.js000644 0000003555 3560116604 015055 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergedCalendar = void 0;
const moment_1 = __importDefault(require("moment"));
const models = __importStar(require("../database/models"));
function mergedCalendar() {
    let current = models.Calendar.getCalendar({
        from: moment_1.default().subtract(1, "years").day(0).format(),
        to: moment_1.default().format(),
    }).data;
    const { createdAt } = models.Platform.getLowestCreatedAtYear();
    let years = [];
    for (let year = createdAt; year <= moment_1.default().year(); year++) {
        years.push(models.Calendar.getCalendar({
            from: moment_1.default().year(year).month(0).date(1).day(0).format(),
            to: moment_1.default().year(year).month(11).date(31).format(),
        }).data);
    }
    return {
        current,
        years,
    };
}
exports.mergedCalendar = mergedCalendar;
package/lib/reducer/database/osm/statements/contribution.js000644 0000001744 3560116604 021273 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS contribution;

CREATE TABLE IF NOT EXISTS contribution
  (
     id            INT NOT NULL auto_increment,
     repoUrl       VARCHAR(2048) NOT NULL,
     datetime      DATETIME NOT NULL,
     nameWithOwner VARCHAR(80) NOT NULL,
     type          VARCHAR(80) NOT NULL,
     calendarId    INT NOT NULL REFERENCES calendar (id),
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO contribution
            (repoUrl,
             datetime,
             nameWithOwner,
             type,
             calendarId)
VALUES      (?,
             ?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   contribution
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   contribution
`;
exports.all = all;
package/lib/utils/enterprise/converter.js000644 0000036660 3560116604 015726 0ustar00000000 000000 "use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.publishEnterprisePageViaConnector = exports.getConnectors = exports.updateConnector = exports.deleteConnector = exports.addConnector = exports.getPipelines = exports.updatePipeline = exports.deletePipeline = exports.addPipeline = exports.getGitlabs = exports.updateGitlab = exports.deleteGitlab = exports.addGitlab = exports.getEnterprisePageUsersContent = exports.getEnterprisePageProjectsContent = exports.updateEnterprisePageGeneralContent = exports.getEnterprisePageGeneralContent = exports.getEnterprisePages = void 0;
const graphql_tag_1 = __importDefault(require("graphql-tag"));
const tools_1 = require("./tools");
exports.getEnterprisePages = async (session) => {
    const node = graphql_tag_1.default `
    query getAllCompanyPages($token: String!) {
      page(slug: "enterprise-pages", token: $token) {
        children {
          name: title
          handle: slug
        }
      }
    }
  `;
    return session
        .customTask("query", node, {})
        .then((res) => res.data?.page.children);
};
exports.getEnterprisePageGeneralContent = async (session, queryArgs) => {
    const node = graphql_tag_1.default `
    query enterprisePageContent($slug: String!, $token: String!) {
      page(slug: $slug, token: $token) {
        ... on EnterpriseFormPage {
          name: title
          handle: slug
          city
          zipCode
          address
          telephone
          telefax
          whatsappTelephone
          whatsappContactline
          email
          vatNumber
          taxId
          tradeRegisterNumber
          courtOfRegistry
          placeOfRegistry
          tradeRegisterNumber
          ownership
          employeeCount
          opensourceUrl
          recruitingUrl
          description
          assocConnectors: connectorScpPage {
            id
          }
          enterpriseContributors {
            id
          }
          enterpriseCodelanguageStatistic {
            name
            type
            color
            primaryExtension
            insertions
            deletions
          }
          enterpriseCodetransitionStatistic {
            insertions
            deletions
            datetime
          }
          enterpriseContributionFeed {
            type
            cid
            datetime
            message
            files {
              insertions
              deletions
              path
              rawChanges
            }
          }
        }
      }
    }
  `;
    return session
        .customTask("query", node, { ...queryArgs })
        .then((res) => {
        const page = res?.data?.page;
        page.mergedEnterpriseCodetransitionStatistic = tools_1.mergeCodetransition(page.enterpriseCodetransitionStatistic);
        page.mergedEnterpriseContributionFeed = tools_1.mergeContributionFeed(page.enterpriseContributionFeed);
        return page;
    });
};
exports.updateEnterprisePageGeneralContent = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation updateEnterprisePageGeneralContent(
      $values: GenericScalar!
      $token: String!
    ) {
      enterpriseFormPage(
        values: $values
        token: $token
        url: "/enterprise-pages/${queryArgs.slug}"
      ) {
        result
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        values: {
            ...queryArgs.imprint,
            ...queryArgs.general,
        },
    })
        .then((res) => res.data?.enterpriseFormPage);
};
exports.getEnterprisePageProjectsContent = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    query enterprisePageContent($slug: String!, $token: String!) {
      page(slug: $slug, token: $token) {
        ... on EnterpriseFormPage {
          enterpriseProjects {
            id
            title: name
            url
            description
            ownerName
            ownerUsername
            ownerEmail
            contributors {
              name
              username
              active
              contributionFeed {
                type
                cid
                datetime
                message
                files {
                  insertions
                  deletions
                  path
                  rawChanges
                }
              }
              codelanguages {
                name
                type
                color
                primaryExtension
                insertions
                deletions
              }
              codetransition {
                insertions
                deletions
                datetime
              }
            }
            contributionFeed {
              type
              cid
              datetime
              message
              files {
                insertions
                deletions
                path
                rawChanges
              }
            }
            codelanguages {
              name
              type
              color
              primaryExtension
              insertions
              deletions
            }
            codetransition {
              insertions
              deletions
              datetime
            }
          }
        }
      }
    }
  `;
    return session
        .customTask("query", node, {
        ...queryArgs,
    })
        .then((res) => {
        const projects = res.data?.page.enterpriseProjects;
        return projects?.map((project) => {
            project.mergedCodetransition = tools_1.mergeCodetransition(project.codetransition);
            project.mergedContributionFeed = tools_1.mergeContributionFeed(project.contributionFeed);
            return project;
        });
    });
};
exports.getEnterprisePageUsersContent = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    query enterprisePageContent($slug: String!, $token: String!) {
      page(slug: $slug, token: $token) {
        ... on EnterpriseFormPage {
          enterpriseContributors {
            name
            username
            active
            contributionFeed {
              type
              cid
              datetime
              message
              files {
                insertions
                deletions
                path
                rawChanges
              }
            }
            codelanguages {
              name
              type
              color
              primaryExtension
              insertions
              deletions
            }
            codetransition {
              insertions
              deletions
              datetime
            }
          }
        }
      }
    }
  `;
    return session
        .customTask("query", node, {
        ...queryArgs,
    })
        .then((res) => {
        const users = res.data?.page.enterpriseContributors;
        return users?.map((user) => {
            user.mergedCodetransition = tools_1.mergeCodetransition(user.codetransition);
            user.mergedContributionFeed = tools_1.mergeContributionFeed(user.contributionFeed);
            return user;
        });
    });
};
exports.addGitlab = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation addGitlab(
      $token: String!
      $active: Boolean!
      $description: String!
      $enterprisePageSlug: String!
      $gitlabToken: String!
      $name: String!
      $privilegesMode: String!
      $url: String!
    ) {
      addGitlab(
        token: $token
        active: $active
        description: $description
        enterprisePageSlug: $enterprisePageSlug
        gitlabToken: $gitlabToken
        name: $name
        privilegesMode: $privilegesMode
        url: $url
      ) {
        gitlab {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.addGitlab.gitlab;
    });
};
exports.deleteGitlab = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation deleteGitlab($token: String!, $id: Int!) {
      deleteGitlab(token: $token, id: $id) {
        success
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.deleteGitlab;
    });
};
exports.updateGitlab = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation updateGitlab(
      $token: String!
      $id: Int!
      $active: Boolean!
      $description: String!
      $enterprisePageSlug: String!
      $gitlabToken: String
      $name: String!
      $privilegesMode: String!
      $url: String!
    ) {
      updateGitlab(
        token: $token
        id: $id
        active: $active
        description: $description
        enterprisePageSlug: $enterprisePageSlug
        gitlabToken: $gitlabToken
        name: $name
        privilegesMode: $privilegesMode
        url: $url
      ) {
        gitlab {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.updateGitlab.gitlab;
    });
};
exports.getGitlabs = (session) => {
    const node = graphql_tag_1.default `
    query getGitlabs($token: String!) {
      gitlabs(token: $token) {
        id
        name
        description
        url
        created
        updated
        active
        enterprisePage {
          title
          slug
        }
        privilegesMode
      }
    }
  `;
    return session.customTask("query", node, {}).then((res) => {
        return res.data?.gitlabs;
    });
};
exports.addPipeline = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation addPipeline(
      $token: String!
      $enterprisePageSlug: String!
      $name: String!
      $description: String!
      $active: Boolean!
    ) {
      addPipeline(
        token: $token
        enterprisePageSlug: $enterprisePageSlug
        name: $name
        description: $description
        active: $active
      ) {
        pipeline {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.addPipeline.pipeline;
    });
};
exports.deletePipeline = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation deletePipeline($token: String!, $id: String!) {
      deletePipeline(token: $token, id: $id) {
        success
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.deletePipeline;
    });
};
exports.updatePipeline = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation updatePipeline(
      $token: String!
      $id: String!
      $active: Boolean!
      $description: String!
      $enterprisePageSlug: String!
      $name: String!
    ) {
      updatePipeline(
        token: $token
        id: $id
        active: $active
        description: $description
        enterprisePageSlug: $enterprisePageSlug
        name: $name
      ) {
        pipeline {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.updatePipeline.pipeline;
    });
};
exports.getPipelines = (session) => {
    const node = graphql_tag_1.default `
    query getPipelines($token: String!) {
      pipelines(token: $token) {
        id
        name
        description
        active
        created
        updated
        enterprisePage {
          title
          slug
        }
      }
    }
  `;
    return session
        .customTask("query", node, {})
        .then((res) => {
        return res.data?.pipelines;
    });
};
exports.addConnector = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation addConnector(
      $token: String!
      $active: Boolean!
      $url: String!
      $name: String!
      $description: String!
      $connectorToken: String!
      $enterprisePageSlug: String!
      $privilegesMode: String!
      $settings: GenericScalar
      $shareMode: String!
    ) {
      addConnector(
        token: $token
        active: $active
        url: $url
        name: $name
        description: $description
        connectorToken: $connectorToken
        enterprisePageSlug: $enterprisePageSlug
        privilegesMode: $privilegesMode
        settings: $settings
        shareMode: $shareMode
      ) {
        connector {
          id
        }
      }
    }
  `;
    return session.begin().then(async () => {
        return session
            .customTask("mutation", node, {
            ...queryArgs,
        })
            .then((res) => {
            return res.data?.addConnector.connector;
        });
    });
};
exports.deleteConnector = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation deleteConnector($token: String!, $id: Int!) {
      deleteConnector(token: $token, id: $id) {
        success
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.deleteConnector;
    });
};
exports.updateConnector = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation updateConnector(
      $token: String!
      $id: Int!
      $active: Boolean!
      $connectorToken: String!
      $description: String!
      $enterprisePageSlug: String!
      $name: String!
      $settings: GenericScalar!
      $shareMode: String!
      $url: String!
    ) {
      updateConnector(
        token: $token
        id: $id
        active: $active
        connectorToken: $connectorToken
        description: $description
        enterprisePageSlug: $enterprisePageSlug
        name: $name
        settings: $settings
        shareMode: $shareMode
        url: $url
      ) {
        connector {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.updateConnector.connector;
    });
};
exports.getConnectors = (session) => {
    const node = graphql_tag_1.default `
    query getConnectors($token: String!) {
      connectors(token: $token) {
        id
        name
        description
        url
        token
        created
        updated
        active
        enterprisePage {
          title
          slug
        }
        privilegesMode
        isHashed
        shareMode
        shareProjects
        shareUsers
        shareCompanyName
        shareCompanyRecruiting
        shareCompanyRecruementUrl
        shareCompanyDescription
        shareCompanyEmployeesCount
        shareCompanyVat
        shareCompanyEmail
        shareCompanyOpensourceStatus
        shareCompanyOpensourceUrl
      }
    }
  `;
    return session
        .customTask("query", node, {})
        .then((res) => {
        return res.data?.connectors;
    });
};
exports.publishEnterprisePageViaConnector = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation publishToEnterpriseConnector($token: String!, $connectorId: Int!) {
      publishCompanyPage(token: $token, connectorId: $connectorId) {
        success
      }
    }
  `;
    return session
        .customTask("mutation", node, { ...queryArgs })
        .then((res) => {
        return res.data?.publishCompanyPage.success;
    });
};
package/lib/utils/github/converter.js000644 0000013754 3560116604 015027 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.run = void 0;
const moment_1 = __importDefault(require("moment"));
const models = __importStar(require("../../reducer/database/models"));
const Delay_1 = __importDefault(require("../../toolbox/Delay"));
async function run(rawData) {
    const platform = models.Platform.objects.create({
        platformName: "github",
        platformUrl: "https://github.com",
        avatarUrl: rawData.profile.avatarUrl,
        websiteUrl: rawData.profile.websiteUrl,
        company: rawData.profile.company,
        email: rawData.profile.email,
        username: rawData.profile.login,
        fullName: rawData.profile.name,
        createdAt: rawData.profile.createdAt,
        location: rawData.profile.location,
        statusMessage: rawData.profile.status?.message,
        statusEmojiHTML: rawData.profile.status?.emojiHTML,
    });
    rawData.profile.organizations.edges.forEach((edge) => {
        if (edge.node) {
            let organization;
            organization = platform.createOrganization({
                avatarUrl: edge.node.avatarUrl,
                url: edge.node.url,
                name: edge.node.login,
                fullname: edge.node.name,
                description: edge.node.description,
            });
            edge.node.membersWithRole.nodes.forEach((node) => {
                organization.createMember({
                    avatarUrl: node.avatarUrl,
                    url: node.url,
                    fullname: node.name,
                    username: node.login,
                    platformId: platform.id,
                });
            });
        }
    });
    let repositories = {};
    for (let [index, yearObject] of Object.entries(rawData.calendar)) {
        await Delay_1.default(300);
        let year = yearObject;
        if (index !== "__typename") {
            let yearCount = "0";
            if (index !== "current") {
                yearCount = index.split("T")[1];
                year.contributionCalendar.weeks.forEach((week) => {
                    week.contributionDays.forEach((day) => {
                        if (day.contributionCount > 0) {
                            platform.createCalendarEntry({
                                date: moment_1.default(day.date).format("YYYY-MM-DD"),
                                total: day.contributionCount,
                            });
                        }
                    });
                });
                year.commitContributionsByRepository.forEach((node) => {
                    repositories[node.repository.nameWithOwner] = node.repository;
                });
                year.issueContributionsByRepository.forEach((node) => {
                    repositories[node.repository.nameWithOwner] = node.repository;
                });
                year.pullRequestContributionsByRepository.forEach((node) => {
                    repositories[node.repository.nameWithOwner] = node.repository;
                });
            }
            platform.createStatistic({
                year: yearCount,
                totalIssueContributions: year.totalIssueContributions,
                totalCommitContributions: year.totalCommitContributions,
                totalRepositoryContributions: year.totalRepositoryContributions,
                totalPullRequestContributions: year.totalPullRequestContributions,
                totalPullRequestReviewContributions: year.totalPullRequestReviewContributions,
                totalRepositoriesWithContributedIssues: year.totalRepositoriesWithContributedIssues,
                totalRepositoriesWithContributedCommits: year.totalRepositoriesWithContributedCommits,
                totalRepositoriesWithContributedPullRequests: year.totalRepositoriesWithContributedPullRequests,
            });
        }
    }
    Object.values(repositories).forEach((node) => {
        let owner = models.Member.objects.create({
            avatarUrl: node.owner.avatarUrl,
            url: node.owner.url,
            fullname: node.owner.login,
            username: node.owner.login,
            platformId: platform.id,
        });
        if (owner.success === false) {
            owner = models.Member.objects.filter({
                url: node.owner.url,
            })[0];
        }
        let repository = platform.createRepository({
            avatarUrl: node.openGraphImageUrl,
            url: node.url,
            name: node.nameWithOwner,
            ownerId: owner.id,
        });
        node.assignableUsers.nodes.forEach((member) => {
            repository.createMember({
                avatarUrl: member.avatarUrl,
                url: member.url,
                fullname: member.name,
                username: member.login,
                platformId: platform.id,
            });
        });
        node.languages.edges.forEach((edge) => {
            repository.createLanguage({
                color: edge.node.color,
                name: edge.node.name,
                size: edge.size,
            });
        });
    });
}
exports.run = run;
package/lib/utils/gitlab/converter.js000644 0000030313 3560116604 014775 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.runScraper = void 0;
const moment_1 = __importDefault(require("moment"));
const models = __importStar(require("../../reducer/database/models"));
function runScraper(rawData) {
    let platformName = rawData.platform.name;
    let platformUrl = rawData.platform.url;
    let avatarUrl = rawData.home.querySelectorAll('[property="og:image"]')[0]
        ?.attributes[0].value;
    avatarUrl = avatarUrl.includes("upload")
        ? platformUrl + avatarUrl
        : avatarUrl;
    let websiteUrl = rawData.home.querySelectorAll('[property="og:url"]')[0]
        ?.attributes[0].value;
    let username = rawData.home
        .querySelectorAll('[data-action="overview"]')[0]
        ?.getAttribute("href")
        ?.slice(1);
    let fullName = rawData.home.querySelectorAll('[property="og:title"]')[0]
        ?.attributes[0].value;
    let createdAt = moment_1.default(new Date(rawData.home
        .getElementsByClassName("user-info")[0]
        .getElementsByTagName("p")[0]
        .getElementsByTagName("span")[1]
        .innerHTML.split("since")[1])).format();
    let status = rawData.home.getElementsByClassName("cover-status")[0];
    let statusMessage = status?.lastChild?.textContent;
    let statusEmojiHTML = status?.getElementsByTagName("gl-emoji")[0]?.outerHTML;
    let platform = models.Platform.objects.create({
        platformName,
        platformUrl,
        avatarUrl,
        websiteUrl,
        company: null,
        email: null,
        username,
        fullName,
        createdAt,
        location: null,
        statusMessage,
        statusEmojiHTML,
    });
    let groups = new DOMParser().parseFromString(rawData.groups.html, "text/html");
    let groupList = groups
        .getElementsByClassName("content-list")[0]
        ?.getElementsByTagName("li");
    if (groupList) {
        for (let index = 0; index < groupList.length; index++) {
            const element = groupList[index];
            let avatarUrl = element
                .getElementsByClassName("avatar-container")[0]
                .getElementsByTagName("img")[0]
                ?.getAttribute("data-src");
            if (avatarUrl) {
                avatarUrl = platformUrl + avatarUrl;
            }
            else {
                avatarUrl = null;
            }
            let nameElement = element
                .getElementsByClassName("title")[0]
                .getElementsByClassName("group-name")[0];
            let url = platformUrl + nameElement.getAttribute("href");
            let name = nameElement.getAttribute("href")?.slice(1);
            let fullName = nameElement.innerHTML;
            platform.createOrganization({
                avatarUrl,
                url,
                name,
                fullname: fullName,
            });
        }
    }
    let projects = new DOMParser().parseFromString(rawData.projects.html, "text/html");
    let projectsList = projects
        .getElementsByClassName("projects-list")[0]
        ?.getElementsByTagName("li");
    if (projectsList) {
        for (let index = 0; index < projectsList.length; index++) {
            const element = projectsList[index];
            let avatarUrl = element
                .getElementsByClassName("avatar-container")[0]
                .getElementsByTagName("img")[0]
                ?.getAttribute("data-src");
            if (avatarUrl) {
                avatarUrl = platformUrl + avatarUrl;
            }
            else {
                avatarUrl = null;
            }
            let nameElement = element
                .getElementsByClassName("avatar-container")[0]
                .getElementsByTagName("a")[0];
            let url = platformUrl + nameElement.getAttribute("href");
            let name = nameElement.getAttribute("href")?.slice(1);
            platform.createRepository({
                avatarUrl,
                url,
                name,
                owner_id: null,
            });
        }
    }
    let events = new DOMParser().parseFromString(rawData.activity.html, "text/html");
    let eventList = events.getElementsByClassName("event-item");
    let days = {};
    let stats = {};
    if (eventList) {
        for (let index = 0; index < eventList.length; index++) {
            const element = eventList[index];
            const typeElementText = element.innerHTML.toLowerCase();
            let type = "undefined";
            switch (true) {
                case typeElementText.includes("pushed"):
                    type = "commit";
                    break;
                case typeElementText.includes("opened"):
                    type = "issue";
                    break;
                case typeElementText.includes("merge branch"):
                    type = "pullRequest";
                    break;
                case typeElementText.includes("created project"):
                    type = "create";
                    break;
            }
            let date = moment_1.default(element.getElementsByTagName("time")[0].dateTime);
            let name = element
                .getElementsByClassName("event-scope")[0]
                ?.getElementsByTagName("a")[0]
                .getAttribute("href");
            if (!name) {
                name = element
                    .getElementsByClassName("event-title")[0]
                    .getElementsByTagName("a")[0]
                    .getAttribute("href");
                if (!name) {
                    name = "";
                }
            }
            let moreCommitText = element
                .getElementsByClassName("commits-stat")[0]
                ?.getElementsByTagName("span")[0].innerText;
            let contributionCount = 1;
            if (moreCommitText) {
                let moreCommitsCount = moreCommitText.match(/\d/g)?.join("");
                if (moreCommitsCount) {
                    contributionCount += parseInt(moreCommitsCount);
                }
            }
            let dateStr = date.format("YYYY-MM-DD");
            let datetimeStr = date.format("YYYY-MM-DDTHH:mm:ss");
            if (!days[dateStr]?.contributions?.[`${type}`]?.datetimeStr) {
                if (days[dateStr]) {
                    if (days[dateStr].contributions) {
                        if (days[dateStr].contributions[`${type}`]) {
                            days[dateStr].contributions[`${type}`][datetimeStr] = {
                                total: contributionCount,
                                name: name.slice(1),
                                repoUrl: platformUrl + name,
                            };
                        }
                        else {
                            days[dateStr].contributions[`${type}`] = {
                                [datetimeStr]: {
                                    total: contributionCount,
                                    name: name.slice(1),
                                    repoUrl: platformUrl + name,
                                },
                            };
                        }
                        days[dateStr].total += contributionCount;
                    }
                    else {
                        days[dateStr] = {
                            contributions: {
                                [`${type}`]: {
                                    [datetimeStr]: {
                                        total: contributionCount,
                                        name: name.slice(1),
                                        repoUrl: platformUrl + name,
                                    },
                                },
                            },
                            total: contributionCount,
                        };
                    }
                }
                else {
                    days[dateStr] = {
                        contributions: {
                            [`${type}`]: {
                                [datetimeStr]: {
                                    total: contributionCount,
                                    name: name.slice(1),
                                    repoUrl: platformUrl + name,
                                },
                            },
                        },
                        total: contributionCount,
                    };
                }
            }
            if (!stats[date.year()]) {
                stats[date.year()] = { [`${type}`]: { total: 0 } };
            }
            else if (!stats[date.year()][`${type}`]) {
                stats[date.year()][`${type}`] = { total: 0 };
            }
            stats[date.year()][`${type}`].total += contributionCount;
        }
        for (let date in days) {
            let calendarDay = platform.createCalendarEntry({
                date: date,
                total: days[date].total,
            });
            for (let type in days[date].contributions) {
                for (let datetime in days[date].contributions[type]) {
                    calendarDay.createContribution({
                        repoUrl: days[date].contributions[type][datetime].repoUrl,
                        datetime,
                        nameWithOwner: days[date].contributions[type][datetime].name,
                        type: type,
                    });
                }
            }
        }
        for (let year in stats) {
            if (year === new Date().getFullYear().toString()) {
                platform.createStatistic({
                    year: 0,
                    totalIssueContributions: stats[year]["issue"]?.total
                        ? stats[year]["issue"].total
                        : 0,
                    totalCommitContributions: stats[year]["commit"]?.total
                        ? stats[year]["commit"].total
                        : 0,
                    totalRepositoryContributions: stats[year]["create"]?.total
                        ? stats[year]["create"].total
                        : 0,
                    totalPullRequestContributions: stats[year]["pullRequest"]?.total
                        ? stats[year]["pullRequest"].total
                        : 0,
                    totalPullRequestReviewContributions: 0,
                    totalRepositoriesWithContributedIssues: 0,
                    totalRepositoriesWithContributedCommits: 0,
                    totalRepositoriesWithContributedPullRequests: 0,
                });
            }
            platform.createStatistic({
                year,
                totalIssueContributions: stats[year]["issue"]?.total
                    ? stats[year]["issue"].total
                    : 0,
                totalCommitContributions: stats[year]["commit"]?.total
                    ? stats[year]["commit"].total
                    : 0,
                totalRepositoryContributions: stats[year]["create"]?.total
                    ? stats[year]["create"].total
                    : 0,
                totalPullRequestContributions: stats[year]["pullRequest"]?.total
                    ? stats[year]["pullRequest"].total
                    : 0,
                totalPullRequestReviewContributions: 0,
                totalRepositoriesWithContributedIssues: 0,
                totalRepositoriesWithContributedCommits: 0,
                totalRepositoriesWithContributedPullRequests: 0,
            });
        }
    }
}
exports.runScraper = runScraper;
package/lib/utils/ops/converter.js000644 0000036660 3560116604 014347 0ustar00000000 000000 "use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.publishEnterprisePageViaConnector = exports.getConnectors = exports.updateConnector = exports.deleteConnector = exports.addConnector = exports.getPipelines = exports.updatePipeline = exports.deletePipeline = exports.addPipeline = exports.getGitlabs = exports.updateGitlab = exports.deleteGitlab = exports.addGitlab = exports.getEnterprisePageUsersContent = exports.getEnterprisePageProjectsContent = exports.updateEnterprisePageGeneralContent = exports.getEnterprisePageGeneralContent = exports.getEnterprisePages = void 0;
const graphql_tag_1 = __importDefault(require("graphql-tag"));
const tools_1 = require("./tools");
exports.getEnterprisePages = async (session) => {
    const node = graphql_tag_1.default `
    query getAllCompanyPages($token: String!) {
      page(slug: "enterprise-pages", token: $token) {
        children {
          name: title
          handle: slug
        }
      }
    }
  `;
    return session
        .customTask("query", node, {})
        .then((res) => res.data?.page.children);
};
exports.getEnterprisePageGeneralContent = async (session, queryArgs) => {
    const node = graphql_tag_1.default `
    query enterprisePageContent($slug: String!, $token: String!) {
      page(slug: $slug, token: $token) {
        ... on EnterpriseFormPage {
          name: title
          handle: slug
          city
          zipCode
          address
          telephone
          telefax
          whatsappTelephone
          whatsappContactline
          email
          vatNumber
          taxId
          tradeRegisterNumber
          courtOfRegistry
          placeOfRegistry
          tradeRegisterNumber
          ownership
          employeeCount
          opensourceUrl
          recruitingUrl
          description
          assocConnectors: connectorScpPage {
            id
          }
          enterpriseContributors {
            id
          }
          enterpriseCodelanguageStatistic {
            name
            type
            color
            primaryExtension
            insertions
            deletions
          }
          enterpriseCodetransitionStatistic {
            insertions
            deletions
            datetime
          }
          enterpriseContributionFeed {
            type
            cid
            datetime
            message
            files {
              insertions
              deletions
              path
              rawChanges
            }
          }
        }
      }
    }
  `;
    return session
        .customTask("query", node, { ...queryArgs })
        .then((res) => {
        const page = res?.data?.page;
        page.mergedEnterpriseCodetransitionStatistic = tools_1.mergeCodetransition(page.enterpriseCodetransitionStatistic);
        page.mergedEnterpriseContributionFeed = tools_1.mergeContributionFeed(page.enterpriseContributionFeed);
        return page;
    });
};
exports.updateEnterprisePageGeneralContent = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation updateEnterprisePageGeneralContent(
      $values: GenericScalar!
      $token: String!
    ) {
      enterpriseFormPage(
        values: $values
        token: $token
        url: "/enterprise-pages/${queryArgs.slug}"
      ) {
        result
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        values: {
            ...queryArgs.imprint,
            ...queryArgs.general,
        },
    })
        .then((res) => res.data?.enterpriseFormPage);
};
exports.getEnterprisePageProjectsContent = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    query enterprisePageContent($slug: String!, $token: String!) {
      page(slug: $slug, token: $token) {
        ... on EnterpriseFormPage {
          enterpriseProjects {
            id
            title: name
            url
            description
            ownerName
            ownerUsername
            ownerEmail
            contributors {
              name
              username
              active
              contributionFeed {
                type
                cid
                datetime
                message
                files {
                  insertions
                  deletions
                  path
                  rawChanges
                }
              }
              codelanguages {
                name
                type
                color
                primaryExtension
                insertions
                deletions
              }
              codetransition {
                insertions
                deletions
                datetime
              }
            }
            contributionFeed {
              type
              cid
              datetime
              message
              files {
                insertions
                deletions
                path
                rawChanges
              }
            }
            codelanguages {
              name
              type
              color
              primaryExtension
              insertions
              deletions
            }
            codetransition {
              insertions
              deletions
              datetime
            }
          }
        }
      }
    }
  `;
    return session
        .customTask("query", node, {
        ...queryArgs,
    })
        .then((res) => {
        const projects = res.data?.page.enterpriseProjects;
        return projects?.map((project) => {
            project.mergedCodetransition = tools_1.mergeCodetransition(project.codetransition);
            project.mergedContributionFeed = tools_1.mergeContributionFeed(project.contributionFeed);
            return project;
        });
    });
};
exports.getEnterprisePageUsersContent = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    query enterprisePageContent($slug: String!, $token: String!) {
      page(slug: $slug, token: $token) {
        ... on EnterpriseFormPage {
          enterpriseContributors {
            name
            username
            active
            contributionFeed {
              type
              cid
              datetime
              message
              files {
                insertions
                deletions
                path
                rawChanges
              }
            }
            codelanguages {
              name
              type
              color
              primaryExtension
              insertions
              deletions
            }
            codetransition {
              insertions
              deletions
              datetime
            }
          }
        }
      }
    }
  `;
    return session
        .customTask("query", node, {
        ...queryArgs,
    })
        .then((res) => {
        const users = res.data?.page.enterpriseContributors;
        return users?.map((user) => {
            user.mergedCodetransition = tools_1.mergeCodetransition(user.codetransition);
            user.mergedContributionFeed = tools_1.mergeContributionFeed(user.contributionFeed);
            return user;
        });
    });
};
exports.addGitlab = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation addGitlab(
      $token: String!
      $active: Boolean!
      $description: String!
      $enterprisePageSlug: String!
      $gitlabToken: String!
      $name: String!
      $privilegesMode: String!
      $url: String!
    ) {
      addGitlab(
        token: $token
        active: $active
        description: $description
        enterprisePageSlug: $enterprisePageSlug
        gitlabToken: $gitlabToken
        name: $name
        privilegesMode: $privilegesMode
        url: $url
      ) {
        gitlab {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.addGitlab.gitlab;
    });
};
exports.deleteGitlab = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation deleteGitlab($token: String!, $id: Int!) {
      deleteGitlab(token: $token, id: $id) {
        success
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.deleteGitlab;
    });
};
exports.updateGitlab = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation updateGitlab(
      $token: String!
      $id: Int!
      $active: Boolean!
      $description: String!
      $enterprisePageSlug: String!
      $gitlabToken: String
      $name: String!
      $privilegesMode: String!
      $url: String!
    ) {
      updateGitlab(
        token: $token
        id: $id
        active: $active
        description: $description
        enterprisePageSlug: $enterprisePageSlug
        gitlabToken: $gitlabToken
        name: $name
        privilegesMode: $privilegesMode
        url: $url
      ) {
        gitlab {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.updateGitlab.gitlab;
    });
};
exports.getGitlabs = (session) => {
    const node = graphql_tag_1.default `
    query getGitlabs($token: String!) {
      gitlabs(token: $token) {
        id
        name
        description
        url
        created
        updated
        active
        enterprisePage {
          title
          slug
        }
        privilegesMode
      }
    }
  `;
    return session.customTask("query", node, {}).then((res) => {
        return res.data?.gitlabs;
    });
};
exports.addPipeline = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation addPipeline(
      $token: String!
      $enterprisePageSlug: String!
      $name: String!
      $description: String!
      $active: Boolean!
    ) {
      addPipeline(
        token: $token
        enterprisePageSlug: $enterprisePageSlug
        name: $name
        description: $description
        active: $active
      ) {
        pipeline {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.addPipeline.pipeline;
    });
};
exports.deletePipeline = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation deletePipeline($token: String!, $id: String!) {
      deletePipeline(token: $token, id: $id) {
        success
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.deletePipeline;
    });
};
exports.updatePipeline = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation updatePipeline(
      $token: String!
      $id: String!
      $active: Boolean!
      $description: String!
      $enterprisePageSlug: String!
      $name: String!
    ) {
      updatePipeline(
        token: $token
        id: $id
        active: $active
        description: $description
        enterprisePageSlug: $enterprisePageSlug
        name: $name
      ) {
        pipeline {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.updatePipeline.pipeline;
    });
};
exports.getPipelines = (session) => {
    const node = graphql_tag_1.default `
    query getPipelines($token: String!) {
      pipelines(token: $token) {
        id
        name
        description
        active
        created
        updated
        enterprisePage {
          title
          slug
        }
      }
    }
  `;
    return session
        .customTask("query", node, {})
        .then((res) => {
        return res.data?.pipelines;
    });
};
exports.addConnector = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation addConnector(
      $token: String!
      $active: Boolean!
      $url: String!
      $name: String!
      $description: String!
      $connectorToken: String!
      $enterprisePageSlug: String!
      $privilegesMode: String!
      $settings: GenericScalar
      $shareMode: String!
    ) {
      addConnector(
        token: $token
        active: $active
        url: $url
        name: $name
        description: $description
        connectorToken: $connectorToken
        enterprisePageSlug: $enterprisePageSlug
        privilegesMode: $privilegesMode
        settings: $settings
        shareMode: $shareMode
      ) {
        connector {
          id
        }
      }
    }
  `;
    return session.begin().then(async () => {
        return session
            .customTask("mutation", node, {
            ...queryArgs,
        })
            .then((res) => {
            return res.data?.addConnector.connector;
        });
    });
};
exports.deleteConnector = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation deleteConnector($token: String!, $id: Int!) {
      deleteConnector(token: $token, id: $id) {
        success
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.deleteConnector;
    });
};
exports.updateConnector = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation updateConnector(
      $token: String!
      $id: Int!
      $active: Boolean!
      $connectorToken: String!
      $description: String!
      $enterprisePageSlug: String!
      $name: String!
      $settings: GenericScalar!
      $shareMode: String!
      $url: String!
    ) {
      updateConnector(
        token: $token
        id: $id
        active: $active
        connectorToken: $connectorToken
        description: $description
        enterprisePageSlug: $enterprisePageSlug
        name: $name
        settings: $settings
        shareMode: $shareMode
        url: $url
      ) {
        connector {
          id
        }
      }
    }
  `;
    return session
        .customTask("mutation", node, {
        ...queryArgs,
    })
        .then((res) => {
        return res.data?.updateConnector.connector;
    });
};
exports.getConnectors = (session) => {
    const node = graphql_tag_1.default `
    query getConnectors($token: String!) {
      connectors(token: $token) {
        id
        name
        description
        url
        token
        created
        updated
        active
        enterprisePage {
          title
          slug
        }
        privilegesMode
        isHashed
        shareMode
        shareProjects
        shareUsers
        shareCompanyName
        shareCompanyRecruiting
        shareCompanyRecruementUrl
        shareCompanyDescription
        shareCompanyEmployeesCount
        shareCompanyVat
        shareCompanyEmail
        shareCompanyOpensourceStatus
        shareCompanyOpensourceUrl
      }
    }
  `;
    return session
        .customTask("query", node, {})
        .then((res) => {
        return res.data?.connectors;
    });
};
exports.publishEnterprisePageViaConnector = (session, queryArgs) => {
    const node = graphql_tag_1.default `
    mutation publishToEnterpriseConnector($token: String!, $connectorId: Int!) {
      publishCompanyPage(token: $token, connectorId: $connectorId) {
        success
      }
    }
  `;
    return session
        .customTask("mutation", node, { ...queryArgs })
        .then((res) => {
        return res.data?.publishCompanyPage.success;
    });
};
package/lib/utils/talks/converter.js000644 0000002520 3560116604 014650 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.run = void 0;
const models_1 = require("../../reducer/database/models");
async function run(rawData) {
    rawData.talks.forEach((item) => {
        let displayUrl = "https://docs.google.com/viewer?embedded=true&url=";
        let downloadUrl;
        if (item.displayUrl) {
            displayUrl += item.displayUrl;
            downloadUrl = item.downloadUrl;
        }
        else {
            downloadUrl = item.html_url.replace("/blob/", "/raw/");
            displayUrl += downloadUrl;
        }
        const talk = {
            name: item.name,
            url: item.html_url,
            displayUrl,
            downloadUrl,
            path: item.path,
        };
        const repository = {
            name: item.repository.name,
            url: item.repository.html_url,
            avatarUrl: item.repository.owner.avatar_url,
            owner: {
                avatarUrl: item.repository.owner.avatar_url,
                url: item.repository.owner.url,
                fullname: item.repository.owner.fullname,
                username: item.repository.owner.username,
            },
        };
        models_1.Talk.objects.create({
            ...talk,
            repositoryData: JSON.stringify(repository),
        });
    });
}
exports.run = run;
package/lib/utils/github/queries/data.js000644 0000005766 3560116604 015412 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.calendarFragment = exports.calendar = exports.profile = void 0;
const apollo_boost_1 = require("apollo-boost");
const profile = () => apollo_boost_1.gql `
  query profile($username: String!) {
    user(login: $username) {
      avatarUrl
      company
      createdAt
      name
      login
      email
      websiteUrl
      hovercard {
        contexts {
          message
          octicon
        }
      }
      isEmployee
      isHireable
      location
      status {
        emojiHTML
        message
      }
      organizations(first: 100) {
        edges {
          node {
            name
            login
            url
            avatarUrl
            name
            description
            membersWithRole(first: 100) {
              totalCount
              nodes {
                name
                login
                avatarUrl
                url
                projectsUrl
              }
            }
          }
        }
      }
    }
  }
`;
exports.profile = profile;
const calendar = (fragments) => apollo_boost_1.gql `
  query calendar ($username: String!){
    user(login: $username) {
      current: contributionsCollection {
        totalIssueContributions
        totalCommitContributions
        totalRepositoryContributions
        totalPullRequestContributions
        totalPullRequestReviewContributions
        totalRepositoriesWithContributedIssues
        totalRepositoriesWithContributedCommits
        totalRepositoriesWithContributedPullRequests
      }
      ${fragments}
    }
  }
`;
exports.calendar = calendar;
const calendarFragment = (c, fromYear, toYear) => `
  calendarT${c}: contributionsCollection(from:"${fromYear}", to:"${toYear}" ){
    totalIssueContributions
    totalCommitContributions
    totalRepositoryContributions
    totalPullRequestContributions
    totalPullRequestReviewContributions
    totalRepositoriesWithContributedIssues
    totalRepositoriesWithContributedCommits
    totalRepositoriesWithContributedPullRequests
    contributionCalendar{
      totalContributions
      weeks{
        contributionDays{
          contributionCount
          date
        }
      }
    }
    commitContributionsByRepository {
      ${contributionByRepositoryFragment}
    }
    issueContributionsByRepository {
      ${contributionByRepositoryFragment}
    }
    pullRequestContributionsByRepository {
      ${contributionByRepositoryFragment}
    }
  }
`;
exports.calendarFragment = calendarFragment;
const contributionByRepositoryFragment = `
  repository {
    openGraphImageUrl
    name
    nameWithOwner
    url
    owner{
      avatarUrl
      login
      url
    }
    assignableUsers(first:100){
      totalCount
      nodes{
        login
        name
        url
        avatarUrl
      }
    }
    languages(first: 50, orderBy: {field: SIZE, direction: DESC}) {
      totalCount
      totalSize
      edges {
        size
        node {
          name
          color
        }
      }
    }
  }
`;
package/lib/toolbox/Delay.js000644 0000000273 3560116604 013112 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function Delay(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
}
exports.default = Delay;
package/lib/reducer/database/helper/general.js000644 0000001160 3560116604 016453 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.squeezer = void 0;
function squeezer(obj, keys, exclude = ["objects"]) {
    let keysToRemove = [];
    if (keys && keys.length > 0) {
        keysToRemove = Object.keys(obj).filter((x) => !keys.includes(x));
    }
    keysToRemove.push(...exclude);
    for (let index = 0; index < keysToRemove.length; index++) {
        let proxy = new Proxy({ index }, {
            get: () => {
                return index;
            },
        });
        delete obj[keysToRemove[proxy.index]];
    }
    return obj;
}
exports.squeezer = squeezer;
package/lib/utils/oauth/GithubProvider.js000644 0000006133 3560116604 015604 0ustar00000000 000000 "use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const GuidGenerator_1 = __importDefault(require("../../toolbox/GuidGenerator"));
const config_json_1 = __importDefault(require("./config.json"));
let providerConfig = config_json_1.default.providers.github;
let details = providerConfig.details.deploy;
const state = GuidGenerator_1.default();
const GithubProvider = {
    buildAuthorizeUrl() {
        const href = window.location.href.toString();
        if (href.includes(config_json_1.default.devUrl)) {
            details = providerConfig.details.dev;
        }
        return `${providerConfig.urls.authorizeUrl}${details.redirectUrl}
        &client_id=${details.clientId}
        &client_secret=${details.clientSecret}
        &scope=${details.scope}
        &state=${state}`;
    },
    extractError(redirectUrl) {
        const errorMatch = redirectUrl.match(/error=([^&]+)/);
        if (!errorMatch) {
            return undefined;
        }
        const errorReason = errorMatch[1];
        const errorDescriptionMatch = redirectUrl.match(/error_description=([^&]+)/);
        const errorDescription = errorDescriptionMatch
            ? errorDescriptionMatch[1]
            : "";
        return new Error(`Error during login. Reason: ${errorReason} Description: ${errorDescription}`);
    },
    async extractSession(redirectUrl) {
        let data = null;
        let code = null;
        const codeMatch = redirectUrl.match(/code=([^&]+)/);
        if (codeMatch) {
            code = codeMatch[1];
        }
        let state = null;
        const stateMatch = redirectUrl.match(/state=([^&]+)/);
        if (stateMatch) {
            state = stateMatch[1];
        }
        const AuthorizeUrl = `${config_json_1.default.proxyUrl}` +
            `${providerConfig.urls.accessTokenUrl}${code}` +
            `&client_secret=${details.clientSecret}` +
            `&client_id=${details.clientId}` +
            `&redirect_uri=${details.redirectUrl}` +
            `&state=${state}`;
        await fetch(AuthorizeUrl, {
            headers: {
                "Accept": "application/json",
                "Access-Allow-Credentials": "True",
                "Access-Control-Allow-Methods": "POST",
                "Access-Control-Allow-Origin": "*",
                "Content-Type": "application/json",
                "Vary": "Origin",
            },
            method: "POST",
        })
            .then(async (res) => await res.json())
            .then(async (res) => {
            const accessToken = res.access_token;
            await fetch(`${providerConfig.urls.usernameUrl}`, {
                headers: {
                    "authorization": "Token " + accessToken,
                }
            })
                .then(async (res) => await res.json())
                .then((res) => {
                data = { username: res.login, accessToken };
                return data;
            });
        });
        return data;
    },
};
exports.default = GithubProvider;
package/lib/toolbox/GuidGenerator.js000644 0000000623 3560116604 014612 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function GuidGenerator() {
    let d = new Date().getTime();
    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
        let r = (d + Math.random() * 16) % 16 | 0;
        d = Math.floor(d / 16);
        return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
    });
}
exports.default = GuidGenerator;
package/lib/index.js000644 0000012717 3560116604 011503 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Intel = void 0;
const snek_client_1 = require("snek-client");
const reducer_1 = require("./reducer");
const github = __importStar(require("./utils/github/index"));
const gitlab = __importStar(require("./utils/gitlab/index"));
const talks = __importStar(require("./utils/talks/index"));
const upload = __importStar(require("./utils/upload/index"));
class Intel {
    constructor() {
        this.snekclient = new snek_client_1.SnekClient();
        this.reducer = new reducer_1.Reducer();
    }
    async append(source) {
        let platform = source.platform.name.toLowerCase();
        try {
            if (platform === "github") {
                let githubClient;
                if (source.platform.url) {
                    githubClient = new snek_client_1.GithubClient(source.platform.url);
                }
                else {
                    githubClient = new snek_client_1.GithubClient();
                }
                let profileData = (await githubClient.gql.sendQuery(github.queries.profile(), {
                    username: source.user,
                }, {
                    authorization: source.authorization,
                }));
                let calendarData = (await githubClient.gql.sendQuery(github.queries.calendar(profileData.data.user), {
                    username: source.user,
                }, {
                    authorization: source.authorization,
                }));
                const data = {
                    profile: profileData.data.user,
                    calendar: calendarData.data.user,
                };
                await github.converter.run(data);
            }
            else if (platform === "gitlab") {
                let gitlabClient;
                if (source.platform.url) {
                    gitlabClient = new snek_client_1.WebClient(source.platform.url);
                }
                else {
                    gitlabClient = new snek_client_1.WebClient("https://gitlab.com");
                }
                let rawData = {
                    platform: {
                        name: source.platform.name,
                        url: source.platform.url
                            ? source.platform.url
                            : "https://gitlab.com",
                    },
                    home: await gitlabClient.scraper.getDom(gitlab.paths.home(source.user)),
                    atom: await gitlabClient.scraper.getDom(gitlab.paths.atom(source.user)),
                    currentCalendar: await gitlabClient.scraper.getJson(gitlab.paths.currentCalendar(source.user)),
                    groups: await gitlabClient.scraper.getJson(gitlab.paths.groups(source.user)),
                    projects: await gitlabClient.scraper.getJson(gitlab.paths.projects(source.user)),
                    activity: await gitlabClient.scraper.getJson(gitlab.paths.activity(source.user)),
                };
                gitlab.converter.runScraper(rawData);
            }
        }
        catch (err) {
            console.error("intel.append()", err);
        }
    }
    async appendList(sources) {
        sources = sources.sort((a, b) => {
            const platformNameOrder = ["github", "gitlab"];
            const aPlatformNameIndex = platformNameOrder.indexOf(a.platform.name);
            const bPlatformNameIndex = platformNameOrder.indexOf(b.platform.name);
            return aPlatformNameIndex - bPlatformNameIndex;
        });
        for (let source in sources) {
            await this.append(sources[source]);
        }
    }
    async generateTalks(sources, organizations = []) {
        if (organizations.length === 0) {
            organizations = reducer_1.Reducer.models.Organization.objects.filter({
                platformName: "github",
            });
            organizations = organizations.map((organization) => {
                return organization.name;
            });
        }
        const usernames = sources.map((source) => {
            return source.user;
        });
        await talks.generate({
            authorization: sources[0].authorization,
            usernames,
            organizations,
        });
    }
    async appendTalk(file) {
        const talk = await upload.anonfiles.uploadFile(file);
        await talks.append(talk);
    }
    async getDownloadUrl(url) {
        let downloadUrl = await upload.anonfiles.getDownloadUrl(url);
        return downloadUrl;
    }
    async getTalks() {
        return this.reducer.getTalks();
    }
    async get() {
        return this.reducer.get();
    }
    resetReducer() {
        this.reducer.reset();
    }
}
exports.Intel = Intel;
package/lib/reducer/database/helper/index.js000644 0000002330 3560116604 016145 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.statistic = exports.general = exports.calendar = void 0;
const calendar = __importStar(require("./calendar"));
exports.calendar = calendar;
const general = __importStar(require("./general"));
exports.general = general;
const statistic = __importStar(require("./statistic"));
exports.statistic = statistic;
package/lib/reducer/database/osm/index.js000644 0000002433 3560116604 015470 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.reset = exports.models = void 0;
const models = __importStar(require("./models"));
exports.models = models;
const reconstructor_1 = require("./reconstructor");
function reset() {
    reconstructor_1.SOAssembler.database.exec("SHOW TABLES").map((table) => {
        reconstructor_1.SOAssembler.database.exec("DELETE FROM " + table.tableid);
    });
}
exports.reset = reset;
package/lib/reducer/helper/index.js000644 0000002625 3560116604 014410 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.talks = exports.language = exports.statistic = exports.profile = exports.calendar = void 0;
const calendar = __importStar(require("./calendar"));
exports.calendar = calendar;
const profile = __importStar(require("./profile"));
exports.profile = profile;
const statistic = __importStar(require("./statistic"));
exports.statistic = statistic;
const language = __importStar(require("./language"));
exports.language = language;
const talks = __importStar(require("./talks"));
exports.talks = talks;
package/lib/reducer/index.js000644 0000002701 3560116604 013124 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Reducer = void 0;
const models = __importStar(require("./database/models"));
const osm = __importStar(require("./database/osm"));
const helper = __importStar(require("./helper"));
class Reducer {
    async get() {
        return {
            profile: await helper.profile.mergedProfile(),
            statistic: await helper.statistic.mergedStatistic(),
        };
    }
    async getTalks() {
        return helper.talks.mergedTalks();
    }
    reset() {
        osm.reset();
    }
}
exports.Reducer = Reducer;
Reducer.models = models;
package/lib/utils/enterprise/index.js000644 0000005127 3560116604 015020 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const snek_client_1 = require("snek-client");
const converter_1 = require("./converter");
const converter_2 = require("./converter");
class Provider {
    constructor(opsUrl, client) {
        this.getEnterprisePages = () => converter_2.getEnterprisePages(this.snekclient.session);
        this.getEnterprisePageGeneralContent = (queryArgs) => converter_2.getEnterprisePageGeneralContent(this.snekclient.session, { ...queryArgs });
        this.updateEnterprisePageGeneralContent = (queryArgs) => converter_2.updateEnterprisePageGeneralContent(this.snekclient.session, {
            ...queryArgs,
        });
        this.getEnterprisePageProjectsContent = (queryArgs) => converter_2.getEnterprisePageProjectsContent(this.snekclient.session, { ...queryArgs });
        this.getEnterprisePageUsersContent = (queryArgs) => converter_2.getEnterprisePageUsersContent(this.snekclient.session, { ...queryArgs });
        this.snekclient = client ? client : new snek_client_1.SnekClient(opsUrl);
    }
}
class OpsProvider extends Provider {
    constructor() {
        super(...arguments);
        this.addGitlab = (queryArgs) => converter_2.addGitlab(this.snekclient.session, { ...queryArgs });
        this.deleteGitlab = (queryArgs) => converter_2.deleteGitlab(this.snekclient.session, { ...queryArgs });
        this.updateGitlab = (queryArgs) => converter_2.updateGitlab(this.snekclient.session, { ...queryArgs });
        this.getGitlabs = () => converter_2.getGitlabs(this.snekclient.session);
        this.addPipeline = (queryArgs) => converter_2.addPipeline(this.snekclient.session, { ...queryArgs });
        this.deletePipeline = (queryArgs) => converter_2.deletePipeline(this.snekclient.session, { ...queryArgs });
        this.updatePipeline = (queryArgs) => converter_2.updatePipeline(this.snekclient.session, { ...queryArgs });
        this.getPipelines = () => converter_2.getPipelines(this.snekclient.session);
        this.addConnector = (queryArgs) => converter_2.addConnector(this.snekclient.session, { ...queryArgs });
        this.deleteConnector = (queryArgs) => converter_2.deleteConnector(this.snekclient.session, { ...queryArgs });
        this.updateConnector = (queryArgs) => converter_2.updateConnector(this.snekclient.session, { ...queryArgs });
        this.getConnectors = () => converter_2.getConnectors(this.snekclient.session);
        this.publishEnterprisePageViaConnector = (queryArgs) => converter_1.publishEnterprisePageViaConnector(this.snekclient.session, {
            ...queryArgs,
        });
    }
}
exports.default = OpsProvider;
package/lib/utils/github/index.js000644 0000002162 3560116604 014116 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.converter = exports.queries = void 0;
const queries = __importStar(require("./queries"));
exports.queries = queries;
const converter = __importStar(require("./converter"));
exports.converter = converter;
package/lib/utils/github/queries/index.js000644 0000003363 3560116604 015577 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.calendar = exports.profile = void 0;
const moment_1 = __importDefault(require("moment"));
const queries = __importStar(require("./data"));
function profile() {
    return queries.profile();
}
exports.profile = profile;
function calendar(profile) {
    let date = moment_1.default(profile.createdAt);
    let fragments = "";
    const runtime = moment_1.default().year() - date.year();
    for (let index = 0; index <= runtime; index++) {
        fragments += queries.calendarFragment(date.year(), moment_1.default(date).month(0).date(1).format(), moment_1.default(date).month(11).date(31).format());
        date.add(1, "year");
    }
    return queries.calendar(fragments);
}
exports.calendar = calendar;
package/lib/utils/gitlab/index.js000644 0000002150 3560116604 014073 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.converter = exports.paths = void 0;
const paths = __importStar(require("./paths"));
exports.paths = paths;
const converter = __importStar(require("./converter"));
exports.converter = converter;
package/lib/utils/oauth/index.js000644 0000000777 3560116604 013766 0ustar00000000 000000 "use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GithubProvider = void 0;
const react_very_simple_oauth_1 = __importDefault(require("react-very-simple-oauth"));
const GithubProvider_1 = __importDefault(require("./GithubProvider"));
exports.GithubProvider = GithubProvider_1.default;
exports.default = react_very_simple_oauth_1.default;
package/lib/utils/ops/index.js000644 0000004734 3560116604 013444 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const snek_client_1 = require("snek-client");
const converter_1 = require("./converter");
const converter_2 = require("./converter");
class Provider {
    constructor(opsUrl) {
        this.getEnterprisePages = () => converter_2.getEnterprisePages(this.snekclient.session);
        this.getEnterprisePageGeneralContent = (queryArgs) => converter_2.getEnterprisePageGeneralContent(this.snekclient.session, { ...queryArgs });
        this.updateEnterprisePageGeneralContent = (queryArgs) => converter_2.updateEnterprisePageGeneralContent(this.snekclient.session, {
            ...queryArgs,
        });
        this.getEnterprisePageProjectsContent = (queryArgs) => converter_2.getEnterprisePageProjectsContent(this.snekclient.session, { ...queryArgs });
        this.getEnterprisePageUsersContent = (queryArgs) => converter_2.getEnterprisePageUsersContent(this.snekclient.session, { ...queryArgs });
        this.addGitlab = (queryArgs) => converter_2.addGitlab(this.snekclient.session, { ...queryArgs });
        this.deleteGitlab = (queryArgs) => converter_2.deleteGitlab(this.snekclient.session, { ...queryArgs });
        this.updateGitlab = (queryArgs) => converter_2.updateGitlab(this.snekclient.session, { ...queryArgs });
        this.getGitlabs = () => converter_2.getGitlabs(this.snekclient.session);
        this.addPipeline = (queryArgs) => converter_2.addPipeline(this.snekclient.session, { ...queryArgs });
        this.deletePipeline = (queryArgs) => converter_2.deletePipeline(this.snekclient.session, { ...queryArgs });
        this.updatePipeline = (queryArgs) => converter_2.updatePipeline(this.snekclient.session, { ...queryArgs });
        this.getPipelines = () => converter_2.getPipelines(this.snekclient.session);
        this.addConnector = (queryArgs) => converter_2.addConnector(this.snekclient.session, { ...queryArgs });
        this.deleteConnector = (queryArgs) => converter_2.deleteConnector(this.snekclient.session, { ...queryArgs });
        this.updateConnector = (queryArgs) => converter_2.updateConnector(this.snekclient.session, { ...queryArgs });
        this.getConnectors = () => converter_2.getConnectors(this.snekclient.session);
        this.publishEnterprisePageViaConnector = (queryArgs) => converter_1.publishEnterprisePageViaConnector(this.snekclient.session, {
            ...queryArgs,
        });
        this.snekclient = new snek_client_1.SnekClient(opsUrl);
    }
}
exports.default = Provider;
package/lib/utils/talks/index.js000644 0000004627 3560116604 013762 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.append = exports.generate = void 0;
const snek_client_1 = require("snek-client");
const paths = __importStar(require("./paths"));
const converter = __importStar(require("./converter"));
async function generate(source) {
    const client = new snek_client_1.WebClient("https://api.github.com/", {
        authorization: source.authorization,
    });
    const run = async (name, user = true) => {
        let pn = 1;
        let currentItems = 0;
        let totalItems = 1;
        while (currentItems < totalItems) {
            let path;
            if (user) {
                path = paths.user(name, pn);
            }
            else {
                path = paths.organization(name, pn);
            }
            await client.scraper
                .getJson(path)
                .then(async (response) => {
                totalItems = response.total_count;
                currentItems += response.items.length;
                await converter.run({ talks: response.items });
                pn++;
            })
                .catch((err) => {
                currentItems = totalItems;
                console.error("Talks .run()", err);
            });
        }
    };
    for (const index in source.usernames) {
        await run(source.usernames[index]);
    }
    for (const index in source.organizations) {
        await run(source.organizations[index], false);
    }
}
exports.generate = generate;
async function append(talk) {
    await converter.run({ talks: [talk] });
}
exports.append = append;
package/lib/utils/upload/index.js000644 0000002021 3560116604 014112 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.anonfiles = void 0;
const anonfiles = __importStar(require("./anonfiles"));
exports.anonfiles = anonfiles;
package/lib/reducer/database/osm/statements/language.js000644 0000003222 3560116604 020330 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.merged = exports.byRepository = exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS language;

CREATE TABLE IF NOT EXISTS language
  (
     id           INT NOT NULL auto_increment,
     color        VARCHAR(80) NULL,
     name         VARCHAR(80) NOT NULL,
     size         INT NOT NULL,
     repositoryId INT NULL REFERENCES repository (id),
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO language
            (color,
             name,
             size,
             repositoryId)
VALUES      (?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   language
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   language
`;
exports.all = all;
const byRepository = (repositoryId) => `
SELECT   l1.color,
         l1.name,
         Sum(l1.size) AS size,
         round(Sum(l1.size) /
         (
                SELECT Sum(size)
                FROM   language L2
                WHERE  repositoryId = ${repositoryId}) * 100, 2) AS share
FROM     language l1
WHERE    repositoryId = ${repositoryId}
GROUP BY name,
         color
ORDER BY size DESC
`;
exports.byRepository = byRepository;
const merged = `
SELECT L1.color,
       L1.name,
       Sum(L1.size)                                        AS size,
       Round(Sum(L1.size) / (SELECT Sum(size)
                             FROM   language L2) * 100, 2) AS share
FROM   language L1
GROUP  BY name,
          color
ORDER  BY size DESC
`;
exports.merged = merged;
package/lib/reducer/helper/language.js000644 0000002332 3560116604 015057 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergedLanguage = void 0;
const models = __importStar(require("../database/models"));
function mergedLanguage() {
    let languages = models.Language.getLanguages();
    languages.map((language) => {
        return language.render([]);
    });
    return languages;
}
exports.mergedLanguage = mergedLanguage;
package/lib/reducer/database/osm/statements/member.js000644 0000001703 3560116604 020016 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS member;

CREATE TABLE IF NOT EXISTS member
  (
     id         INT NOT NULL auto_increment,
     avatarUrl  VARCHAR(2048) NOT NULL,
     url        VARCHAR(2048) NOT NULL,
     fullname   VARCHAR(80) NULL,
     username   VARCHAR(80) NOT NULL,
     platformId INT NOT NULL REFERENCES platform (id),
     UNIQUE(url),
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO member
            (avatarUrl,
             url,
             fullname,
             username,
             platformId)
VALUES      (?,
             ?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   member
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   member
`;
exports.all = all;
package/lib/toolbox/Merge.js000644 0000001046 3560116604 013112 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergeObjectsInUnique = void 0;
function mergeObjectsInUnique(array, property) {
    const newArray = new Map();
    array.forEach((item) => {
        const propertyValue = item[property];
        newArray.has(propertyValue)
            ? newArray.set(propertyValue, { ...item, ...newArray.get(propertyValue) })
            : newArray.set(propertyValue, item);
    });
    return Array.from(newArray.values());
}
exports.mergeObjectsInUnique = mergeObjectsInUnique;
package/lib/reducer/database/models.js000644 0000043416 3560116604 015054 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Talk = exports.Calendar = exports.Streak = exports.RepositoryHasMember = exports.Member = exports.Organization = exports.Language = exports.Repository = exports.Contribution = exports.Statistic = exports.Platform = void 0;
const moment_1 = __importDefault(require("moment"));
const osm = __importStar(require("./osm"));
const helper = __importStar(require("./helper"));
class Platform extends osm.models.PlatformSO {
    constructor(args) {
        super();
        this.objects = Platform.objects;
        this.id = 0;
        this.platformName = "";
        this.platformUrl = "";
        this.avatarUrl = "";
        this.websiteUrl = "";
        this.company = "";
        this.email = "";
        this.username = "";
        this.fullName = "";
        this.createdAt = "";
        this.location = "";
        this.statusMessage = "";
        this.statusEmojiHTML = "";
        this.createdAt = "adad";
        this.id = args["id"];
        this.platformName = args["platformName"];
        this.platformUrl = args["platformUrl"];
        this.avatarUrl = args["avatarUrl"];
        this.websiteUrl = args["websiteUrl"];
        this.company = args["company"];
        this.email = args["email"];
        this.username = args["username"];
        this.fullName = args["fullName"];
        this.createdAt = args["createdAt"];
        this.location = args["location"];
        this.statusMessage = args["statusMessage"];
        this.statusEmojiHTML = args["statusEmojiHTML"];
    }
    createRepository(fields) {
        let repository = Repository.objects.create(fields);
        if (repository.success === false) {
            repository = Repository.objects.filter({
                url: fields.url,
            })[0];
        }
        PlatformHasRepository.objects.create({
            platformId: this.id,
            repositoryId: repository.id,
        });
        return repository;
    }
    createOrganization(fields) {
        let organization = Organization.objects.create(fields);
        if (organization.success === false) {
            organization = Organization.objects.filter({
                url: fields.url,
            })[0];
        }
        PlatformHasOrganization.objects.create({
            platformId: this.id,
            organizationId: organization.id,
        });
        return organization;
    }
    createStatistic(fields) {
        fields.platformId = this.id;
        let statistic = Statistic.objects.create(fields);
        return statistic;
    }
    createCalendarEntry(fields) {
        fields.platformId = this.id;
        let calendar = Calendar.objects.create(fields);
        return calendar;
    }
    getRepositories() {
        let repositories = PlatformHasRepository.objects.filter({
            platformId: this.id,
        }, Repository);
        return repositories;
    }
    getOrganizations() {
        let organizations = PlatformHasOrganization.objects.filter({
            platformId: this.id,
        }, Organization);
        return organizations;
    }
    getCalendar(dates) {
        let response = Calendar.getCalendar(dates);
        return response.data;
    }
    save() { }
}
exports.Platform = Platform;
Platform.objects = osm.models.PlatformSO.getObjects(Platform);
class Member extends osm.models.MemberSO {
    constructor(args) {
        super();
        this.objects = Member.objects;
        this.id = 0;
        this.avatarUrl = "";
        this.url = "";
        this.fullname = "";
        this.username = "";
        this.platformId = 0;
        this.id = args["id"];
        this.avatarUrl = args["avatarUrl"];
        this.url = args["url"];
        this.fullname = args["fullname"];
        this.username = args["username"];
        this.platformId = args["platformId"];
    }
    save() { }
}
exports.Member = Member;
Member.objects = osm.models.MemberSO.getObjects(Member);
class Repository extends osm.models.RepositorySO {
    constructor(args) {
        super();
        this.objects = Repository.objects;
        this.id = 0;
        this.avatarUrl = "";
        this.url = "";
        this.name = "";
        this.ownerId = 0;
        this.id = args["id"];
        this.avatarUrl = args["avatarUrl"];
        this.url = args["url"];
        this.name = args["name"];
        this.ownerId = args["ownerId"];
    }
    createMember(fields) {
        let member = Member.objects.create({
            avatarUrl: fields.avatarUrl,
            url: fields.url,
            fullname: fields.fullname,
            username: fields.username,
            platformId: fields.platformId,
        });
        if (member.success === false) {
            member = Member.objects.filter({
                url: fields.url,
            })[0];
        }
        RepositoryHasMember.objects.create({
            repositoryId: this.id,
            memberId: member.id,
        });
        return member;
    }
    createLanguage(fields) {
        fields.repositoryId = this.id;
        let language = Language.objects.create(fields);
        return language;
    }
    getMembers() {
        let members = RepositoryHasMember.objects.filter({
            repositoryId: this.id,
        }, Member);
        return members;
    }
    getLanguages() {
        let response = Language.objects.custom(Language.statements.byRepository(this.id));
        return response;
    }
    save() { }
}
exports.Repository = Repository;
Repository.objects = osm.models.RepositorySO.getObjects(Repository);
class RepositoryHasMember extends osm.models.RepositoryHasMemberSO {
    constructor() {
        super(...arguments);
        this.objects = RepositoryHasMember.objects;
        this.id = 0;
    }
    save() { }
}
exports.RepositoryHasMember = RepositoryHasMember;
RepositoryHasMember.objects = osm.models.RepositoryHasMemberSO.getObjects(RepositoryHasMember);
class Language extends osm.models.LanguageSO {
    constructor(args) {
        super();
        this.objects = Language.objects;
        this.id = 0;
        this.color = "";
        this.name = "";
        this.size = 0;
        this.share = 0;
        this.repositoryId = 0;
        this.id = args["id"];
        this.color = args["color"];
        this.name = args["name"];
        this.size = args["size"];
        this.share = args["share"];
        this.repositoryId = args["repositoryId"];
    }
    static getLanguages() {
        let response = this.objects.custom(Language.statements.merged);
        response = response.map((entry) => {
            return new Language(entry);
        });
        return response;
    }
    save() { }
}
exports.Language = Language;
Language.objects = osm.models.LanguageSO.getObjects(Language);
class PlatformHasRepository extends osm.models.PlatformHasRepositorySO {
    constructor() {
        super(...arguments);
        this.objects = PlatformHasRepository.objects;
        this.id = 0;
    }
    save() { }
}
PlatformHasRepository.objects = osm.models.PlatformHasRepositorySO.getObjects(PlatformHasRepository);
class Organization extends osm.models.OrganizationSO {
    constructor(args) {
        super();
        this.objects = Organization.objects;
        this.id = 0;
        this.avatarUrl = "";
        this.url = "";
        this.name = "";
        this.fullname = "";
        this.description = "";
        this.platformName = "";
        this.id = args["id"];
        this.avatarUrl = args["avatarUrl"];
        this.url = args["url"];
        this.name = args["name"];
        this.fullname = args["fullname"];
        this.description = args["description"];
        this.platformName = args["platformName"];
    }
    createMember(fields) {
        let member = Member.objects.create({
            avatarUrl: fields.avatarUrl,
            url: fields.url,
            fullname: fields.fullname,
            username: fields.username,
            platformId: fields.platformId,
        });
        if (member.success === false) {
            member = Member.objects.filter({
                url: fields.url,
            })[0];
        }
        OrganizationHasMember.objects.create({
            organizationId: this.id,
            memberId: member.id,
        });
        return member;
    }
    getMembers() {
        let members = OrganizationHasMember.objects.filter({
            organizationId: this.id,
        }, Member);
        return members;
    }
    getRepositories() {
        let filterStatement = Repository.statements.withOwner;
        let response = this.objects.filter({ owner: this.name }, Repository, filterStatement);
        return response;
    }
    save() { }
}
exports.Organization = Organization;
Organization.objects = osm.models.OrganizationSO.getObjects(Organization);
class OrganizationHasMember extends osm.models.OrganizationHasMemberSO {
    constructor() {
        super(...arguments);
        this.objects = OrganizationHasMember.objects;
        this.id = 0;
    }
    save() { }
}
OrganizationHasMember.objects = osm.models.OrganizationHasMemberSO.getObjects(OrganizationHasMember);
class PlatformHasOrganization extends osm.models.PlatformHasOrganizationSO {
    constructor() {
        super(...arguments);
        this.objects = PlatformHasOrganization.objects;
        this.id = 0;
    }
    save() { }
}
PlatformHasOrganization.objects = osm.models.PlatformHasOrganizationSO.getObjects(PlatformHasOrganization);
class Statistic extends osm.models.StatisticSO {
    constructor(args) {
        super();
        this.objects = Statistic.objects;
        this.id = 0;
        this.year = 0;
        this.totalIssueContributions = 0;
        this.totalCommitContributions = 0;
        this.totalRepositoryContributions = 0;
        this.totalPullRequestContributions = 0;
        this.totalPullRequestReviewContributions = 0;
        this.totalRepositoriesWithContributedIssues = 0;
        this.totalRepositoriesWithContributedCommits = 0;
        this.totalRepositoriesWithContributedPullRequests = 0;
        this.platformId = 0;
        this.id = args["id"];
        this.year = args["year"];
        this.totalIssueContributions = args["totalIssueContributions"];
        this.totalCommitContributions = args["totalCommitContributions"];
        this.totalRepositoryContributions = args["totalRepositoryContributions"];
        this.totalPullRequestContributions = args["totalPullRequestContributions"];
        this.totalPullRequestReviewContributions =
            args["totalPullRequestReviewContributions"];
        this.totalRepositoriesWithContributedIssues =
            args["totalRepositoriesWithContributedIssues"];
        this.totalRepositoriesWithContributedCommits =
            args["totalRepositoriesWithContributedCommits"];
        this.totalRepositoriesWithContributedPullRequests =
            args["totalRepositoriesWithContributedPullRequests"];
        this.platformId = args["platformId"];
    }
    createStreak(fields) {
        fields.statisticId = this.id;
        let streak = Streak.objects.create(fields);
        return streak;
    }
    getDates() {
        let from, to;
        if (this.year === 0) {
            from = moment_1.default().subtract(1, "years").day(0).format();
            to = moment_1.default().format();
        }
        else {
            from = moment_1.default().year(this.year).month(0).day(0).date(1).format();
            to = moment_1.default().year(this.year).month(11).day(31).format();
        }
        return {
            from,
            to,
        };
    }
    getStreaks() {
        if (this.year || this.year === 0) {
            let { from, to } = this.getDates();
            let response = Calendar.getDaysBetweenDate({
                from,
                to,
            });
            response = helper.statistic.calculateStreaks(response);
            response = response.map((entry) => {
                return new Streak(entry);
            });
            return response;
        }
        return [];
    }
    getStreakDetail(streaks) {
        let longest = streaks[0];
        let current = new Streak({
            id: -1,
            startDate: "-",
            endDate: "-",
            totalDays: 0,
            totalContributions: 0,
            statisticId: 0,
        });
        streaks.forEach((streak) => {
            if (streak.totalDays >= longest.totalDays) {
                longest = streak;
            }
            if (moment_1.default().diff(streak.endDate, "days") === 0) {
                current = streak;
            }
        });
        return {
            longest,
            current,
        };
    }
    getBusiestDay() {
        if (this.year || this.year === 0) {
            let { from, to } = this.getDates();
            let response = Calendar.getBusiestDay({
                from,
                to,
            });
            if (response) {
                return new Calendar(response);
            }
        }
        return new Calendar({
            id: -1,
            date: "",
            total: 0,
            platformId: -1,
        });
    }
    getContributions() {
        let response = Statistic.getContributions(this);
        return response;
    }
    static getMerged() {
        return super.getMerged(Statistic);
    }
    save() { }
}
exports.Statistic = Statistic;
Statistic.objects = osm.models.StatisticSO.getObjects(Statistic);
class Streak extends osm.models.StreakSO {
    constructor(args) {
        super();
        this.objects = Streak.objects;
        this.id = 0;
        this.startDate = "";
        this.endDate = "";
        this.totalDays = 0;
        this.totalContributions = 0;
        this.statisticId = 0;
        this.id = args["id"];
        this.startDate = args["startDate"];
        this.endDate = args["endDate"];
        this.totalDays = args["totalDays"];
        this.totalContributions = args["totalContributions"];
        this.statisticId = args["statisticId"];
    }
    save() { }
}
exports.Streak = Streak;
Streak.objects = osm.models.StreakSO.getObjects(Streak);
class Calendar extends osm.models.CalendarSO {
    constructor(args) {
        super();
        this.objects = Calendar.objects;
        this.id = 0;
        this.date = "";
        this.total = 0;
        this.platformId = 0;
        this.id = args["id"];
        this.date = args["date"];
        this.total = args["total"];
        this.platformId = args["platformId"];
    }
    createContribution(fields) {
        let contribution = Contribution.objects.create({
            repoUrl: fields.repoUrl,
            datetime: fields.datetime,
            nameWithOwner: fields.nameWithOwner,
            type: fields.type,
            calendarId: this.id,
        });
        return contribution;
    }
    save() { }
}
exports.Calendar = Calendar;
Calendar.objects = osm.models.CalendarSO.getObjects(Calendar);
class Contribution extends osm.models.ContributionSO {
    constructor(args) {
        super();
        this.objects = Contribution.objects;
        this.id = 0;
        this.repoUrl = "";
        this.datetime = "";
        this.nameWithOwner = "";
        this.type = "";
        this.calendarId = 0;
        this.id = args["id"];
        this.repoUrl = args["repoUrl"];
        this.datetime = args["datetime"];
        this.nameWithOwner = args["nameWithOwner"];
        this.type = args["type"];
        this.calendarId = args["calendarId"];
    }
    save() { }
}
exports.Contribution = Contribution;
Contribution.objects = osm.models.ContributionSO.getObjects(Contribution);
class Talk extends osm.models.TalkSO {
    constructor(args) {
        super();
        this.objects = Talk.objects;
        this.id = 0;
        this.name = "";
        this.url = "";
        this.displayUrl = "";
        this.downloadUrl = "";
        this.path = "";
        this.repositoryData = "";
        this.id = args["id"];
        this.name = args["name"];
        this.url = args["url"];
        this.displayUrl = args["displayUrl"];
        this.downloadUrl = args["downloadUrl"];
        this.path = args["path"];
        this.repositoryData = args["repositoryData"];
    }
    getRepository() {
        let repositoryData = {};
        try {
            repositoryData = JSON.parse(this.repositoryData);
            const repository = Repository.objects.filter({
                url: repositoryData.url,
            })[0];
            if (repository) {
                repository.owner = Member.objects.get({
                    id: repository.ownerId,
                });
                repository.owner.render([]);
                return repository;
            }
            else {
                let repository = new Repository(repositoryData);
                repository.owner = new Member(repositoryData.owner);
                return repository;
            }
        }
        catch (ex) {
            console.warn(ex +
                "De-serialization of repositoryData failed, " +
                "therefore an empty repository is provided!");
            return new Repository(repositoryData);
        }
    }
    save() { }
}
exports.Talk = Talk;
Talk.objects = osm.models.TalkSO.getObjects(Talk);
package/lib/reducer/database/osm/models.js000644 0000021504 3560116604 015644 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TalkSO = exports.ContributionSO = exports.CalendarSO = exports.StreakSO = exports.StatisticSO = exports.PlatformHasOrganizationSO = exports.OrganizationHasMemberSO = exports.OrganizationSO = exports.PlatformHasRepositorySO = exports.LanguageSO = exports.RepositoryHasMemberSO = exports.RepositorySO = exports.MemberSO = exports.PlatformSO = exports.BaseSO = void 0;
const moment_1 = __importDefault(require("moment"));
const reconstructor_1 = require("./reconstructor");
const platform = __importStar(require("./statements/platform"));
const member = __importStar(require("./statements/member"));
const repository = __importStar(require("./statements/repository"));
const repositoryHasMember = __importStar(require("./statements/repositoryHasMember"));
const platformHasRepository = __importStar(require("./statements/platformHasRepository"));
const language = __importStar(require("./statements/language"));
const organization = __importStar(require("./statements/organization"));
const organizationHasMember = __importStar(require("./statements/organizationHasMember"));
const platformHasOrganization = __importStar(require("./statements/platformHasOrganization"));
const statistic = __importStar(require("./statements/statistic"));
const streak = __importStar(require("./statements/streak"));
const calendar = __importStar(require("./statements/calendar"));
const contribution = __importStar(require("./statements/contribution"));
const talk = __importStar(require("./statements/talk"));
const helper = __importStar(require("../helper"));
class BaseSO {
    static getObjects(self) {
        return new reconstructor_1.SOAssembler(self);
    }
    render(filter, excludes = ["objects"]) {
        return helper.general.squeezer(this, filter, excludes);
    }
}
exports.BaseSO = BaseSO;
class PlatformSO extends BaseSO {
    static getLowestCreatedAtYear() {
        return reconstructor_1.SOAssembler.database.exec(PlatformSO.statements.lowestCreatedAtYear)[0];
    }
    static getSourceTypes() {
        return reconstructor_1.SOAssembler.database.exec(PlatformSO.statements.getSourceTypes);
    }
    tableName() {
        return "platform";
    }
}
exports.PlatformSO = PlatformSO;
PlatformSO.statements = platform;
class MemberSO extends BaseSO {
    tableName() {
        return "member";
    }
}
exports.MemberSO = MemberSO;
MemberSO.statements = member;
class RepositorySO extends BaseSO {
    static getLanguages() {
        return reconstructor_1.SOAssembler.database.exec(LanguageSO.statements.merged);
    }
    tableName() {
        return "repository";
    }
}
exports.RepositorySO = RepositorySO;
RepositorySO.statements = repository;
class RepositoryHasMemberSO extends BaseSO {
    tableName() {
        return "repositoryhasmember";
    }
}
exports.RepositoryHasMemberSO = RepositoryHasMemberSO;
RepositoryHasMemberSO.statements = repositoryHasMember;
class LanguageSO extends BaseSO {
    tableName() {
        return "language";
    }
}
exports.LanguageSO = LanguageSO;
LanguageSO.statements = language;
class PlatformHasRepositorySO extends BaseSO {
    tableName() {
        return "platformhasrepository";
    }
}
exports.PlatformHasRepositorySO = PlatformHasRepositorySO;
PlatformHasRepositorySO.statements = platformHasRepository;
class OrganizationSO extends BaseSO {
    tableName() {
        return "organization";
    }
}
exports.OrganizationSO = OrganizationSO;
OrganizationSO.statements = organization;
class OrganizationHasMemberSO extends BaseSO {
    tableName() {
        return "organizationhasmember";
    }
}
exports.OrganizationHasMemberSO = OrganizationHasMemberSO;
OrganizationHasMemberSO.statements = organizationHasMember;
class PlatformHasOrganizationSO extends BaseSO {
    tableName() {
        return "platformhasorganization";
    }
}
exports.PlatformHasOrganizationSO = PlatformHasOrganizationSO;
PlatformHasOrganizationSO.statements = platformHasOrganization;
class StatisticSO extends BaseSO {
    static getMerged(cls) {
        let response = reconstructor_1.SOAssembler.database.exec(StatisticSO.statements.allMerged);
        response = response.map((entry) => {
            return new cls(entry);
        });
        return response;
    }
    static getContributions(self) {
        let response = null;
        if (!self.id) {
            response = {
                commit: reconstructor_1.SOAssembler.database.exec(StatisticSO.statements.commitContributionsOfYear, [self.year])[0],
                issue: reconstructor_1.SOAssembler.database.exec(StatisticSO.statements.issueContributionsOfYear, [self.year])[0],
                pullRequest: reconstructor_1.SOAssembler.database.exec(StatisticSO.statements.pullRequestContributionsOfYear, [self.year])[0],
                pullRequestReview: reconstructor_1.SOAssembler.database.exec(StatisticSO.statements.pullRequestReviewContributionsOfYear, [self.year])[0],
                total: 0,
            };
            response.total =
                response.commit.total +
                    response.issue.total +
                    response.pullRequest.total +
                    response.pullRequestReview.total;
        }
        if (response) {
            return response;
        }
        const defaultShare = {
            total: 0,
            size: 0,
        };
        return {
            commit: defaultShare,
            issue: defaultShare,
            pullRequest: defaultShare,
            pullRequestReview: defaultShare,
            total: 0,
        };
    }
    tableName() {
        return "statistic";
    }
}
exports.StatisticSO = StatisticSO;
StatisticSO.statements = statistic;
class StreakSO extends BaseSO {
    tableName() {
        return "streak";
    }
}
exports.StreakSO = StreakSO;
StreakSO.statements = streak;
class CalendarSO extends BaseSO {
    static getDaysBetweenDate(dates) {
        let days = reconstructor_1.SOAssembler.database.exec(CalendarSO.statements.betweenDate, [
            dates.from,
            dates.to,
        ]);
        return days;
    }
    static getBusiestDay(dates) {
        let response = reconstructor_1.SOAssembler.database.exec(CalendarSO.statements.busiestDayBetweenDate(moment_1.default(dates.from).format("YYYY-MM-DD"), moment_1.default(dates.to).format("YYYY-MM-DD")))[0];
        return response;
    }
    static getCalendar(dates) {
        let calendar = helper.calendar.generateCalendarStructure(dates.from, dates.to);
        calendar.weeks.forEach((week) => {
            week.days.forEach((day) => {
                let entries = reconstructor_1.SOAssembler.database.exec(CalendarSO.statements.dayByDate, [day.date]);
                let total = 0;
                if (entries.length > 0) {
                    let selectedDay = entries[0];
                    total = selectedDay.total;
                }
                day.total = total;
            });
        });
        try {
            let busiestDayTotal = 0;
            let busiestDay = CalendarSO.getBusiestDay(dates);
            if (busiestDay) {
                busiestDayTotal = busiestDay.total;
            }
            helper.calendar.fillCalendarWithColors(calendar, busiestDayTotal);
            return {
                success: true,
                data: calendar,
            };
        }
        catch (err) {
            return {
                success: false,
                data: helper.calendar.generateCalendarStructure(dates.from, dates.to),
                message: "Check for data in the calendar table.",
            };
        }
    }
    tableName() {
        return "calendar";
    }
}
exports.CalendarSO = CalendarSO;
CalendarSO.statements = calendar;
class ContributionSO extends BaseSO {
    tableName() {
        return "contribution";
    }
}
exports.ContributionSO = ContributionSO;
ContributionSO.statements = contribution;
class TalkSO extends BaseSO {
    tableName() {
        return "talk";
    }
}
exports.TalkSO = TalkSO;
TalkSO.statements = talk;
package/lib/reducer/database/osm/statements/organization.js000644 0000002373 3560116604 021257 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS organization;

CREATE TABLE IF NOT EXISTS organization
  (
     id          INT NOT NULL auto_increment,
     avatarUrl   VARCHAR(2048) NOT NULL,
     url         VARCHAR(2048) NOT NULL,
     name        VARCHAR(80) NOT NULL,
     fullname    VARCHAR(80) NOT NULL,
     description VARCHAR(255),
     UNIQUE(url),
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO organization
            (avatarUrl,
             url,
             name,
             fullname,
             description)
VALUES      (?,
             ?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   organization
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT id,
       avatarUrl,
       url,
       name,
       fullname,
       description,
       (SELECT p.platformName
        FROM   platformhasorganization pho
               INNER JOIN platform p
                       ON pho.platformId = p.id
        WHERE  pho.organizationId = o.id) AS platformName
FROM   organization o
`;
exports.all = all;
package/lib/reducer/database/osm/statements/organizationHasMember.js000644 0000001472 3560116604 023042 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS organizationhasmember;

CREATE TABLE IF NOT EXISTS organizationhasmember
  (
     id             INT NOT NULL auto_increment,
     organizationId INT NOT NULL REFERENCES organization (id),
     memberId       INT NOT NULL REFERENCES member (id),
     UNIQUE(id),
     PRIMARY KEY (organizationId, memberId)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO organizationhasmember
            (organizationId,
             memberId)
VALUES      (?,
             ?);
`;
exports.create = create;
const all = `
SELECT *
FROM   organizationhasmember
       INNER JOIN member m
               ON memberId = m.id
`;
exports.all = all;
package/lib/utils/gitlab/paths.js000644 0000001437 3560116604 014112 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.projects = exports.groups = exports.atom = exports.activity = exports.currentCalendar = exports.home = void 0;
const root = "/";
const home = (username) => root + username;
exports.home = home;
const currentCalendar = (username) => root + "users/" + username + "/calendar";
exports.currentCalendar = currentCalendar;
const activity = (username) => root + username + "?limit=2147483647";
exports.activity = activity;
const atom = (username) => root + username + ".atom?limit=2147483647";
exports.atom = atom;
const groups = (username) => root + "users/" + username + "/groups.json";
exports.groups = groups;
const projects = (username) => root + "users/" + username + "/projects.json";
exports.projects = projects;
package/lib/utils/talks/paths.js000644 0000000632 3560116604 013762 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.organization = exports.user = void 0;
const user = (username, page) => `/search/code?q=user:${username} in:file extension:pdf&page=${page}`;
exports.user = user;
const organization = (organizationName, page) => `/search/code?q=org:${organizationName} in:file extension:pdf&page=${page}`;
exports.organization = organization;
package/lib/reducer/database/osm/statements/platform.js000644 0000003610 3560116604 020372 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSourceTypes = exports.lowestCreatedAtYear = exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS platform;

CREATE TABLE IF NOT EXISTS platform
  (
     id              INT NOT NULL auto_increment,
     platformName    VARCHAR(80) NOT NULL,
     platformUrl     VARCHAR(2048) NOT NULL,
     avatarUrl       VARCHAR(2048) NOT NULL,
     websiteUrl      VARCHAR(2048) NOT NULL,
     company         VARCHAR(80) NOT NULL,
     email           VARCHAR(80) NOT NULL,
     username        VARCHAR(80) NOT NULL,
     fullname        VARCHAR(80) NOT NULL,
     createdAt       DATE NOT NULL,
     location        VARCHAR(80) NULL,
     statusMessage   VARCHAR(80) NULL,
     statusEmojiHTML VARCHAR(80) NULL,
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO platform
            (platformName,
             platformUrl,
             avatarUrl,
             websiteUrl,
             company,
             email,
             username,
             fullname,
             createdAt,
             location,
             statusMessage,
             statusEmojiHTML)
VALUES      (?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   platform
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   platform
`;
exports.all = all;
const lowestCreatedAtYear = `
SELECT Year(Min(createdAt)) AS createdAt
FROM   platform
`;
exports.lowestCreatedAtYear = lowestCreatedAtYear;
const getSourceTypes = `
SELECT platformName        AS source,
       Count(platformName) AS total
FROM   platform
GROUP  BY platformName
`;
exports.getSourceTypes = getSourceTypes;
package/lib/reducer/database/osm/statements/platformHasOrganization.js000644 0000001524 3560116604 023415 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS platformhasorganization;

CREATE TABLE IF NOT EXISTS platformhasorganization
  (
     id             INT NOT NULL auto_increment,
     platformId     INT NOT NULL REFERENCES platform (id),
     organizationId INT NOT NULL REFERENCES organization (id),
     UNIQUE(id),
     PRIMARY KEY (platformId, organizationId)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO platformhasorganization
            (platformId,
             organizationId)
VALUES      (?,
             ?);
`;
exports.create = create;
const all = `
SELECT *
FROM   platformhasorganization
       INNER JOIN organization o
               ON organizationId = o.id
`;
exports.all = all;
package/lib/reducer/database/osm/statements/platformHasRepository.js000644 0000001474 3560116604 023134 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS platformhasrepository;

CREATE TABLE IF NOT EXISTS platformhasrepository
  (
     id           INT NOT NULL auto_increment,
     platformId   INT NOT NULL REFERENCES platform (id),
     repositoryId INT NOT NULL REFERENCES repository (id),
     UNIQUE(id),
     PRIMARY KEY (platformId, repositoryId)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO platformhasrepository
            (platformId,
             repositoryId)
VALUES      (?,
             ?);
`;
exports.create = create;
const all = `
SELECT *
FROM   platformhasrepository
       INNER JOIN repository r
               ON repositoryId = r.id
`;
exports.all = all;
package/lib/reducer/helper/profile.js000644 0000005767 3560116604 014753 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergedProfile = void 0;
const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
const models = __importStar(require("../database/models"));
const Delay_1 = __importDefault(require("../../toolbox/Delay"));
async function mergedProfile() {
    let platform = models.Platform.objects.get({ id: 1 });
    let repositories = models.Repository.objects.all();
    let organizations = models.Organization.objects.all();
    platform.sources = models.Platform.getSourceTypes();
    platform.repositories = repositories.map((repository) => {
        repository.owner = models.Member.objects.get({
            id: repository.ownerId,
        }).render([]);
        repository.members = repository.getMembers().map((member) => {
            return member.render([]);
        });
        repository.languages = repository.getLanguages().map((language) => {
            return language.render([]);
        });
        return repository.render([]);
    });
    await Delay_1.default(1000);
    platform.organizations = organizations.map((organization) => {
        organization.members = organization.getMembers().map((member) => {
            return member.render([]);
        });
        let repositories = organization.getRepositories();
        const owner = lodash_clonedeep_1.default(organization).render(["avatarUrl", "url", "fullname", "name"], ["repositories", "objects"]);
        organization.repositories = repositories.map((repository) => {
            repository.owner = owner;
            repository.members = repository.getMembers().map((member) => {
                return member.render([]);
            });
            repository.languages = repository.getLanguages().map((language) => {
                return language.render([]);
            });
            return repository.render([]);
        });
        return organization.render([]);
    });
    await Delay_1.default(1000);
    platform.render([]);
    return platform;
}
exports.mergedProfile = mergedProfile;
package/lib/reducer/database/osm/reconstructor.js000644 0000010230 3560116604 017267 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SOAssembler = void 0;
let alasql = require("alasql");
class SOAssembler {
    constructor(Base) {
        this.Base = Base;
        if (Base.statements.initialize) {
            SOAssembler.database.exec(Base.statements.initialize);
        }
        else {
        }
    }
    create(fields) {
        try {
            let tablename = new this.Base({}).tableName();
            SOAssembler.database.exec(this.Base.statements.create, Object.values(fields));
            fields.id = SOAssembler.database.autoval(tablename, "id");
            let obj = new this.Base(fields);
            return obj;
        }
        catch (err) {
            return {
                success: false,
                message: err.message,
            };
        }
    }
    get(fields) {
        try {
            let response = SOAssembler.database.exec(this.Base.statements.get, Object.values(fields));
            if (response.length === 1) {
                response = response[0];
            }
            let obj = new this.Base(response);
            return obj;
        }
        catch (err) {
            return {
                success: false,
                message: err.message,
            };
        }
    }
    all() {
        try {
            let response;
            response = SOAssembler.database.exec(this.Base.statements.all);
            response = response.map((entry) => {
                return new this.Base(entry);
            });
            return response;
        }
        catch (err) {
            console.error("OSM reconstructor .all()", err);
            return {
                success: false,
                message: err.message,
            };
        }
    }
    filter(filter, Cls, filterStatement) {
        try {
            if (!filterStatement) {
                filterStatement = this.Base.statements.all;
            }
            let response = SOAssembler.database.exec(filterStatement);
            for (let entry in response) {
                if ({}.hasOwnProperty.call(response, entry)) {
                    for (let f in filter) {
                        if ({}.hasOwnProperty.call(filter, f)) {
                            let eProxy = new Proxy({ entry }, {
                                get: () => {
                                    return entry;
                                },
                            });
                            let fProxy = new Proxy({ f }, {
                                get: () => {
                                    return f;
                                },
                            });
                            if (response[eProxy.entry]) {
                                if (filter[fProxy.f] !== response[eProxy.entry][fProxy.f]) {
                                    delete response[eProxy.entry];
                                }
                            }
                        }
                    }
                }
            }
            let filtered = response.filter((el) => {
                return el !== null;
            });
            let objects = filtered.map((entry) => {
                let o;
                if (Cls) {
                    o = new Cls(entry);
                }
                else {
                    o = new this.Base(entry);
                }
                return o;
            });
            return objects;
        }
        catch (err) {
            console.error("OSM reconstructor .filer()", err);
            return {
                success: false,
                response: null,
                message: err.message,
            };
        }
    }
    custom(query) {
        try {
            let response = SOAssembler.database.exec(query);
            response = response.map((entry) => {
                return new this.Base(entry);
            });
            return response;
        }
        catch (err) {
            return {
                success: false,
                message: err.message,
            };
        }
    }
    reload() {
        SOAssembler.database = new alasql.Database();
    }
}
exports.SOAssembler = SOAssembler;
SOAssembler.database = new alasql.Database();
package/lib/reducer/database/osm/statements/repository.js000644 0000002250 3560116604 020764 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.withOwner = exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS repository;

CREATE TABLE IF NOT EXISTS repository
  (
     id        INT NOT NULL auto_increment,
     avatarUrl VARCHAR(2048) NOT NULL,
     url       VARCHAR(2048) NOT NULL,
     name      VARCHAR(80) NOT NULL,
     ownerId   INT NULL REFERENCES member (id),
     UNIQUE(url),
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO repository
            (avatarUrl,
             url,
             name,
             ownerId)
VALUES      (?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   repository
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   repository r
`;
exports.all = all;
const withOwner = `
SELECT r.id        AS id,
       r.avatarUrl AS avatarUrl,
       r.url       AS url,
       r.name      AS name,
       m.username  AS owner
FROM   repository r
       INNER JOIN member m
               ON r.ownerId = m.id
`;
exports.withOwner = withOwner;
package/lib/reducer/database/osm/statements/repositoryHasMember.js000644 0000001446 3560116604 022556 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS repositoryhasmember;

CREATE TABLE IF NOT EXISTS repositoryhasmember
  (
     id           INT NOT NULL auto_increment,
     repositoryId INT NOT NULL REFERENCES repository (id),
     memberId     INT NOT NULL REFERENCES member (id),
     UNIQUE(id),
     PRIMARY KEY (repositoryId, memberId)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO repositoryhasmember
            (repositoryId,
             memberId)
VALUES      (?,
             ?);
`;
exports.create = create;
const all = `
SELECT *
FROM   repositoryhasmember
       INNER JOIN member m
               ON memberId = m.id
`;
exports.all = all;
package/lib/reducer/database/helper/statistic.js000644 0000003634 3560116604 017055 0ustar00000000 000000 "use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.calculateStreaks = void 0;
const moment_1 = __importDefault(require("moment"));
function calculateStreaks(values) {
    const streaks = [];
    let streak = undefined;
    const checkContinuation = (day1, day2) => {
        try {
            const dayDiff = moment_1.default(day2.date).diff(moment_1.default(day1.date), "days");
            if (dayDiff > 1) {
                return false;
            }
            return true;
        }
        catch {
            return undefined;
        }
    };
    const handleStreak = (day, isLastDay = false) => {
        if (streak) {
            if (!isLastDay) {
                streak.totalDays++;
            }
            streak.totalContributions += day.total;
        }
        else {
            streak = {
                totalContributions: day.total,
                totalDays: 0,
                startDate: moment_1.default(day.date).format("YYYY-MM-DD"),
            };
        }
    };
    const pushStreak = (lastDay) => {
        if (streak) {
            if (streak.totalDays > 0) {
                streak.endDate = moment_1.default(lastDay.date).format("YYYY-MM-DD");
                streaks.push(streak);
            }
            streak = undefined;
        }
    };
    for (let index = 0; index < values.length; index++) {
        const day = values[index];
        const nextDay = values[index + 1];
        const status = checkContinuation(day, nextDay);
        if (status) {
            handleStreak(day);
        }
        else if (status === undefined) {
            handleStreak(day);
            pushStreak(day);
        }
        else {
            pushStreak(day);
        }
    }
    return streaks;
}
exports.calculateStreaks = calculateStreaks;
package/lib/reducer/database/osm/statements/statistic.js000644 0000010047 3560116604 020557 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.pullRequestReviewContributionsOfYear = exports.pullRequestContributionsOfYear = exports.issueContributionsOfYear = exports.commitContributionsOfYear = exports.allMerged = exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS statistic;

CREATE TABLE IF NOT EXISTS statistic
  (
     id                                           INT NOT NULL auto_increment,
     year                                         INT NOT NULL,
     totalIssueContributions                      INT NOT NULL,
     totalCommitContributions                     INT NOT NULL,
     totalRepositoryContributions                 INT NOT NULL,
     totalPullRequestContributions                INT NOT NULL,
     totalPullRequestReviewContributions          INT NOT NULL,
     totalRepositoriesWithContributedIssues       INT NOT NULL,
     totalRepositoriesWithContributedCommits      INT NOT NULL,
     totalRepositoriesWithContributedPullRequests INT NOT NULL,
     platformId                                   INT NOT NULL REFERENCES
     platform (id),
     UNIQUE(year, platformId),
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO statistic
            (year,
             totalIssueContributions,
             totalCommitContributions,
             totalRepositoryContributions,
             totalPullRequestContributions,
             totalPullRequestReviewContributions,
             totalRepositoriesWithContributedIssues,
             totalRepositoriesWithContributedCommits,
             totalRepositoriesWithContributedPullRequests,
             platformId)
VALUES      (?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   statistic
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   statistic
`;
exports.all = all;
const allMerged = `
SELECT year,
       Sum(totalIssueContributions)                      AS
       totalIssueContributions,
       Sum(totalCommitContributions)                     AS
       totalCommitContributions,
       Sum(totalRepositoryContributions)                 AS
       totalRepositoryContributions,
       Sum(totalPullRequestContributions)                AS
       totalPullRequestContributions,
       Sum(totalPullRequestReviewContributions)          AS
       totalPullRequestReviewContributions,
       Sum(totalRepositoriesWithContributedIssues)       AS
       totalRepositoriesWithContributedIssues,
       Sum(totalRepositoriesWithContributedCommits)      AS
       totalRepositoriesWithContributedCommits,
       Sum(totalRepositoriesWithContributedPullRequests) AS
       totalRepositoriesWithContributedPullRequests
FROM   statistic
GROUP  BY year
ORDER  BY year
`;
exports.allMerged = allMerged;
const contributionSumFragment = `
  Sum(totalCommitContributions)
  + Sum(totalIssueContributions)
  + Sum(totalPullRequestContributions)
  + Sum(totalPullRequestReviewContributions)
`;
const contributionOfYearFragment = (type) => `
SELECT   Sum(${type})                                                AS total,
         round(Sum(${type}) / (${contributionSumFragment}) * 100, 2) AS share
FROM     statistic
WHERE    year = ?
GROUP BY year
`;
const commitContributionsOfYear = `
  ${contributionOfYearFragment("totalCommitContributions")}
`;
exports.commitContributionsOfYear = commitContributionsOfYear;
const issueContributionsOfYear = `
  ${contributionOfYearFragment("totalIssueContributions")}
`;
exports.issueContributionsOfYear = issueContributionsOfYear;
const pullRequestContributionsOfYear = `
  ${contributionOfYearFragment("totalPullRequestContributions")}
`;
exports.pullRequestContributionsOfYear = pullRequestContributionsOfYear;
const pullRequestReviewContributionsOfYear = `
  ${contributionOfYearFragment("totalPullRequestReviewContributions")}
`;
exports.pullRequestReviewContributionsOfYear = pullRequestReviewContributionsOfYear;
package/lib/reducer/helper/statistic.js000644 0000004746 3560116604 015316 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergedStatistic = void 0;
const models = __importStar(require("../database/models"));
const helper = __importStar(require("./index"));
const Delay_1 = __importDefault(require("../../toolbox/Delay"));
async function mergedStatistic() {
    let statistic = models.Statistic.getMerged();
    let currentYear = null;
    let yearsList = [];
    let calendar = helper.calendar.mergedCalendar();
    for (const index in statistic) {
        await Delay_1.default(300);
        let entry = statistic[index];
        let streaks = entry.getStreaks().map((streak) => {
            return streak.render([]);
        });
        let { longest, current } = entry.getStreakDetail(streaks);
        entry.streak = {
            longest,
            current,
            streaks,
        };
        entry.contributions = entry.getContributions();
        entry.busiestDay = entry.getBusiestDay();
        if (entry.busiestDay) {
            entry.busiestDay = entry.busiestDay.render([]);
        }
        entry.render([]);
        if (entry.year === 0) {
            entry.calendar = calendar.current;
            currentYear = entry;
        }
        else {
            entry.calendar = calendar.years[yearsList.length];
            yearsList.push(entry);
        }
    }
    await Delay_1.default(2500);
    const languages = helper.language.mergedLanguage();
    return { current: currentYear, years: yearsList, languages };
}
exports.mergedStatistic = mergedStatistic;
package/lib/reducer/database/osm/statements/streak.js000644 0000001511 3560116604 020035 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS streak;

CREATE TABLE IF NOT EXISTS streak
  (
     id          INT NOT NULL auto_increment,
     startDate   DATE NULL,
     endDate     DATE NULL,
     total       INT NULL,
     statisticId INT NOT NULL REFERENCES statistic(id),
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO streak
            (startDate,
             endDate,
             total,
             statisticId)
VALUES      (?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   streak
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   streak
`;
exports.all = all;
package/lib/reducer/database/osm/statements/talk.js000644 0000002000 3560116604 017471 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.all = exports.get = exports.create = exports.initialize = void 0;
const initialize = `
DROP TABLE IF EXISTS talk;

CREATE TABLE IF NOT EXISTS talk
  (
     id             INT NOT NULL auto_increment,
     name           VARCHAR(80) NOT NULL,
     url            VARCHAR(2024) NOT NULL,
     displayUrl     VARCHAR(2024) NOT NULL,
     downloadUrl    VARCHAR(2024) NOT NULL,
     path           VARCHAR(2024) NOT NULL,
     repositoryData TEXT NOT NULL,
     PRIMARY KEY (id)
  );
`;
exports.initialize = initialize;
const create = `
INSERT INTO talk
            (name,
             url,
             displayUrl,
             downloadUrl,
             path,
             repositoryData)
VALUES      (?,
             ?,
             ?,
             ?,
             ?,
             ?);
`;
exports.create = create;
const get = `
SELECT *
FROM   talk
WHERE  id = ?
`;
exports.get = get;
const all = `
SELECT *
FROM   talk
`;
exports.all = all;
package/lib/reducer/helper/talks.js000644 0000001372 3560116604 014415 0ustar00000000 000000 "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergedTalks = void 0;
const models_1 = require("../database/models");
function randomUid(length) {
    let result = "";
    let characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    for (let index = 0; index < length; index++) {
        result += characters.charAt(Math.floor(Math.random() * characters.length));
    }
    return result;
}
function mergedTalks() {
    let talks = models_1.Talk.objects.all();
    talks.map((talk) => {
        talk.repository = talk.getRepository().render([]);
        talk.uid = randomUid(11);
        talk.render([], ["repositoryData", "objects"]);
    });
    return talks;
}
exports.mergedTalks = mergedTalks;
package/lib/utils/enterprise/tools.js000644 0000010465 3560116604 015052 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergeContributionFeed = exports.mergeCodetransition = void 0;
const moment_1 = __importDefault(require("moment"));
const reducer_1 = require("../../reducer");
const models = __importStar(require("../../reducer/database/models"));
const helper = __importStar(require("../../reducer/helper/calendar"));
const mergeCodetransition = (arr) => {
    const reducer = new reducer_1.Reducer();
    arr.sort((a, b) => (moment_1.default(a.datetime) > moment_1.default(b.datetime) ? 1 : -1));
    if (arr.length > 0) {
        const platform = models.Platform.objects.create({
            platformName: moment_1.default().toString(),
            platformUrl: "ops.local",
            avatarUrl: "",
            websiteUrl: "",
            company: null,
            email: null,
            username: "",
            fullName: "",
            createdAt: arr[0].datetime,
            location: null,
            statusMessage: "",
            statusEmojiHTML: "",
        });
        const days = [];
        arr.reduce(function (res, value) {
            const date = value.datetime.split(" ")[0];
            if (!res[date]) {
                res[date] = {
                    date: date,
                    total: 0,
                };
                days.push(res[date]);
            }
            try {
                res[value.datetime.split(" ")[0]].total +=
                    parseInt(value.insertions) - parseInt(value.deletions);
            }
            catch { }
            return res;
        }, {});
        for (let date in days) {
            platform.createCalendarEntry({
                date: days[date].date,
                total: days[date].total,
            });
        }
        const calendar = helper.mergedCalendar();
        reducer.reset();
        return calendar;
    }
};
exports.mergeCodetransition = mergeCodetransition;
const mergeContributionFeed = (arr) => {
    const reducer = new reducer_1.Reducer();
    arr.sort((a, b) => (moment_1.default(a.datetime) > moment_1.default(b.datetime) ? 1 : -1));
    if (arr.length > 0) {
        const platform = models.Platform.objects.create({
            platformName: moment_1.default().toString(),
            platformUrl: "ops.local",
            avatarUrl: "",
            websiteUrl: "",
            company: null,
            email: null,
            username: "",
            fullName: "",
            createdAt: arr[0].datetime,
            location: null,
            statusMessage: "",
            statusEmojiHTML: "",
        });
        const days = [];
        arr.reduce(function (res, value) {
            const date = value.datetime.split(" ")[0];
            if (!res[date]) {
                res[date] = {
                    date: date,
                    total: 0,
                };
                days.push(res[date]);
            }
            try {
                res[value.datetime.split(" ")[0]].total += 1;
            }
            catch { }
            return res;
        }, {});
        for (let date in days) {
            platform.createCalendarEntry({
                date: days[date].date,
                total: days[date].total,
            });
        }
        const calendar = helper.mergedCalendar();
        reducer.reset();
        return calendar;
    }
};
exports.mergeContributionFeed = mergeContributionFeed;
package/lib/utils/ops/tools.js000644 0000010465 3560116604 013473 0ustar00000000 000000 "use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergeContributionFeed = exports.mergeCodetransition = void 0;
const moment_1 = __importDefault(require("moment"));
const reducer_1 = require("../../reducer");
const models = __importStar(require("../../reducer/database/models"));
const helper = __importStar(require("../../reducer/helper/calendar"));
const mergeCodetransition = (arr) => {
    const reducer = new reducer_1.Reducer();
    arr.sort((a, b) => (moment_1.default(a.datetime) > moment_1.default(b.datetime) ? 1 : -1));
    if (arr.length > 0) {
        const platform = models.Platform.objects.create({
            platformName: moment_1.default().toString(),
            platformUrl: "ops.local",
            avatarUrl: "",
            websiteUrl: "",
            company: null,
            email: null,
            username: "",
            fullName: "",
            createdAt: arr[0].datetime,
            location: null,
            statusMessage: "",
            statusEmojiHTML: "",
        });
        const days = [];
        arr.reduce(function (res, value) {
            const date = value.datetime.split(" ")[0];
            if (!res[date]) {
                res[date] = {
                    date: date,
                    total: 0,
                };
                days.push(res[date]);
            }
            try {
                res[value.datetime.split(" ")[0]].total +=
                    parseInt(value.insertions) - parseInt(value.deletions);
            }
            catch { }
            return res;
        }, {});
        for (let date in days) {
            platform.createCalendarEntry({
                date: days[date].date,
                total: days[date].total,
            });
        }
        const calendar = helper.mergedCalendar();
        reducer.reset();
        return calendar;
    }
};
exports.mergeCodetransition = mergeCodetransition;
const mergeContributionFeed = (arr) => {
    const reducer = new reducer_1.Reducer();
    arr.sort((a, b) => (moment_1.default(a.datetime) > moment_1.default(b.datetime) ? 1 : -1));
    if (arr.length > 0) {
        const platform = models.Platform.objects.create({
            platformName: moment_1.default().toString(),
            platformUrl: "ops.local",
            avatarUrl: "",
            websiteUrl: "",
            company: null,
            email: null,
            username: "",
            fullName: "",
            createdAt: arr[0].datetime,
            location: null,
            statusMessage: "",
            statusEmojiHTML: "",
        });
        const days = [];
        arr.reduce(function (res, value) {
            const date = value.datetime.split(" ")[0];
            if (!res[date]) {
                res[date] = {
                    date: date,
                    total: 0,
                };
                days.push(res[date]);
            }
            try {
                res[value.datetime.split(" ")[0]].total += 1;
            }
            catch { }
            return res;
        }, {});
        for (let date in days) {
            platform.createCalendarEntry({
                date: days[date].date,
                total: days[date].total,
            });
        }
        const calendar = helper.mergedCalendar();
        reducer.reset();
        return calendar;
    }
};
exports.mergeContributionFeed = mergeContributionFeed;
package/lib/utils/oauth/config.json000644 0000002075 3560116604 014452 0ustar00000000 000000 {
    "providers": {
        "github": {
            "details": {
                "dev": {
                    "clientId": "1440dd4c1d1c4c0fa124",
                    "clientSecret": "0723a2b5bfef27efc8b2d26d837ead239fa0b0e6",
                    "redirectUrl": "http://localhost:3000/redirect",
                    "scope": "repo, user:email, read:user, read:org"
                },
                "deploy": {
                    "clientId": "2148629809594d57c113",
                    "clientSecret": "64a37e4846387cfcaea35d83afca3c9c8689628c",
                    "redirectUrl": "https://snek.at/redirect",
                    "scope": "repo, user:email, read:user, read:org"
                }
            },
            "urls": {
                "authorizeUrl": "https://github.com/login/oauth/authorize?redirect_uri=",
                "accessTokenUrl": "https://github.com/login/oauth/access_token?code=",
                "usernameUrl": "https://api.github.com/user"
            }
        }
    },
    "proxyUrl": "https://cors.snek.at/",
    "devUrl": "http://localhost:3000"
}
package/package.json000644 0000002241 3560116604 011545 0ustar00000000 000000 {
  "name": "snek-intel",
  "version": "0.1.2",
  "homepage": "http://snek.at",
  "license": "EUPL-1.2",
  "main": "lib/index.js",
  "types": "lib/index.d.ts",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/snek-at/intel.git"
  },
  "files": [
    "lib",
    "LICENSES"
  ],
  "scripts": {
    "start": "react-scripts start",
    "test": "react-scripts test --env=jsdom",
    "eject": "react-scripts eject",
    "predeploy": "yarn run build",
    "deploy": "gh-pages -d build",
    "build": "react-scripts build"
  },
  "browserslist": [
    ">0.2%",
    "not dead",
    "not ie <= 11",
    "not op_mini all"
  ],
  "description": "A not so tiny snek intel.",
  "bugs": {
    "url": "https://github.com/snek-at/intel/issues"
  },
  "author": "schettn",
  "dependencies": {
    "alasql": "^0.5.5",
    "apollo-boost": "^0.4.7",
    "gql": "^1.1.2",
    "graphql": "^14.6.0",
    "lodash.clonedeep": "^4.5.0",
    "moment": "^2.24.0",
    "react-scripts": "^3.4.1",
    "react-very-simple-oauth": "^1.1.1",
    "snek-client": "file:snek-client-0.2.0-rc.5.tgz"
  },
  "devDependencies": {
    "@types/lodash.clonedeep": "^4.5.6",
    "typescript": "^3.8.3"
  }
}
package/README.md000644 0000022204 3560116604 010537 0ustar00000000 000000 
<p align="center">
  <a href="https://snek.at/" target="_blank" rel="noopener noreferrer">
    <img src="https://avatars2.githubusercontent.com/u/55870326?s=400&u=c6c7f06305ddc94747d474850fde7b2044f53838&v=4" alt="SNEK Logo" height="150">
  </a>
</p>

<h3 align="center">SNEK - Social Network for Engineers and Knowledged</h3>
<p align="center">
The SNEK project is an attempt to create a transparent, open-source non-profit platform that allows engineers to categorize and compare. It should enable engineers from adjacent fields to visualize each other's skills through visualization and project identification.

  <br>
Intel serves as the :green_heart: of SNEK. Intel is the central data processing system for SNEK, providing interfaces to connect our other systems.
  <br>
  <br>
  <a href="https://github.com/snek-at/intel/issues/new?template=bug_report.md">Report bug</a>
  ·
  <a href="https://github.com/snek-at/intel/issues/new?template=feature_request.md">Request feature</a>
  ·
  <a href="https://www.overleaf.com/read/bcxwhwbhrmps">Documentation</a>
  <br>
  <br>
  <a href="https://www.codacy.com/app/kleberbaum/intel"></a>
</p>
 
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/b0224ced616347beb703d9330867b5d5)](https://app.codacy.com/gh/snek-at/intel?utm_source=github.com&utm_medium=referral&utm_content=snek-at/intel&utm_campaign=Badge_Grade_Dashboard)
## Table of contents

-   [Installation](#installation)
-   [Features](#features)
-   [Usage](#usage)
-   [Contributing](#contributing)
-   [Bugs and feature requests](#bugs-and-feature-requests)
-   [Versioning](#versioning)
-   [Creators](#creators)
-   [Thanks](#thanks)
-   [Copyright and license](#copyright-and-license)

## [](#installation)Installation
The system can be installed using the ```npm install``` command:
```bash
$ npm install snek-intel
```

## [](#features)Features
-   GitLab Querying
-   GitHub Querying
-   Statistics Generation
-   Interface with various GraphQL APIs
-   OAuth2-Authentication
-   Session Management

## [](#usage)Usage
### Source Object
```typescript
/* GitHub Source Object */
let source = {
  user: "schettn",
  platform: { name: "github", url: "https://api.github.com/graphql" },
  authorization: "token XXXXXXXXXXXXXXXX",
};

/* GitLab Source Object */
let source = {
  user: "schettn",
  platform: { name: "gitlab", url: "https://gitlab.com" },
};
```
### Append Source Object to Database
```typescript
await intel.append(source);
```
### Append List of Source Object to Database
```typescript
await intel.appendList([source1, source2]);
```
### Get Reduced Data from Database
```typescript
let data = intel.get();
```
### Reset Database
This will erase all data in the database.
```typescript
intel.resetReducer();
```
### Sessions
Session are completely handled by the Intel. 
```typescript
/* 
 * Starts the session for an anonymous user or maintains the session if
 * a user is logged in.
 */
await intel.snekclient.session.begin();

/*
 * Overrides an active session with a new session using the credential
 * pair.
 */
await intel.snekclient.session.begin({
  username: "schettn",
  password: "tschischkotschicko",
});

/* Ends the session */
await intel.snekclient.session.end();

```
### Tasks
All tasks are session aware! Every task has the capability of token handling. Modifying a token is not suggested.
```typescript
/** Authorization Tasks */
/* Login an anonymous user on the snek-engine */
let userData =
    await intel.snekclient.session.tasks.auth.anon();

/* Login a real user on the snek-engine */
let userData =
    await intel.snekclient.session.tasks.auth.nonanon();

/* Refresh the user tokens on the snek-engine */
let refreshState =
    await intel.snekclient.session.tasks.auth.refresh();

/* Revoke the user tokens on the snek-engine */
let revokeState =
    await intel.snekclient.session.tasks.auth.revoke();


/** General Tasks */
/* Get all profile pages from snek-engine */
let pagesData =
    await intel.snekclient.session.tasks.general.allPageUrls();

/* Get all GitLab servers from the snek-engine */
let gitlabServerData =
    await intel.snekclient.session.tasks.general.gitlabServer();

/** User Tasks */
/* Get all GitLab servers from the snek-engine */
let cachePageData =
    await intel.snekclient.session.tasks.user.cache();

/* Get the profile page data from the snek-engine */
let profilePageData =
    await intel.snekclient.session.tasks.user.profile();

/* Get the registration data from snek-engine */
let registrationData =
    await intel.snekclient.session.tasks.user.registration();

/* Get the whoami data from snek-engine */
let whoamiData =
    await intel.snekclient.session.tasks.user.whoami();
```

### OAuth2
#### Config File
The client ID, the client secret and the redirect URL are provided by an OAuth organization. To change this file, the repository has to be cloned in order to create a new config file manually.
```json
{
  "providers": {
    "github": {
      "details": {
        "dev": {
          "clientId": "1440dd4c1d1c4c0fa124",
          "clientSecret": "0723a2b5bfef27efc8b2d26d837ead239fa0b0e6",
          "redirectUrl": "http://localhost:3000/redirect",
          "scope": "repo, user:email, read:user, read:org"
        },
        "deploy": {
          "clientId": "b4337a9c1ad66984c060",
          "clientSecret": "1b05648d36ca92d63766e32e8e9a7d740b214816",
          "redirectUrl": "https://snek.at/redirect",
          "scope": "repo, user:email, read:user, read:org"
        }
      },
      "urls": {
        "authorizeUrl": "https://github.com/login/oauth/authorize?redirect_uri=",
        "accessTokenUrl": "https://github.com/login/oauth/access_token?code=",
        "usernameUrl": "https://api.github.com/user"
      }
    }
  },
  "proxyUrl": "https://cors.snek.at/",
  "devUrl": "http://localhost:3000"
}
```
<mark>Currently, a solution to adapt the config file more easily is under development.</mark>

#### Implementation
##### Redirect page
Put this script inside your redirect page to obtain the access token from the OAuth2 request. 
```javascript
/*
 * The redirect script:
 * Get name of window which was set by the parent to be the unique
 * request key
 */
const requestKey = window.name;

// Update corresponding entry with the redirected url which should
// either contain the access token or the reason for failure in the query
// parameter / hash
localStorage.setItem(requestKey, window.location.href);
window.close();
```
##### Requesting access token
```javascript
/* Import GithubProvider and the RSA */
import RSA, { GithubProvider } from "snek-intel/utils/oauth";

/* Gets the username and accessToken */
const openGitHubOAuth = () => {
    return await RSA.acquireTokenAsync(GithubProvider)
};

/* Example on how to call the GitHub OAuth function */
const { data } = openGitHubOAuth();

console.log(data.username, data.accessToken)
```
## [](#contributing)Contributing
![GitHub last commit](https://img.shields.io/github/last-commit/snek-at/intel) ![GitHub issues](https://img.shields.io/github/issues-raw/snek-at/intel) ![GitHub closed issues](https://img.shields.io/github/issues-closed-raw/snek-at/intel?color=green)

Please read through our [contributing guidelines](https://github.com/snek-at/front/blob/master/CONTRIBUTING.md). Included are directions for opening issues, coding standards, and notes on development.

All code should conform to the [Code Guide](https://github.com/snek-at/tonic/blob/master/STYLE_GUIDE.md), maintained by [SNEK](https://github.com/snek-at).

## [](#bug-and-feature-requests)Bugs and feature requests

Do you have a bug or a feature request? Please first search for existing and closed issues. If your problem or idea has not been addressed yet, [please open a new issue](https://github.com/snek-at/package-template/issues/new/choose).

## [](#versioning)Versioning
![GitHub package.json version](https://img.shields.io/github/package-json/v/snek-at/intel)

For reasons of transparency concering our release cycle and in striving to maintain backward compatibility, this repository is maintained under [the Semantic Versioning guidelines](https://semver.org/). Some minor screw ups aside, we try to adhere to those rules whenever possible.

## [](#creators)Creators
<table border="0">
	<tr>
		<td>
		<a href="https://github.com/schettn">
			<img src="https://avatars.githubusercontent.com/schettn?s=100" alt="Avatar schettn">
		</a>
		</td>
		<td>
			<a href="https://github.com/pinterid">
				<img src="https://avatars.githubusercontent.com/pinterid?s=100" alt="Avatar pinterid">
			</a>
		</td>	
		<td>
			<a href="https://github.com/kleberbaum">
				<img src="https://avatars.githubusercontent.com/kleberbaum?s=100" alt="Avatar kleberbaum">
			</a>
		</td>
	</tr>
	<tr>
		<td><a href="https://github.com/schettn">Nico Schett</a></td>
		<td><a href="https://github.com/pinterid">David Pinterics</a></td>
		<td><a href="https://github.com/kleberbaum">Florian Kleber</a></td>
	</tr>
</table>

## [](#thanks)Thanks
We do not have any external contributors yet, but if you want your name to be here, feel free to [contribute to our project](#contributing).

## [](#copyright-and-license)Copyright and license
![GitHub repository license](https://img.shields.io/badge/license-EUPL--1.2-blue)

SPDX-License-Identifier: (EUPL-1.2)
Copyright © 2019-2020 Simon Prast
package/lib/utils/upload/anonfiles.d.ts000644 0000000723 3560116604 015224 0ustar00000000 000000 interface ITalk {
    name: string;
    displayUrl: string | null;
    downloadUrl: string | null;
    html_url: string;
    path: string;
    repository: {
        name: string;
        full_name: string;
        html_url: string;
        owner: {
            avatar_url: string;
        };
    };
}
declare function getDownloadUrl(url: string): Promise<string | null>;
declare function uploadFile(file: Blob): Promise<ITalk>;
export { uploadFile, getDownloadUrl };
package/lib/reducer/database/helper/calendar.d.ts000644 0000001000 3560116604 017034 0ustar00000000 000000 import { Moment } from "moment";
interface ICalendar {
    startDate: Moment;
    endDate: Moment;
    weeks: IWeek[];
}
interface IWeek {
    days: IDay[];
}
interface IDay {
    date: string;
    color: string;
    total: number;
}
declare function generateCalendarStructure(startDate: string, endDate: string): ICalendar;
declare function fillCalendarWithColors(calendar: ICalendar, busiestDayTotal: number): ICalendar;
export type { ICalendar };
export { generateCalendarStructure, fillCalendarWithColors };
package/lib/reducer/database/osm/statements/calendar.d.ts000644 0000002035 3560116604 020553 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS calendar;\n\nCREATE TABLE IF NOT EXISTS calendar\n  ( \n     id         INT NOT NULL auto_increment,\n     date       DATE NOT NULL,\n     total      INT NOT NULL,\n     platformId INT NOT NULL REFERENCES platform (id),\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO calendar\n            (date,\n             total,\n             platformId)\nVALUES      (?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   calendar\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   calendar\nORDER BY date\n";
declare const betweenDate = "\nSELECT *\nFROM   calendar\nWHERE  date >= ?\n       AND date <= ?\nORDER BY date\n";
declare const busiestDayBetweenDate: (from: string, to: string) => string;
declare const dayByDate = "\nSELECT id, \n       Sum(total) AS total, \n       date, \n       platformId \nFROM   calendar \nWHERE  date = ? \nGROUP  BY date \n";
export { initialize, create, get, all, betweenDate, busiestDayBetweenDate, dayByDate, };
package/lib/reducer/helper/calendar.d.ts000644 0000000254 3560116604 015302 0ustar00000000 000000 import { ICalendar } from "../database/helper/calendar";
declare function mergedCalendar(): {
    current: ICalendar;
    years: ICalendar[];
};
export { mergedCalendar };
package/lib/reducer/database/osm/statements/contribution.d.ts000644 0000001526 3560116604 021525 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS contribution;\n\nCREATE TABLE IF NOT EXISTS contribution\n  (\n     id            INT NOT NULL auto_increment,\n     repoUrl       VARCHAR(2048) NOT NULL,\n     datetime      DATETIME NOT NULL,\n     nameWithOwner VARCHAR(80) NOT NULL,\n     type          VARCHAR(80) NOT NULL,\n     calendarId    INT NOT NULL REFERENCES calendar (id),\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO contribution\n            (repoUrl,\n             datetime,\n             nameWithOwner,\n             type,\n             calendarId)\nVALUES      (?,\n             ?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   contribution\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   contribution\n";
export { initialize, create, get, all };
package/lib/utils/enterprise/converter.d.ts000644 0000007472 3560116604 016161 0ustar00000000 000000 import { SnekSession } from "snek-client/lib/session/sessions";
export declare const getEnterprisePages: (session: SnekSession) => Promise<[] | undefined>;
export declare const getEnterprisePageGeneralContent: (session: SnekSession, queryArgs: {
    slug: string;
}) => Promise<any>;
export declare const updateEnterprisePageGeneralContent: (session: SnekSession, queryArgs: {
    slug: string;
    imprint: {
        city?: string;
        zip_code?: string;
        address?: string;
        telephone?: string;
        telefax?: string;
        vat_number?: string;
        whatsapp_telephone?: string;
        whatsapp_contactline?: string;
        tax_id?: string;
        trade_register_number?: string;
        court_of_registry?: string;
        place_of_registry?: string;
        ownership?: string;
        email?: string;
        employee_count?: string;
        opensource_url?: string;
        recruiting_url?: string;
        description?: string;
    };
    general: {
        title: string;
    };
}) => Promise<object | undefined>;
export declare const getEnterprisePageProjectsContent: (session: SnekSession, queryArgs: {
    slug: string;
}) => Promise<any[] | undefined>;
export declare const getEnterprisePageUsersContent: (session: SnekSession, queryArgs: {
    slug: string;
}) => Promise<any[] | undefined>;
export declare const addGitlab: (session: SnekSession, queryArgs: {
    active: boolean;
    description: string;
    enterprisePageSlug: string;
    gitlabToken: string;
    name: string;
    privilegesMode: string;
    url: string;
}) => Promise<{
    id: string;
} | undefined>;
export declare const deleteGitlab: (session: SnekSession, queryArgs: {
    id: number;
}) => Promise<{
    success: boolean;
} | undefined>;
export declare const updateGitlab: (session: SnekSession, queryArgs: {
    id: number;
    active?: boolean;
    description?: string;
    enterprisePageSlug?: string;
    gitlabToken?: string;
    name?: string;
    privilegesMode?: string;
    url?: string;
}) => Promise<{
    id: number;
} | undefined>;
export declare const getGitlabs: (session: SnekSession) => Promise<[] | undefined>;
export declare const addPipeline: (session: SnekSession, queryArgs: {
    enterprisePageSlug: string;
    active: boolean;
    name: string;
    description: string;
}) => Promise<{
    id: string;
} | undefined>;
export declare const deletePipeline: (session: SnekSession, queryArgs: {
    id: string;
}) => Promise<{
    success: boolean;
} | undefined>;
export declare const updatePipeline: (session: SnekSession, queryArgs: {
    id: number;
    active?: boolean;
    description?: string;
    enterprisePageSlug?: string;
    name?: string;
}) => Promise<{
    id: string;
} | undefined>;
export declare const getPipelines: (session: SnekSession) => Promise<[] | undefined>;
export declare const addConnector: (session: SnekSession, queryArgs: {
    active: boolean;
    url: string;
    name: string;
    description: string;
    connectorToken: string;
    enterprisePageSlug: string;
    privilegesMode: string;
    settings: {};
    shareMode: string;
}) => Promise<{
    id: string;
} | undefined>;
export declare const deleteConnector: (session: SnekSession, queryArgs: {
    id: number;
}) => Promise<{
    success: boolean;
} | undefined>;
export declare const updateConnector: (session: SnekSession, queryArgs: {
    id: number;
    active?: boolean;
    connectorToken?: string;
    description?: string;
    enterprisePageSlug?: string;
    name?: string;
    privilegesMode?: string;
    settings?: {};
    shareMode?: string;
    url?: string;
}) => Promise<{
    id: number;
} | undefined>;
export declare const getConnectors: (session: SnekSession) => Promise<[] | undefined>;
export declare const publishEnterprisePageViaConnector: (session: SnekSession, queryArgs: {
    connectorId: number;
}) => Promise<boolean | undefined>;
package/lib/utils/github/converter.d.ts000644 0000000103 3560116604 015243 0ustar00000000 000000 declare function run(rawData: any): Promise<void>;
export { run };
package/lib/utils/gitlab/converter.d.ts000644 0000000633 3560116604 015233 0ustar00000000 000000 interface IScrapedData {
    platform: {
        url: string;
        name: string;
    };
    home: Document;
    atom?: Document;
    currentCalendar: {
        [index: string]: number;
    };
    groups: {
        html: string;
    };
    projects: {
        html: string;
    };
    activity: {
        html: string;
    };
}
declare function runScraper(rawData: IScrapedData): void;
export { runScraper };
package/lib/utils/ops/converter.d.ts000644 0000007472 3560116604 014602 0ustar00000000 000000 import { SnekSession } from "snek-client/lib/session/sessions";
export declare const getEnterprisePages: (session: SnekSession) => Promise<[] | undefined>;
export declare const getEnterprisePageGeneralContent: (session: SnekSession, queryArgs: {
    slug: string;
}) => Promise<any>;
export declare const updateEnterprisePageGeneralContent: (session: SnekSession, queryArgs: {
    slug: string;
    imprint: {
        city?: string;
        zip_code?: string;
        address?: string;
        telephone?: string;
        telefax?: string;
        vat_number?: string;
        whatsapp_telephone?: string;
        whatsapp_contactline?: string;
        tax_id?: string;
        trade_register_number?: string;
        court_of_registry?: string;
        place_of_registry?: string;
        ownership?: string;
        email?: string;
        employee_count?: string;
        opensource_url?: string;
        recruiting_url?: string;
        description?: string;
    };
    general: {
        title: string;
    };
}) => Promise<object | undefined>;
export declare const getEnterprisePageProjectsContent: (session: SnekSession, queryArgs: {
    slug: string;
}) => Promise<any[] | undefined>;
export declare const getEnterprisePageUsersContent: (session: SnekSession, queryArgs: {
    slug: string;
}) => Promise<any[] | undefined>;
export declare const addGitlab: (session: SnekSession, queryArgs: {
    active: boolean;
    description: string;
    enterprisePageSlug: string;
    gitlabToken: string;
    name: string;
    privilegesMode: string;
    url: string;
}) => Promise<{
    id: string;
} | undefined>;
export declare const deleteGitlab: (session: SnekSession, queryArgs: {
    id: number;
}) => Promise<{
    success: boolean;
} | undefined>;
export declare const updateGitlab: (session: SnekSession, queryArgs: {
    id: number;
    active?: boolean;
    description?: string;
    enterprisePageSlug?: string;
    gitlabToken?: string;
    name?: string;
    privilegesMode?: string;
    url?: string;
}) => Promise<{
    id: number;
} | undefined>;
export declare const getGitlabs: (session: SnekSession) => Promise<[] | undefined>;
export declare const addPipeline: (session: SnekSession, queryArgs: {
    enterprisePageSlug: string;
    active: boolean;
    name: string;
    description: string;
}) => Promise<{
    id: string;
} | undefined>;
export declare const deletePipeline: (session: SnekSession, queryArgs: {
    id: string;
}) => Promise<{
    success: boolean;
} | undefined>;
export declare const updatePipeline: (session: SnekSession, queryArgs: {
    id: number;
    active?: boolean;
    description?: string;
    enterprisePageSlug?: string;
    name?: string;
}) => Promise<{
    id: string;
} | undefined>;
export declare const getPipelines: (session: SnekSession) => Promise<[] | undefined>;
export declare const addConnector: (session: SnekSession, queryArgs: {
    active: boolean;
    url: string;
    name: string;
    description: string;
    connectorToken: string;
    enterprisePageSlug: string;
    privilegesMode: string;
    settings: {};
    shareMode: string;
}) => Promise<{
    id: string;
} | undefined>;
export declare const deleteConnector: (session: SnekSession, queryArgs: {
    id: number;
}) => Promise<{
    success: boolean;
} | undefined>;
export declare const updateConnector: (session: SnekSession, queryArgs: {
    id: number;
    active?: boolean;
    connectorToken?: string;
    description?: string;
    enterprisePageSlug?: string;
    name?: string;
    privilegesMode?: string;
    settings?: {};
    shareMode?: string;
    url?: string;
}) => Promise<{
    id: number;
} | undefined>;
export declare const getConnectors: (session: SnekSession) => Promise<[] | undefined>;
export declare const publishEnterprisePageViaConnector: (session: SnekSession, queryArgs: {
    connectorId: number;
}) => Promise<boolean | undefined>;
package/lib/utils/talks/converter.d.ts000644 0000000103 3560116604 015077 0ustar00000000 000000 declare function run(rawData: any): Promise<void>;
export { run };
package/lib/utils/github/queries/data.d.ts000644 0000000437 3560116604 015634 0ustar00000000 000000 declare const profile: () => import("apollo-boost").DocumentNode;
declare const calendar: (fragments: string) => import("apollo-boost").DocumentNode;
declare const calendarFragment: (c: number, fromYear: string, toYear: string) => string;
export { profile, calendar, calendarFragment };
package/lib/toolbox/Delay.d.ts000644 0000000114 3560116604 013340 0ustar00000000 000000 declare function Delay(ms: number): Promise<unknown>;
export default Delay;
package/lib/reducer/database/helper/general.d.ts000644 0000000144 3560116604 016710 0ustar00000000 000000 declare function squeezer(obj: any, keys?: string[], exclude?: string[]): any;
export { squeezer };
package/lib/utils/oauth/GithubProvider.d.ts000644 0000000206 3560116604 016033 0ustar00000000 000000 import { IProvider } from "react-very-simple-oauth";
declare const GithubProvider: IProvider<boolean>;
export default GithubProvider;
package/lib/toolbox/GuidGenerator.d.ts000644 0000000110 3560116604 015035 0ustar00000000 000000 declare function GuidGenerator(): string;
export default GuidGenerator;
package/lib/index.d.ts000644 0000001731 3560116604 011731 0ustar00000000 000000 import { SnekClient } from "snek-client";
interface IIntel {
    snekclient: SnekClient;
    append(source: ISource): Promise<void>;
    appendList?(sources: ISource[]): Promise<void>;
}
interface ISource {
    user: string;
    platform: {
        url?: string;
        name: string;
    };
    authorization: string;
}
export declare class Intel implements IIntel {
    snekclient: SnekClient;
    private reducer;
    constructor();
    append(source: ISource): Promise<void>;
    appendList(sources: ISource[]): Promise<void>;
    generateTalks(sources: ISource[], organizations?: string[]): Promise<void>;
    appendTalk(file: Blob): Promise<void>;
    getDownloadUrl(url: string): Promise<string | null>;
    getTalks(): Promise<import("./reducer/helper/talks").ITalk[]>;
    get(): Promise<{
        profile: import("./reducer/helper/profile").IPlatform;
        statistic: import("./reducer/helper/statistic").IStatisticResponse;
    }>;
    resetReducer(): void;
}
export {};
package/lib/reducer/database/helper/index.d.ts000644 0000000241 3560116604 016400 0ustar00000000 000000 import * as calendar from "./calendar";
import * as general from "./general";
import * as statistic from "./statistic";
export { calendar, general, statistic };
package/lib/reducer/database/osm/index.d.ts000644 0000000136 3560116604 015722 0ustar00000000 000000 import * as models from "./models";
declare function reset(): void;
export { models, reset };
package/lib/reducer/helper/index.d.ts000644 0000000374 3560116604 014643 0ustar00000000 000000 import * as calendar from "./calendar";
import * as profile from "./profile";
import * as statistic from "./statistic";
import * as language from "./language";
import * as talks from "./talks";
export { calendar, profile, statistic, language, talks };
package/lib/reducer/index.d.ts000644 0000000543 3560116604 013362 0ustar00000000 000000 import * as models from "./database/models";
import * as helper from "./helper";
declare class Reducer {
    static models: typeof models;
    get(): Promise<{
        profile: helper.profile.IPlatform;
        statistic: helper.statistic.IStatisticResponse;
    }>;
    getTalks(): Promise<helper.talks.ITalk[]>;
    reset(): void;
}
export { Reducer };
package/lib/utils/enterprise/index.d.ts000644 0000003175 3560116604 015255 0ustar00000000 000000 import { SnekClient } from "snek-client";
declare class Provider {
    snekclient: SnekClient;
    constructor(opsUrl: string, client?: SnekClient);
    getEnterprisePages: () => Promise<[] | undefined>;
    getEnterprisePageGeneralContent: (queryArgs: any) => Promise<any>;
    updateEnterprisePageGeneralContent: (queryArgs: any) => Promise<object | undefined>;
    getEnterprisePageProjectsContent: (queryArgs: any) => Promise<any[] | undefined>;
    getEnterprisePageUsersContent: (queryArgs: any) => Promise<any[] | undefined>;
}
declare class OpsProvider extends Provider {
    addGitlab: (queryArgs: any) => Promise<{
        id: string;
    } | undefined>;
    deleteGitlab: (queryArgs: any) => Promise<{
        success: boolean;
    } | undefined>;
    updateGitlab: (queryArgs: any) => Promise<{
        id: number;
    } | undefined>;
    getGitlabs: () => Promise<[] | undefined>;
    addPipeline: (queryArgs: any) => Promise<{
        id: string;
    } | undefined>;
    deletePipeline: (queryArgs: any) => Promise<{
        success: boolean;
    } | undefined>;
    updatePipeline: (queryArgs: any) => Promise<{
        id: string;
    } | undefined>;
    getPipelines: () => Promise<[] | undefined>;
    addConnector: (queryArgs: any) => Promise<{
        id: string;
    } | undefined>;
    deleteConnector: (queryArgs: any) => Promise<{
        success: boolean;
    } | undefined>;
    updateConnector: (queryArgs: any) => Promise<{
        id: number;
    } | undefined>;
    getConnectors: () => Promise<[] | undefined>;
    publishEnterprisePageViaConnector: (queryArgs: any) => Promise<boolean | undefined>;
}
export default OpsProvider;
package/lib/utils/github/index.d.ts000644 0000000157 3560116604 014354 0ustar00000000 000000 import * as queries from "./queries";
import * as converter from "./converter";
export { queries, converter };
package/lib/utils/github/queries/index.d.ts000644 0000000360 3560116604 016025 0ustar00000000 000000 interface IProfile {
    createdAt: string;
}
declare function profile(): import("graphql").DocumentNode;
declare function calendar(profile: IProfile): import("graphql").DocumentNode;
export type { IProfile };
export { profile, calendar };
package/lib/utils/gitlab/index.d.ts000644 0000000151 3560116604 014326 0ustar00000000 000000 import * as paths from "./paths";
import * as converter from "./converter";
export { paths, converter };
package/lib/utils/oauth/index.d.ts000644 0000000211 3560116604 014201 0ustar00000000 000000 import RSA from "react-very-simple-oauth";
import GithubProvider from "./GithubProvider";
export default RSA;
export { GithubProvider };
package/lib/utils/ops/index.d.ts000644 0000003066 3560116604 013675 0ustar00000000 000000 import { SnekClient } from "snek-client";
declare class Provider {
    snekclient: SnekClient;
    constructor(opsUrl: string);
    getEnterprisePages: () => Promise<[] | undefined>;
    getEnterprisePageGeneralContent: (queryArgs: any) => Promise<any>;
    updateEnterprisePageGeneralContent: (queryArgs: any) => Promise<object | undefined>;
    getEnterprisePageProjectsContent: (queryArgs: any) => Promise<any[] | undefined>;
    getEnterprisePageUsersContent: (queryArgs: any) => Promise<any[] | undefined>;
    addGitlab: (queryArgs: any) => Promise<{
        id: string;
    } | undefined>;
    deleteGitlab: (queryArgs: any) => Promise<{
        success: boolean;
    } | undefined>;
    updateGitlab: (queryArgs: any) => Promise<{
        id: number;
    } | undefined>;
    getGitlabs: () => Promise<[] | undefined>;
    addPipeline: (queryArgs: any) => Promise<{
        id: string;
    } | undefined>;
    deletePipeline: (queryArgs: any) => Promise<{
        success: boolean;
    } | undefined>;
    updatePipeline: (queryArgs: any) => Promise<{
        id: string;
    } | undefined>;
    getPipelines: () => Promise<[] | undefined>;
    addConnector: (queryArgs: any) => Promise<{
        id: string;
    } | undefined>;
    deleteConnector: (queryArgs: any) => Promise<{
        success: boolean;
    } | undefined>;
    updateConnector: (queryArgs: any) => Promise<{
        id: number;
    } | undefined>;
    getConnectors: () => Promise<[] | undefined>;
    publishEnterprisePageViaConnector: (queryArgs: any) => Promise<boolean | undefined>;
}
export default Provider;
package/lib/utils/talks/index.d.ts000644 0000000365 3560116604 014211 0ustar00000000 000000 interface ISource {
    authorization: string;
    usernames: string[];
    organizations: string[];
}
declare function generate(source: ISource): Promise<void>;
declare function append(talk: object): Promise<void>;
export { generate, append };
package/lib/utils/upload/index.d.ts000644 0000000100 3560116604 014342 0ustar00000000 000000 import * as anonfiles from "./anonfiles";
export { anonfiles };
package/lib/reducer/database/osm/statements/language.d.ts000644 0000002154 3560116604 020567 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS language;\n\nCREATE TABLE IF NOT EXISTS language\n  (\n     id           INT NOT NULL auto_increment,\n     color        VARCHAR(80) NULL,\n     name         VARCHAR(80) NOT NULL,\n     size         INT NOT NULL,\n     repositoryId INT NULL REFERENCES repository (id),\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO language\n            (color,\n             name,\n             size,\n             repositoryId)\nVALUES      (?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   language\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   language\n";
declare const byRepository: (repositoryId: number) => string;
declare const merged = "\nSELECT L1.color,\n       L1.name,\n       Sum(L1.size)                                        AS size,\n       Round(Sum(L1.size) / (SELECT Sum(size)\n                             FROM   language L2) * 100, 2) AS share\nFROM   language L1\nGROUP  BY name,\n          color\nORDER  BY size DESC\n";
export { initialize, create, get, all, byRepository, merged };
package/lib/reducer/helper/language.d.ts000644 0000000177 3560116604 015320 0ustar00000000 000000 import * as models from "../database/models";
declare function mergedLanguage(): models.Language[];
export { mergedLanguage };
package/lib/reducer/database/osm/statements/member.d.ts000644 0000001466 3560116604 020260 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS member;\n\nCREATE TABLE IF NOT EXISTS member\n  (\n     id         INT NOT NULL auto_increment,\n     avatarUrl  VARCHAR(2048) NOT NULL,\n     url        VARCHAR(2048) NOT NULL,\n     fullname   VARCHAR(80) NULL,\n     username   VARCHAR(80) NOT NULL,\n     platformId INT NOT NULL REFERENCES platform (id),\n     UNIQUE(url),\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO member\n            (avatarUrl,\n             url,\n             fullname,\n             username,\n             platformId)\nVALUES      (?,\n             ?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   member\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   member\n";
export { initialize, create, get, all };
package/lib/toolbox/Merge.d.ts000644 0000000121 3560116604 013337 0ustar00000000 000000 export declare function mergeObjectsInUnique<T>(array: T[], property: any): T[];
package/lib/reducer/database/models.d.ts000644 0000017125 3560116604 015306 0ustar00000000 000000 import * as osm from "./osm";
import * as helper from "./helper";
interface IPlatform {
    id: number;
    platformName: string;
    platformUrl: string;
    avatarUrl: string;
    websiteUrl: string;
    company: string;
    email: string;
    username: string;
    fullName: string;
    createdAt: string;
    location: string;
    statusMessage: string;
    statusEmojiHTML: string;
}
interface IMember {
    id: number;
    avatarUrl: string;
    url: string;
    fullname: string;
    username: string;
    platformId: number;
}
interface IRepository {
    id: number;
    avatarUrl: string;
    url: string;
    name: string;
    ownerId: number;
}
interface ILanguage {
    id: number;
    color: string;
    name: string;
    size: number;
    share: number;
    repositoryId: number;
}
interface IOrganization {
    id: number;
    avatarUrl: string;
    url: string;
    name: string;
    fullname: string;
    description: string;
    platformName: string;
}
interface IStatistic {
    id: number;
    year: number;
    totalIssueContributions: number;
    totalCommitContributions: number;
    totalRepositoryContributions: number;
    totalPullRequestContributions: number;
    totalPullRequestReviewContributions: number;
    totalRepositoriesWithContributedIssues: number;
    totalRepositoriesWithContributedCommits: number;
    totalRepositoriesWithContributedPullRequests: number;
    platformId: number;
}
interface IStreak {
    id: number;
    startDate: string;
    endDate: string;
    totalDays: number;
    totalContributions: number;
    statisticId: number;
}
interface ICalendar {
    id: number;
    date: string;
    total: number;
    platformId: number;
}
interface IContribution {
    id: number;
    repoUrl: string;
    datetime: string;
    nameWithOwner: string;
    type: string;
    calendarId: number;
}
interface ITalk {
    id: number;
    name: string;
    url: string;
    displayUrl: string;
    downloadUrl: string;
    path: string;
    repositoryData: string;
}
declare class Platform extends osm.models.PlatformSO implements IPlatform {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    platformName: string;
    platformUrl: string;
    avatarUrl: string;
    websiteUrl: string;
    company: string;
    email: string;
    username: string;
    fullName: string;
    createdAt: string;
    location: string;
    statusMessage: string;
    statusEmojiHTML: string;
    constructor(args: IPlatform);
    createRepository(fields: any): Repository;
    createOrganization(fields: any): Organization;
    createStatistic(fields: any): Statistic;
    createCalendarEntry(fields: any): Calendar;
    getRepositories(): Repository[];
    getOrganizations(): Organization[];
    getCalendar(dates: any): helper.calendar.ICalendar;
    save(): void;
}
declare class Member extends osm.models.MemberSO {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    avatarUrl: string;
    url: string;
    fullname: string;
    username: string;
    platformId: number;
    constructor(args: IMember);
    save(): void;
}
declare class Repository extends osm.models.RepositorySO implements IRepository {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    avatarUrl: string;
    url: string;
    name: string;
    ownerId: number;
    constructor(args: IRepository);
    createMember(fields: any): Member;
    createLanguage(fields: any): Language;
    getMembers(): Member[];
    getLanguages(): Language[];
    save(): void;
}
declare class RepositoryHasMember extends osm.models.RepositoryHasMemberSO {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    save(): void;
}
declare class Language extends osm.models.LanguageSO implements ILanguage {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    color: string;
    name: string;
    size: number;
    share: number;
    repositoryId: number;
    constructor(args: ILanguage);
    static getLanguages(): Language[];
    save(): void;
}
declare class Organization extends osm.models.OrganizationSO implements IOrganization {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    avatarUrl: string;
    url: string;
    name: string;
    fullname: string;
    description: string;
    platformName: string;
    constructor(args: IOrganization);
    createMember(fields: any): Member;
    getMembers(): Member[];
    getRepositories(): Repository[];
    save(): void;
}
declare class Statistic extends osm.models.StatisticSO implements IStatistic {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    year: number;
    totalIssueContributions: number;
    totalCommitContributions: number;
    totalRepositoryContributions: number;
    totalPullRequestContributions: number;
    totalPullRequestReviewContributions: number;
    totalRepositoriesWithContributedIssues: number;
    totalRepositoriesWithContributedCommits: number;
    totalRepositoriesWithContributedPullRequests: number;
    platformId: number;
    constructor(args: IStatistic);
    createStreak(fields: any): Streak;
    getDates(): {
        from: string;
        to: string;
    };
    getStreaks(): Streak[];
    getStreakDetail(streaks: Streak[]): {
        longest: Streak;
        current: Streak;
    };
    getBusiestDay(): Calendar;
    getContributions(): {
        commit: osm.models.Share;
        issue: osm.models.Share;
        pullRequest: osm.models.Share;
        pullRequestReview: osm.models.Share;
        total: number;
    };
    static getMerged(): Statistic[];
    save(): void;
}
declare class Streak extends osm.models.StreakSO implements IStreak {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    startDate: string;
    endDate: string;
    totalDays: number;
    totalContributions: number;
    statisticId: number;
    constructor(args: IStreak);
    save(): void;
}
declare class Calendar extends osm.models.CalendarSO implements ICalendar {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    date: string;
    total: number;
    platformId: number;
    constructor(args: ICalendar);
    createContribution(fields: any): Contribution;
    save(): void;
}
declare class Contribution extends osm.models.ContributionSO implements IContribution {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    repoUrl: string;
    datetime: string;
    nameWithOwner: string;
    type: string;
    calendarId: number;
    constructor(args: IContribution);
    save(): void;
}
declare class Talk extends osm.models.TalkSO implements ITalk {
    static objects: import("./osm/reconstructor").SOAssembler;
    objects: import("./osm/reconstructor").SOAssembler;
    id: number;
    name: string;
    url: string;
    displayUrl: string;
    downloadUrl: string;
    path: string;
    repositoryData: string;
    constructor(args: ITalk);
    getRepository(): Repository;
    save(): void;
}
export { Platform, Statistic, Contribution, Repository, Language, Organization, Member, RepositoryHasMember, Streak, Calendar, Talk, };
package/lib/reducer/database/osm/models.d.ts000644 0000012272 3560116604 016102 0ustar00000000 000000 import { SOAssembler } from "./reconstructor";
import * as platform from "./statements/platform";
import * as member from "./statements/member";
import * as repository from "./statements/repository";
import * as repositoryHasMember from "./statements/repositoryHasMember";
import * as platformHasRepository from "./statements/platformHasRepository";
import * as language from "./statements/language";
import * as organization from "./statements/organization";
import * as organizationHasMember from "./statements/organizationHasMember";
import * as platformHasOrganization from "./statements/platformHasOrganization";
import * as statistic from "./statements/statistic";
import * as streak from "./statements/streak";
import * as calendar from "./statements/calendar";
import * as contribution from "./statements/contribution";
import * as talk from "./statements/talk";
import * as helper from "../helper";
interface Share {
    size: number;
    total: number;
}
declare abstract class BaseSO {
    static objects: SOAssembler;
    abstract id: number;
    abstract save(): void;
    abstract objects: SOAssembler;
    abstract tableName(): string;
    static getObjects(self: any): SOAssembler;
    render(filter: string[], excludes?: string[]): any;
}
declare abstract class PlatformSO extends BaseSO {
    static statements: typeof platform;
    static getLowestCreatedAtYear(): any;
    static getSourceTypes(): any;
    abstract createRepository(fields: any): RepositorySO;
    abstract createOrganization(fields: any): OrganizationSO;
    abstract createStatistic(fields: any): StatisticSO;
    abstract createCalendarEntry(fields: any): CalendarSO;
    abstract getRepositories(fields: any): RepositorySO[];
    abstract getOrganizations(fields: any): OrganizationSO[];
    abstract getCalendar(dates: any): object;
    tableName(): string;
}
declare abstract class MemberSO extends BaseSO {
    static statements: typeof member;
    tableName(): string;
}
declare abstract class RepositorySO extends BaseSO {
    static statements: typeof repository;
    static getLanguages(): any;
    abstract createMember(fields: any): MemberSO;
    abstract createLanguage(fields: any): LanguageSO;
    abstract getMembers(fields: any): MemberSO[];
    abstract getLanguages(fields: any): LanguageSO[];
    tableName(): string;
}
declare abstract class RepositoryHasMemberSO extends BaseSO {
    static statements: typeof repositoryHasMember;
    tableName(): string;
}
declare abstract class LanguageSO extends BaseSO {
    static statements: typeof language;
    tableName(): string;
}
declare abstract class PlatformHasRepositorySO extends BaseSO {
    static statements: typeof platformHasRepository;
    tableName(): string;
}
declare abstract class OrganizationSO extends BaseSO {
    static statements: typeof organization;
    abstract createMember(fields: any): MemberSO;
    abstract getMembers(): MemberSO[];
    abstract getRepositories(): RepositorySO[];
    tableName(): string;
}
declare abstract class OrganizationHasMemberSO extends BaseSO {
    static statements: typeof organizationHasMember;
    tableName(): string;
}
declare abstract class PlatformHasOrganizationSO extends BaseSO {
    static statements: typeof platformHasOrganization;
    tableName(): string;
}
declare abstract class StatisticSO extends BaseSO {
    static statements: typeof statistic;
    static getMerged(cls: any): any;
    static getContributions(self: any): {
        commit: Share;
        issue: Share;
        pullRequest: Share;
        pullRequestReview: Share;
        total: number;
    };
    abstract createStreak(fields: any): StreakSO;
    abstract getStreaks(): StreakSO[];
    abstract getStreakDetail(streaks: StreakSO[]): {
        longest: StreakSO;
        current: StreakSO;
    };
    abstract getBusiestDay(): CalendarSO;
    abstract getContributions(): {
        commit: Share;
        issue: Share;
        pullRequest: Share;
        pullRequestReview: Share;
        total: number;
    };
    tableName(): string;
}
declare abstract class StreakSO extends BaseSO {
    static statements: typeof streak;
    tableName(): string;
}
declare abstract class CalendarSO extends BaseSO {
    static statements: typeof calendar;
    static getDaysBetweenDate(dates: {
        from: string;
        to: string;
    }): any;
    static getBusiestDay(dates: {
        from: string;
        to: string;
    }): any;
    static getCalendar(dates: {
        from: string;
        to: string;
    }): {
        success: boolean;
        data: helper.calendar.ICalendar;
        message?: undefined;
    } | {
        success: boolean;
        data: helper.calendar.ICalendar;
        message: string;
    };
    abstract createContribution(fields: any): ContributionSO;
    tableName(): string;
}
declare abstract class ContributionSO extends BaseSO {
    static statements: typeof contribution;
    tableName(): string;
}
declare abstract class TalkSO extends BaseSO {
    static statements: typeof talk;
    tableName(): string;
}
export type { Share };
export { BaseSO, PlatformSO, MemberSO, RepositorySO, RepositoryHasMemberSO, LanguageSO, PlatformHasRepositorySO, OrganizationSO, OrganizationHasMemberSO, PlatformHasOrganizationSO, StatisticSO, StreakSO, CalendarSO, ContributionSO, TalkSO, };
package/lib/reducer/database/osm/statements/organization.d.ts000644 0000002170 3560116604 021506 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS organization;\n\nCREATE TABLE IF NOT EXISTS organization\n  (\n     id          INT NOT NULL auto_increment,\n     avatarUrl   VARCHAR(2048) NOT NULL,\n     url         VARCHAR(2048) NOT NULL,\n     name        VARCHAR(80) NOT NULL,\n     fullname    VARCHAR(80) NOT NULL,\n     description VARCHAR(255),\n     UNIQUE(url),\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO organization\n            (avatarUrl,\n             url,\n             name,\n             fullname,\n             description)\nVALUES      (?,\n             ?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   organization\nWHERE  id = ?\n";
declare const all = "\nSELECT id,\n       avatarUrl,\n       url,\n       name,\n       fullname,\n       description,\n       (SELECT p.platformName\n        FROM   platformhasorganization pho\n               INNER JOIN platform p\n                       ON pho.platformId = p.id\n        WHERE  pho.organizationId = o.id) AS platformName\nFROM   organization o\n";
export { initialize, create, get, all };
package/lib/reducer/database/osm/statements/organizationHasMember.d.ts000644 0000001266 3560116604 023277 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS organizationhasmember;\n\nCREATE TABLE IF NOT EXISTS organizationhasmember\n  (\n     id             INT NOT NULL auto_increment,\n     organizationId INT NOT NULL REFERENCES organization (id),\n     memberId       INT NOT NULL REFERENCES member (id),\n     UNIQUE(id),\n     PRIMARY KEY (organizationId, memberId)\n  );\n";
declare const create = "\nINSERT INTO organizationhasmember\n            (organizationId,\n             memberId)\nVALUES      (?,\n             ?);\n";
declare const all = "\nSELECT *\nFROM   organizationhasmember\n       INNER JOIN member m\n               ON memberId = m.id\n";
export { initialize, create, all };
package/lib/utils/gitlab/paths.d.ts000644 0000000605 3560116604 014342 0ustar00000000 000000 declare const home: (username: string) => string;
declare const currentCalendar: (username: string) => string;
declare const activity: (username: string) => string;
declare const atom: (username: string) => string;
declare const groups: (username: string) => string;
declare const projects: (username: string) => string;
export { home, currentCalendar, activity, atom, groups, projects };
package/lib/utils/talks/paths.d.ts000644 0000000257 3560116604 014221 0ustar00000000 000000 declare const user: (username: string, page: number) => string;
declare const organization: (organizationName: string, page: number) => string;
export { user, organization };
package/lib/reducer/database/osm/statements/platform.d.ts000644 0000003271 3560116604 020631 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS platform;\n\nCREATE TABLE IF NOT EXISTS platform\n  (\n     id              INT NOT NULL auto_increment,\n     platformName    VARCHAR(80) NOT NULL,\n     platformUrl     VARCHAR(2048) NOT NULL,\n     avatarUrl       VARCHAR(2048) NOT NULL,\n     websiteUrl      VARCHAR(2048) NOT NULL,\n     company         VARCHAR(80) NOT NULL,\n     email           VARCHAR(80) NOT NULL,\n     username        VARCHAR(80) NOT NULL,\n     fullname        VARCHAR(80) NOT NULL,\n     createdAt       DATE NOT NULL,\n     location        VARCHAR(80) NULL,\n     statusMessage   VARCHAR(80) NULL,\n     statusEmojiHTML VARCHAR(80) NULL,\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO platform\n            (platformName,\n             platformUrl,\n             avatarUrl,\n             websiteUrl,\n             company,\n             email,\n             username,\n             fullname,\n             createdAt,\n             location,\n             statusMessage,\n             statusEmojiHTML)\nVALUES      (?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   platform\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   platform\n";
declare const lowestCreatedAtYear = "\nSELECT Year(Min(createdAt)) AS createdAt\nFROM   platform\n";
declare const getSourceTypes = "\nSELECT platformName        AS source,\n       Count(platformName) AS total\nFROM   platform\nGROUP  BY platformName\n";
export { initialize, create, get, all, lowestCreatedAtYear, getSourceTypes };
package/lib/reducer/database/osm/statements/platformHasOrganization.d.ts000644 0000001320 3560116604 023643 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS platformhasorganization;\n\nCREATE TABLE IF NOT EXISTS platformhasorganization\n  (\n     id             INT NOT NULL auto_increment,\n     platformId     INT NOT NULL REFERENCES platform (id),\n     organizationId INT NOT NULL REFERENCES organization (id),\n     UNIQUE(id),\n     PRIMARY KEY (platformId, organizationId)\n  );\n";
declare const create = "\nINSERT INTO platformhasorganization\n            (platformId,\n             organizationId)\nVALUES      (?,\n             ?);\n";
declare const all = "\nSELECT *\nFROM   platformhasorganization\n       INNER JOIN organization o\n               ON organizationId = o.id\n";
export { initialize, create, all };
package/lib/reducer/database/osm/statements/platformHasRepository.d.ts000644 0000001270 3560116604 023362 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS platformhasrepository;\n\nCREATE TABLE IF NOT EXISTS platformhasrepository\n  (\n     id           INT NOT NULL auto_increment,\n     platformId   INT NOT NULL REFERENCES platform (id),\n     repositoryId INT NOT NULL REFERENCES repository (id),\n     UNIQUE(id),\n     PRIMARY KEY (platformId, repositoryId)\n  );\n";
declare const create = "\nINSERT INTO platformhasrepository\n            (platformId,\n             repositoryId)\nVALUES      (?,\n             ?);\n";
declare const all = "\nSELECT *\nFROM   platformhasrepository\n       INNER JOIN repository r\n               ON repositoryId = r.id\n";
export { initialize, create, all };
package/lib/reducer/helper/profile.d.ts000644 0000001060 3560116604 015165 0ustar00000000 000000 import * as models from "../database/models";
interface IPlatform extends models.Platform {
    sources: object[];
    repositories: IRepository[];
    organizations: IOrganization[];
}
interface IRepository extends models.Repository {
    owner: models.Organization;
    members: models.Member[];
    languages: models.Language[];
}
interface IOrganization extends models.Organization {
    members: models.Member[];
    repositories: IRepository[];
}
declare function mergedProfile(): Promise<IPlatform>;
export type { IPlatform };
export { mergedProfile };
package/lib/reducer/database/osm/reconstructor.d.ts000644 0000000473 3560116604 017533 0ustar00000000 000000 declare class SOAssembler {
    private Base;
    static database: any;
    constructor(Base: any);
    create(fields: any): any;
    get(fields: any): any;
    all(): any;
    filter(filter: any, Cls?: any, filterStatement?: string): any;
    custom(query: any): any;
    reload(): void;
}
export { SOAssembler };
package/lib/reducer/database/osm/statements/repository.d.ts000644 0000002001 3560116604 021212 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS repository;\n\nCREATE TABLE IF NOT EXISTS repository\n  (\n     id        INT NOT NULL auto_increment,\n     avatarUrl VARCHAR(2048) NOT NULL,\n     url       VARCHAR(2048) NOT NULL,\n     name      VARCHAR(80) NOT NULL,\n     ownerId   INT NULL REFERENCES member (id),\n     UNIQUE(url),\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO repository\n            (avatarUrl,\n             url,\n             name,\n             ownerId)\nVALUES      (?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   repository\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   repository r\n";
declare const withOwner = "\nSELECT r.id        AS id,\n       r.avatarUrl AS avatarUrl,\n       r.url       AS url,\n       r.name      AS name,\n       m.username  AS owner\nFROM   repository r\n       INNER JOIN member m\n               ON r.ownerId = m.id\n";
export { initialize, create, get, all, withOwner };
package/lib/reducer/database/osm/statements/repositoryHasMember.d.ts000644 0000001242 3560116604 023004 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS repositoryhasmember;\n\nCREATE TABLE IF NOT EXISTS repositoryhasmember\n  (\n     id           INT NOT NULL auto_increment,\n     repositoryId INT NOT NULL REFERENCES repository (id),\n     memberId     INT NOT NULL REFERENCES member (id),\n     UNIQUE(id),\n     PRIMARY KEY (repositoryId, memberId)\n  );\n";
declare const create = "\nINSERT INTO repositoryhasmember\n            (repositoryId,\n             memberId)\nVALUES      (?,\n             ?);\n";
declare const all = "\nSELECT *\nFROM   repositoryhasmember\n       INNER JOIN member m\n               ON memberId = m.id\n";
export { initialize, create, all };
package/lib/reducer/database/helper/statistic.d.ts000644 0000000452 3560116604 017304 0ustar00000000 000000 interface IStreak {
    startDate?: string;
    endDate?: string | null;
    totalDays: number;
    totalContributions: number;
}
interface IDay {
    date?: string;
    color?: string;
    total: number;
}
declare function calculateStreaks(values: IDay[]): IStreak[];
export { calculateStreaks };
package/lib/reducer/database/osm/statements/statistic.d.ts000644 0000005717 3560116604 021023 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS statistic;\n\nCREATE TABLE IF NOT EXISTS statistic\n  (\n     id                                           INT NOT NULL auto_increment,\n     year                                         INT NOT NULL,\n     totalIssueContributions                      INT NOT NULL,\n     totalCommitContributions                     INT NOT NULL,\n     totalRepositoryContributions                 INT NOT NULL,\n     totalPullRequestContributions                INT NOT NULL,\n     totalPullRequestReviewContributions          INT NOT NULL,\n     totalRepositoriesWithContributedIssues       INT NOT NULL,\n     totalRepositoriesWithContributedCommits      INT NOT NULL,\n     totalRepositoriesWithContributedPullRequests INT NOT NULL,\n     platformId                                   INT NOT NULL REFERENCES\n     platform (id),\n     UNIQUE(year, platformId),\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO statistic\n            (year,\n             totalIssueContributions,\n             totalCommitContributions,\n             totalRepositoryContributions,\n             totalPullRequestContributions,\n             totalPullRequestReviewContributions,\n             totalRepositoriesWithContributedIssues,\n             totalRepositoriesWithContributedCommits,\n             totalRepositoriesWithContributedPullRequests,\n             platformId)\nVALUES      (?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   statistic\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   statistic\n";
declare const allMerged = "\nSELECT year,\n       Sum(totalIssueContributions)                      AS\n       totalIssueContributions,\n       Sum(totalCommitContributions)                     AS\n       totalCommitContributions,\n       Sum(totalRepositoryContributions)                 AS\n       totalRepositoryContributions,\n       Sum(totalPullRequestContributions)                AS\n       totalPullRequestContributions,\n       Sum(totalPullRequestReviewContributions)          AS\n       totalPullRequestReviewContributions,\n       Sum(totalRepositoriesWithContributedIssues)       AS\n       totalRepositoriesWithContributedIssues,\n       Sum(totalRepositoriesWithContributedCommits)      AS\n       totalRepositoriesWithContributedCommits,\n       Sum(totalRepositoriesWithContributedPullRequests) AS\n       totalRepositoriesWithContributedPullRequests\nFROM   statistic\nGROUP  BY year\nORDER  BY year\n";
declare const commitContributionsOfYear: string;
declare const issueContributionsOfYear: string;
declare const pullRequestContributionsOfYear: string;
declare const pullRequestReviewContributionsOfYear: string;
export { initialize, create, get, all, allMerged, commitContributionsOfYear, issueContributionsOfYear, pullRequestContributionsOfYear, pullRequestReviewContributionsOfYear, };
package/lib/reducer/helper/statistic.d.ts000644 0000001441 3560116604 015537 0ustar00000000 000000 import * as models from "../database/models";
import { Share } from "../database/osm/models";
import { ICalendar } from "../database/helper/calendar";
interface IStatisticResponse {
    current: IStatistic | null;
    years: IStatistic[];
    languages: models.Language[];
}
interface IStatistic extends models.Statistic {
    busiestDay: models.Calendar;
    contributions: {
        commit: Share;
        issue: Share;
        pullRequest: Share;
        pullRequestReview: Share;
        total: number;
    };
    streak: {
        longest: models.Streak;
        current: models.Streak;
        streaks: models.Streak[];
    };
    calendar: ICalendar;
}
declare function mergedStatistic(): Promise<IStatisticResponse>;
export type { IStatisticResponse, IStatistic };
export { mergedStatistic };
package/lib/reducer/database/osm/statements/streak.d.ts000644 0000001270 3560116604 020273 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS streak;\n\nCREATE TABLE IF NOT EXISTS streak\n  (\n     id          INT NOT NULL auto_increment,\n     startDate   DATE NULL,\n     endDate     DATE NULL,\n     total       INT NULL,\n     statisticId INT NOT NULL REFERENCES statistic(id),\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO streak\n            (startDate,\n             endDate,\n             total,\n             statisticId)\nVALUES      (?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   streak\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   streak\n";
export { initialize, create, get, all };
package/lib/reducer/database/osm/statements/talk.d.ts000644 0000001565 3560116604 017744 0ustar00000000 000000 declare const initialize = "\nDROP TABLE IF EXISTS talk;\n\nCREATE TABLE IF NOT EXISTS talk\n  (\n     id             INT NOT NULL auto_increment,\n     name           VARCHAR(80) NOT NULL,\n     url            VARCHAR(2024) NOT NULL,\n     displayUrl     VARCHAR(2024) NOT NULL,\n     downloadUrl    VARCHAR(2024) NOT NULL,\n     path           VARCHAR(2024) NOT NULL,\n     repositoryData TEXT NOT NULL,\n     PRIMARY KEY (id)\n  );\n";
declare const create = "\nINSERT INTO talk\n            (name,\n             url,\n             displayUrl,\n             downloadUrl,\n             path,\n             repositoryData)\nVALUES      (?,\n             ?,\n             ?,\n             ?,\n             ?,\n             ?);\n";
declare const get = "\nSELECT *\nFROM   talk\nWHERE  id = ?\n";
declare const all = "\nSELECT *\nFROM   talk\n";
export { initialize, create, get, all };
package/lib/reducer/helper/talks.d.ts000644 0000000335 3560116604 014647 0ustar00000000 000000 import { Repository, Talk } from "../database/models";
interface ITalk extends Talk {
    repository: Repository;
    uid: string;
}
declare function mergedTalks(): ITalk[];
export type { ITalk };
export { mergedTalks };
package/lib/utils/enterprise/tools.d.ts000644 0000000745 3560116604 015306 0ustar00000000 000000 declare const mergeCodetransition: (arr: any[]) => {
    current: import("../../reducer/database/helper/calendar").ICalendar;
    years: import("../../reducer/database/helper/calendar").ICalendar[];
} | undefined;
declare const mergeContributionFeed: (arr: any[]) => {
    current: import("../../reducer/database/helper/calendar").ICalendar;
    years: import("../../reducer/database/helper/calendar").ICalendar[];
} | undefined;
export { mergeCodetransition, mergeContributionFeed };
package/lib/utils/ops/tools.d.ts000644 0000000745 3560116604 013727 0ustar00000000 000000 declare const mergeCodetransition: (arr: any[]) => {
    current: import("../../reducer/database/helper/calendar").ICalendar;
    years: import("../../reducer/database/helper/calendar").ICalendar[];
} | undefined;
declare const mergeContributionFeed: (arr: any[]) => {
    current: import("../../reducer/database/helper/calendar").ICalendar;
    years: import("../../reducer/database/helper/calendar").ICalendar[];
} | undefined;
export { mergeCodetransition, mergeContributionFeed };