ProtoAccountDataSerializer.java

/**
 * Copyright 2010 Google Inc.
 *
 * 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.
 *
 */

package org.waveprotocol.box.server.persistence.protos;

import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.protobuf.ByteString;
import com.google.wave.api.Context;
import com.google.wave.api.ProtocolVersion;
import com.google.wave.api.event.EventType;
import com.google.wave.api.robot.Capability;

import org.waveprotocol.box.server.account.AccountData;
import org.waveprotocol.box.server.account.HumanAccountData;
import org.waveprotocol.box.server.account.HumanAccountDataImpl;
import org.waveprotocol.box.server.account.RobotAccountData;
import org.waveprotocol.box.server.account.RobotAccountDataImpl;
import org.waveprotocol.box.server.authentication.PasswordDigest;
import org.waveprotocol.box.server.persistence.protos.ProtoAccountStoreData.ProtoAccountData;
import org.waveprotocol.box.server.persistence.protos.ProtoAccountStoreData.ProtoAccountData.AccountDataType;
import org.waveprotocol.box.server.persistence.protos.ProtoAccountStoreData.ProtoHumanAccountData;
import org.waveprotocol.box.server.persistence.protos.ProtoAccountStoreData.ProtoPasswordDigest;
import org.waveprotocol.box.server.persistence.protos.ProtoAccountStoreData.ProtoRobotAccountData;
import org.waveprotocol.box.server.persistence.protos.ProtoAccountStoreData.ProtoRobotCapabilities;
import org.waveprotocol.box.server.persistence.protos.ProtoAccountStoreData.ProtoRobotCapability;
import org.waveprotocol.box.server.robots.RobotCapabilities;
import org.waveprotocol.wave.model.wave.ParticipantId;

import java.util.List;
import java.util.Map;

/**
 * This class is used to serialize and deserialize {@link AccountData} and {@link ProtoAccountData}
 * 
 * @author tad.glines@gmail.com (Tad Glines)
 */
public class ProtoAccountDataSerializer {
  /**
   * Serialize {@link AccountData} into {@link ProtoAccountData}.
   */
  public static ProtoAccountData serialize(AccountData account) {
    Preconditions.checkNotNull(account, "account is null");
    Preconditions.checkArgument(account.isHuman() || account.isRobot(),
        "account is neither a human or robot account!");
    ProtoAccountData.Builder builder = ProtoAccountData.newBuilder();
    builder.setAccountId(account.getId().getAddress());
    if (account.isHuman()) {
      builder.setAccountType(AccountDataType.HUMAN_ACCOUNT);
      builder.setHumanAccountData(serialize(account.asHuman()));
    } else if (account.isRobot()) {
      builder.setAccountType(AccountDataType.ROBOT_ACCOUNT);
      builder.setRobotAccountData(serialize(account.asRobot()));
    }
    return builder.build();
  }
  
  private static ProtoHumanAccountData serialize(HumanAccountData account) {
    Preconditions.checkNotNull(account, "account is null");
    ProtoHumanAccountData.Builder builder = ProtoHumanAccountData.newBuilder();
    if (account.getPasswordDigest() != null) {
      builder.setPasswordDigest(serialize(account.getPasswordDigest()));
    }
    return builder.build();
  }
  
  private static ProtoPasswordDigest serialize(PasswordDigest digest) {
    Preconditions.checkNotNull(digest, "digest is null");
    return ProtoPasswordDigest.newBuilder()
      .setSalt(ByteString.copyFrom(digest.getSalt()))
      .setDigest(ByteString.copyFrom(digest.getDigest()))
      .build();
  }

  private static ProtoRobotAccountData serialize(RobotAccountData account) {
    Preconditions.checkNotNull(account, "account is null");
    ProtoRobotAccountData.Builder builder = ProtoRobotAccountData.newBuilder();
    builder.setUrl(account.getUrl());
    builder.setConsumerSecret(account.getConsumerSecret());
    builder.setIsVerified(account.isVerified());
    if (account.getCapabilities() != null) {
      builder.setRobotCapabilities(serialize(account.getCapabilities()));
    }
    return builder.build();
  }
  
  private static ProtoRobotCapabilities serialize(RobotCapabilities capabilities) {
    ProtoRobotCapabilities.Builder builder = ProtoRobotCapabilities.newBuilder();
    builder.setProtocolVersion(capabilities.getProtocolVersion().getVersionString());
    builder.setCapabilitiesHash(capabilities.getCapabilitiesHash());
    if (capabilities.getCapabilitiesMap() != null) {
      for (Capability capability: capabilities.getCapabilitiesMap().values()) {
        builder.addCapability(serialize(capability));
      }
    }
    return builder.build();
  }
  
  private static ProtoRobotCapability serialize(Capability capability) {
    ProtoRobotCapability.Builder builder = ProtoRobotCapability.newBuilder();
    builder.setEventType(capability.getEventType().name());
    builder.setFilter(capability.getFilter());
    for (Context context: capability.getContexts()) {
      builder.addContext(context.name());
    }
    return builder.build();
  }
  
  /**
   * Deserialize {@link ProtoAccountData} into {@link AccountData}.
   */
  public static AccountData deserialize(ProtoAccountData data) {
    switch (data.getAccountType()) {
      case HUMAN_ACCOUNT:
        Preconditions.checkArgument(data.hasHumanAccountData(),
            "ProtoAccountData is missing the human_account_data field");
        return deserialize(data.getAccountId(), data.getHumanAccountData());
      case ROBOT_ACCOUNT:
        Preconditions.checkArgument(data.hasRobotAccountData(),
            "ProtoAccountData is missing the robot_account_data field");
        return deserialize(data.getAccountId(), data.getRobotAccountData());
      default:
        throw new IllegalArgumentException(
            "ProtoAccountData contains neither HumanAccountData nor RobotAccountData.");
    }
  }
  
  private static HumanAccountData deserialize(String account_id, ProtoHumanAccountData data) {
    ParticipantId id = ParticipantId.ofUnsafe(account_id);
    if (data.hasPasswordDigest()) {
      return new HumanAccountDataImpl(id, deserialize(data.getPasswordDigest()));
    } else {
      return new HumanAccountDataImpl(id);
    }
  }

  private static PasswordDigest deserialize(ProtoPasswordDigest data) {
    return PasswordDigest.from(data.getSalt().toByteArray(), data.getDigest().toByteArray());
  }
  
  private static RobotAccountData deserialize(String account_id, ProtoRobotAccountData data) {
    ParticipantId id = ParticipantId.ofUnsafe(account_id);
    RobotCapabilities capabilities = null;
    if (data.hasRobotCapabilities()) {
      capabilities = deserialize(data.getRobotCapabilities());
    }
    return new RobotAccountDataImpl(id, data.getUrl(), data.getConsumerSecret(),
        capabilities, data.getIsVerified());
  }
  
  private static RobotCapabilities deserialize(ProtoRobotCapabilities data) {
    Map<EventType, Capability> capabilities = Maps.newHashMap();
    for (ProtoRobotCapability capabilityData: data.getCapabilityList()) {
      Capability capability = deserialize(capabilityData);
      capabilities.put(capability.getEventType(), capability);
    }
    return new RobotCapabilities(capabilities, data.getCapabilitiesHash(),
        ProtocolVersion.fromVersionString(data.getProtocolVersion()));
  }
  
  private static Capability deserialize(ProtoRobotCapability data) {
    List<Context> contexts = Lists.newArrayList();
    for (String str: data.getContextList()) {
      contexts.add(Context.valueOf(str));
    }
    return new Capability(EventType.valueOf(data.getEventType()), contexts, data.getFilter());
  }
}