places.ts

//   Copyright 2020 Vircadia Contributors
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

'use strict'

import Config from '@Base/config';

import { Router, RequestHandler, Request, Response, NextFunction } from 'express';
import { setupMetaverseAPI, finishMetaverseAPI } from '@Route-Tools/middleware';
import { accountFromAuthToken } from '@Route-Tools/middleware';
import { buildPlaceInfo } from '@Route-Tools/Util';

import { Domains } from '@Entities/Domains';
import { Places } from '@Entities/Places';

import { Perm } from '@Route-Tools/Perm';
import { checkAccessToEntity } from '@Route-Tools/Permissions';

import { PaginationInfo } from '@Entities/EntityFilters/PaginationInfo';
import { PlaceFilterInfo } from '@Entities/EntityFilters/PlaceFilterInfo';
import { Maturity } from '@Entities/Sets/Maturity';

import { IsNullOrEmpty, IsNotNullOrEmpty } from '@Tools/Misc';
import { Logger } from '@Tools/Logging';

// Return places information
// The accounts returned depend on the scope (whether admin) and the search criteria (infoer)
const procGetPlaces: RequestHandler = async (req: Request, resp: Response, next: NextFunction) => {
  if (req.vAuthAccount) {
    const pager = new PaginationInfo();
    const placer = new PlaceFilterInfo();

    pager.parametersFromRequest(req);
    placer.parametersFromRequest(req);

    // Loop through all the filtered accounts and create array of info
    const places: any[] = [];
    for await (const place of Places.enumerateAsync(pager, placer)) {
      places.push(await buildPlaceInfo(place));
    };

    req.vRestResp.Data = {
      'places': places,
      'maturity-categories': Maturity.MaturityCategories
    };

    placer.addResponseFields(req);
    pager.addResponseFields(req);
  }
  else {
    req.vRestResp.respondFailure(req.vAccountError ?? 'Not logged in');
  };
  next();
};

// Create a Place.
// We receive either the new request with the data under 'place' or
//    the legacy request with some of the data at the top level.
// { 'place_id': id, 'path': path, 'domain_id': id }
export const procPostPlaces: RequestHandler = async (req: Request, resp: Response, next: NextFunction) => {
  if (req.vAuthAccount) {
    let requestedName: string;
    let requestedDesc: string;
    let requestedAddr: string;
    let requestedDomainId: string;

    if (req.body.place) {
      requestedName = req.body.place.name;
      requestedDesc = req.body.place.description;
      requestedAddr = req.body.place.address;
      requestedDomainId = req.body.place.domainId;
    }
    else {
      requestedName = req.body.place_id;
      requestedAddr = req.body.path;
      requestedDomainId = req.body.domain_id;
    };

    if (requestedName && requestedAddr && requestedDomainId) {
      const aDomain = await Domains.getDomainWithId(requestedDomainId);
      if (aDomain) {
        if (await checkAccessToEntity(req.vAuthToken, aDomain, [ Perm.SPONSOR, Perm.ADMIN ], req.vAuthAccount)) {
          const maybePlace = await Places.getPlaceWithName(requestedName);
          if (IsNullOrEmpty(maybePlace)) {
            const newPlace = Places.createPlace();
            newPlace.name = requestedName;
            newPlace.description = requestedDesc;
            newPlace.address = requestedAddr;
            newPlace.domainId = aDomain.id;
            newPlace.maturity = aDomain.maturity ?? Maturity.UNRATED;
            Places.addPlace(newPlace);

            req.vRestResp.Data = buildPlaceInfo(newPlace, aDomain);
          }
          else {
            req.vRestResp.respondFailure('place name already exists');
          };
        }
        else {
          req.vRestResp.respondFailure('unauthorized');
        };
      }
      else {
        req.vRestResp.respondFailure('name/address/domainId not specified');
      };
    }
    else {
      req.vRestResp.respondFailure('no domain specified');
    };
  }
  else {
    req.vRestResp.respondFailure(req.vAccountError ?? 'Not logged in');
  };
  next();
};

export const name = '/api/v1/places';

export const router = Router();

router.get(   '/api/v1/places',   [ setupMetaverseAPI,      // req.vRestResp, req.vAuthToken
                                    accountFromAuthToken,   // req.vAuthAccount
                                    procGetPlaces,
                                    finishMetaverseAPI ] );
router.post(   '/api/v1/places',
                                  [ setupMetaverseAPI,   // req.vRESTResp, req.vAuthToken
                                    accountFromAuthToken, // req.vAuthAccount
                                    procPostPlaces,
                                    finishMetaverseAPI ] );