RegistrationService

package com.srv4pos.server.api.registration;

import com.srv4pos.server.api.activation.RegistrationDetailedOverviewInfo;
import com.srv4pos.server.api.activation.RegistrationInfo;
import com.srv4pos.server.api.day.RegistrationVersion;
import com.srv4pos.server.api.exceptions.ReferenceNotFoundJsonException;
import com.srv4pos.server.api.infrastructure.EmptyConnectionWriter;
import com.srv4pos.server.api.infrastructure.HttpMethod;
import com.srv4pos.server.api.infrastructure.StringConnectionWriter;
import com.srv4pos.server.api.infrastructure.credentials.Credentials;
import com.srv4pos.server.api.infrastructure.exceptions.enums.ForbiddenErrorType;
import com.srv4pos.server.api.infrastructure.exceptions.enums.UnprocessableEntityErrorType;
import com.srv4pos.server.api.infrastructure.http.HttpHelper;
import com.srv4pos.server.api.infrastructure.http.Transport;
import com.srv4pos.server.api.infrastructure.request.StringResponse;

import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.srv4pos.server.api.infrastructure.request.RequestHelper.requestString;
import static com.srv4pos.server.api.infrastructure.request.RequestHelper.requestVoid;
import static java.lang.String.format;


/**
 * Service to reach registrations.
 *
 * @author Ruslan Kashapov.
 */
public class RegistrationService {

    private URL url;
    private Credentials credentials;
    private Transport transport;

    /**
     * Constructs the service.
     *
     * @param url         of the server
     * @param credentials to work with the server
     * @param transport   to know the method to reach the server
     */
    public RegistrationService(URL url, Credentials credentials, Transport transport) {
        this.url = url;
        this.credentials = credentials;
        this.transport = transport;
    }

    /**
     * Get balance of registration.
     *
     * @param version          version of seller, may be null (if latest data needed)
     * @param cashRegisterName described in swedish regulations as "cash register designation"
     * @return balance of registration
     * @throws ReferenceNotFoundJsonException                                     if cashRegisterName is not found
     * @throws com.srv4pos.server.api.exceptions.UnprocessableEntityJsonException see:
     *                                                                            {@link UnprocessableEntityErrorType#DAY_IS_NOT_CLOSED},
     *                                                                            {@link UnprocessableEntityErrorType#REPORT_IS_NOT_PRINTED}
     */
    public BalanceInfo getBalance(Integer version, String cashRegisterName) {
        StringResponse response = requestString(
                format("%s/registrations/%s/balance", credentials.getSellerId(), cashRegisterName),
                HttpMethod.GET,
                url,
                credentials.toAuthentication(),
                HttpHelper.integerToETag(version),
                null,
                EmptyConnectionWriter.EMPTY_CONNECTION_WRITER,
                HttpHelper.CONTENT_TYPE_APPLICATION_JSON,
                transport);

        return response == null ? null : BalanceInfo.fromJsonToBalanceInfo(response.getContent());
    }

    /**
     * Set balance of registration.
     *
     * @param version           expected latest version of seller
     * @param cashRegisterName  described in swedish regulations as "cash register designation"
     * @param changeBalanceInfo registration balance and action
     * @throws ReferenceNotFoundJsonException                                     if cashRegisterName is not found
     * @throws com.srv4pos.server.api.exceptions.UnprocessableEntityJsonException see:
     *                                                                            {@link UnprocessableEntityErrorType#DAY_IS_CLOSED},
     *                                                                            {@link UnprocessableEntityErrorType#DAY_IS_NOT_CLOSED},
     *                                                                            {@link UnprocessableEntityErrorType#REPORT_IS_NOT_PRINTED}
     */
    public void setBalance(int version, String cashRegisterName, ChangeBalanceInfo changeBalanceInfo) {
        requestVoid(
                format("%s/registrations/%s/balance", credentials.getSellerId(), cashRegisterName),
                HttpMethod.POST,
                url,
                credentials.toAuthentication(),
                HttpHelper.integerToETag(version),
                null,
                new StringConnectionWriter(changeBalanceInfo.toJson()),
                HttpHelper.CONTENT_TYPE_APPLICATION_JSON,
                transport);
    }

    /**
     * Returns list of all registrations.
     *
     * @param version version of seller, may be null (if latest data needed)
     * @return list of all registrations
     */
    public List<RegistrationInfo> list(Integer version) {
        return list(version, null, null, null, null, false);
    }

