public void ProcessThrowsIfSyncItemIsNull()
    {
      var sut = new CopyParentId();
      var dsitem = Substitute.For<IDsDbItem>();
      var dataStorage = Substitute.For<DataStorage>(Database.GetDatabase("master"));
      var args = new DsItemLoadingArgs(dsitem, dataStorage);

      Action action = () => sut.Process(args);

      action.ShouldThrow<ArgumentNullException>().WithMessage("*SyncItem");
    }
    public void ProcessThrowsIfSyncItemParentIdIsNotIdentifier()
    {
      var sut = new CopyParentId();
      var dsitem = Substitute.For<IDsDbItem>();
      dsitem.SyncItem.Returns(new SyncItem { ParentID = "not an id" });
      var dataStorage = Substitute.For<DataStorage>(Database.GetDatabase("master"));
      var args = new DsItemLoadingArgs(dsitem, dataStorage);

      Action action = () => sut.Process(args);

      action.ShouldThrow<ArgumentException>().WithMessage("Unable to copy ParentId. Valid identifier expected.*");
    }
    public void ProcessIgnoresParentIdIfNoParentItemFound()
    {
      var sut = new CopyParentId();
      var dsitem = Substitute.For<IDsDbItem, DbItem>("item");
      var parentId = ID.NewID;
      dsitem.SyncItem.Returns(new SyncItem { ParentID = parentId.ToString() });
      var dataStorage = Substitute.For<DataStorage>(Database.GetDatabase("master"));
      var args = new DsItemLoadingArgs(dsitem, dataStorage);

      sut.Process(args);

      ((DbItem)dsitem).ParentID.Should().BeNull();
    }
    public void Process(DsItemLoadingArgs args)
    {
      Assert.ArgumentNotNull(args, "args");

      var dsDbItem = args.DsDbItem as DsDbItem;

      if (dsDbItem == null || !dsDbItem.DeserializeLinkedTemplate || args.DataStorage.GetFakeItem(dsDbItem.TemplateID) != null)
      {
        return;
      }

      DeserializeTemplate(args.DataStorage, dsDbItem.TemplateID, dsDbItem.SerializationFolderName);
    }
    public void Process(DsItemLoadingArgs args)
    {
      Assert.ArgumentNotNull(args, "args");

      var syncItem = args.DsDbItem.SyncItem;
      Assert.ArgumentNotNull(syncItem, "SyncItem");
      Assert.ArgumentCondition(ID.IsID(syncItem.ParentID), "ParentID", "Unable to copy ParentId. Valid identifier expected.");

      var parentId = ID.Parse(syncItem.ParentID);
      if (args.DataStorage.GetFakeItem(parentId) == null)
      {
        return;
      }

      // TODO: Avoid type casting.
      ((DbItem)args.DsDbItem).ParentID = parentId;
    }
    public void Process(DsItemLoadingArgs args)
    {
      Assert.ArgumentNotNull(args, "args");

      var dsDbItem = args.DsDbItem as DsDbItem;

      if (dsDbItem == null)
      {
        return;
      }

      // Deserialize and link descendants, if needed
      var file = args.DsDbItem.File;
      if (!dsDbItem.IncludeDescendants || file.Directory == null)
      {
        return;
      }

      var childItemsFolder = new DirectoryInfo(file.Directory.FullName + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(file.Name));
      if (!childItemsFolder.Exists)
      {
        return;
      }

      foreach (var itemFile in childItemsFolder.GetFiles("*.item", SearchOption.TopDirectoryOnly))
      {
        DbItem childItem;
        var syncItem = itemFile.Deserialize();

        if (syncItem.TemplateID == TemplateIDs.Template.ToString())
        {
          childItem = new DsDbTemplate(dsDbItem.SerializationFolderName, syncItem, itemFile);
        }
        else
        {
          childItem = new DsDbItem(dsDbItem.SerializationFolderName, syncItem, itemFile, true);
        }

        dsDbItem.Children.Add(childItem);
      }
    }
    public void Process(DsItemLoadingArgs args)
    {
      Assert.ArgumentNotNull(args, "args");

      var template = args.DsDbItem as DsDbTemplate;
      Assert.ArgumentNotNull(template, "Item was not a DsDbTemplate, which is required here");

      foreach (var descendantItem in template.File
        .DeserializeAll(template.SyncItem, Deserializer.GetSerializationFolder(template.SerializationFolderName), 3)
        .Where(i => ID.IsID(i.TemplateID) && ID.Parse(i.TemplateID) == TemplateIDs.TemplateField))
      {
        var isSharedField = descendantItem.SharedFields.FirstOrDefault(f => "Shared".Equals(f.FieldName));
        var typeField = descendantItem.SharedFields.FirstOrDefault(f => "Type".Equals(f.FieldName));

        var isShared = isSharedField != null && "1".Equals(isSharedField.FieldValue);

        template.Fields.Add(new DbField(descendantItem.Name, ID.Parse(descendantItem.ID))
          {
            Shared = isShared,
            Type = typeField != null ? typeField.FieldValue : string.Empty
          });
      }
    }
 public void Process(DsItemLoadingArgs args)
 {
   Assert.ArgumentNotNull(args, "args");
   args.DsDbItem.SyncItem.CopyVersionedFieldsTo(args.DsDbItem);
 }