    /**
     * Returns list of registrations.
     *
     * @param version     version of seller, may be null (if latest data needed)
     * @param firstResult when pagination starts or null
     * @param maxResults  amount of items per page or null
     * @param orderBy     field to order by, possible values are "IDENTIFIER", "NAME"
     * @param orderDesc   field to direction of ordering
     * @param activeOnly  True if need only active registrations, otherwise all registrations
     * @return list of registrations
     */
    public List<RegistrationInfo> list(Integer version,
                                       Integer firstResult,
                                       Integer maxResults,
                                       RegistrationInfo.Fields orderBy,
                                       Boolean orderDesc,
                                       Boolean activeOnly) {
        Map<String, String> params = new HashMap<String, String>();

        if (activeOnly != null) {
            params.put("activeOnly", String.valueOf(activeOnly));
        }
        if (firstResult != null) {
            params.put("firstResult", Integer.toString(firstResult));
        }
        if (maxResults != null) {
            params.put("maxResults", Integer.toString(maxResults));
        }
        if (orderBy != null) {
            params.put("orderBy", orderBy.name());
        }
        if (orderDesc != null) {
            params.put("orderDesc", orderDesc.toString());
        }

        StringResponse response = requestString(
                format("%s/registrations", credentials.getSellerId()),
                HttpMethod.GET,
                url,
                credentials.toAuthentication(),
                null,
                params,
                EmptyConnectionWriter.EMPTY_CONNECTION_WRITER,
                HttpHelper.CONTENT_TYPE_APPLICATION_JSON,
                transport);

        return response == null ? null : (List<RegistrationInfo>) RegistrationInfo.fromJsonArrayToRegistrationInfoes(response.getContent());
    }

    /**
     * Returns stats by registrations.
     *
     * @param period filters by date period
     * @return
     */
    public List<RegistrationStatsInfo> stats(String period) {
        Map<String, String> params = new HashMap<String, String>();
        if (period != null) {
            params.put("period", period);
        }
        StringResponse response = requestString(
                format("%s/registrations/stats", credentials.getSellerId()),
                HttpMethod.GET,
                url,
                credentials.toAuthentication(),
                null,
                params,
                EmptyConnectionWriter.EMPTY_CONNECTION_WRITER,
                HttpHelper.CONTENT_TYPE_APPLICATION_JSON,
                transport
        );
        return response == null ? null : (List<RegistrationStatsInfo>) RegistrationStatsInfo.fromJsonArrayToRegistrationStatsInfoes(response.getContent());
    }

    /**
     * Returns an registration info.
     *
     * @param seller           seller's identifier
     * @param cashRegisterName cash register name
     * @return the entity
     * @throws com.srv4pos.server.api.exceptions.NotFoundJsonException  if registration wasn't found
     * @throws com.srv4pos.server.api.exceptions.ForbiddenJsonException see:
     *                                                                  {@link ForbiddenErrorType#INSUFFICIENT_ACCESS_RIGHTS}
     */
    public RegistrationDetailedOverviewInfo getOverviewInfo(String seller, String cashRegisterName) {
        return RegistrationDetailedOverviewInfo.fromJsonToRegistrationDetailedOverviewInfo(requestString(
                format("%s/registrations/%s", seller, cashRegisterName),
                HttpMethod.GET,
                url,
                credentials.toAuthentication(),
                null,
                null,
                EmptyConnectionWriter.EMPTY_CONNECTION_WRITER,
                HttpHelper.CONTENT_TYPE_APPLICATION_JSON,
                transport).getContent());
    }

    /**
     * Returns latest version of registration.
     *
     * @param cashRegisterName described in swedish regulations as "cash register designation"
     * @return version number
     * @see RegistrationServiceSample
     */
    public RegistrationVersion getRegistrationVersion(String cashRegisterName) {
        return RegistrationVersion.fromJsonToRegistrationVersion(
                requestString(
                        format("%s/registrations/%s/version", credentials.getSellerId(), cashRegisterName),
                        HttpMethod.GET,
                        url,
                        credentials.toAuthentication(),
                        null,
                        null,
                        EmptyConnectionWriter.EMPTY_CONNECTION_WRITER,
                        HttpHelper.CONTENT_TYPE_APPLICATION_JSON,
                        transport
                ).getContent()
        );
    }

    /**
     * Returns list of item changes between two versions.
     *
     * @param versionFrom version from included
     * @param versionTo   version to included
     * @return list of items to be added, edited or deleted ({@link com.srv4pos.server.api.activation.RegistrationInfo#deleted} = true)
     */
    public List<RegistrationInfo> listDiff(int versionFrom, int versionTo) {
        StringResponse response = requestString(
                String.format("%s/registrations-diff/%s/%s", credentials.getSellerId(), versionFrom, versionTo),
                HttpMethod.GET,
                url,
                credentials.toAuthentication(),
                null,
                null,
                EmptyConnectionWriter.EMPTY_CONNECTION_WRITER,
                HttpHelper.CONTENT_TYPE_APPLICATION_JSON,
                transport
        );
        return (List<RegistrationInfo>) RegistrationInfo.fromJsonArrayToRegistrationInfoes(response.getContent());
    }

    /**
     * Delete registration from the server.
     *
     * @param version    current version of the entity
     * @param identifier identifies entity
     * @throws com.srv4pos.server.api.exceptions.VersionConflictJsonException if version mismatch
     */
    public void delete(int version, String identifier) {
        requestVoid(
                format("%s/registrations/%s", credentials.getSellerId(), identifier),
                HttpMethod.DELETE,
                url,
                credentials.toAuthentication(),
                HttpHelper.integerToETag(version),
                null,
                EmptyConnectionWriter.EMPTY_CONNECTION_WRITER,
                HttpHelper.CONTENT_TYPE_APPLICATION_JSON,
                transport
        );
    }
}