Microsoft has presented some compelling arguments as to why this will happen, cost benefits, architectural benefits, technical benefits, and so on. I can truly see their point. Cloud computing really is the coolest thing since sliced bread.

I cannot begin to convey the benefits and opportunities of a global computing cloud where everything from processing power to gigantic raw data feeds are available at everyone’s fingertips. All the world’s statistics; flight traffic information, stock markets, civic registries, motor registries, price and stock lists from manufacturers, news, periodic tables, historical data and statistics on toxic waste and energy consumption, all of it, at my disposal. This is the single largest effort to embrace the mentality of the digital generation, where consuming, remixing and publishing is as natural as breathing. This could very well change the way we use and think about information and computing in the future.

I am not alone in worrying about such things as data sovereignty, information ownership, data protection and standards compliance. Microsoft is taking steps to acquire the necessary certifications, such as PCI, to allow the business community to fully commit to their take on cloud computing and the Azure platform, but they’re not quite there just yet.

The problem is that standards such as PCI aren’t designed to be implemented on a cloud computing scenario. What is more likely to happen is that such standards will adapt to cloud computing terms and scenarios. That will take time. Until then, interconnected public and private clouds will be the name of the game.

For now, I’m happy to sift through all the free t-shirts and blinking beer mugs I got at the partner expo.

We did a fair bit of research before we left, and although the research encountered a multitude of opinions, everyone seemed to agree on staying well clear of an area called Inglewood. Needless to say, it was with mounting trepidation that we observed how our shuttle-bus from the rental-car service left LA international airport far behind, and sped off deeper and deeper into precisely that area.

The rental service turned out to be so far away from the airport, that our carefully printed out directions and local maps ended up being of no immediate use.

Eventually we managed to guess our way to the freeway, only to be greeted by the LA rush-hour traffic.

I kid you not; spending two hours tip-tapping the accelerator on a fiftyeleven lane wide spaghetti-freeway in rush-hour in an awkward rental-car with a way too sensitive accelerator after not having slept for 72 hours, truly is a remarkable experience! I highly recommend it!

The hotel we stay at is a rather cozy place on West Olympic Blvd, cuddled up against the eastern edge of Koreatown, or K–town as the natives refer to it.

Half an hour after arriving at the hotel, the awful memory of what passes for pizza in Sweden was pleasantly swept away by a friendly deliveryman from Domino’s. Thank you, Domino’s! My first decent pizza in over ten years!

Oh, while shopping today, I saw an actual LAPD squad car! After having seen these chase bad-guys all across my TV since childhood, I just had to snap an inconspicuous picture

After some refactoring and additional coding, the class structure looks like this:

The XmlTableBase and XmlTable classes are re-usable for generic LINQ friendly XML table-like storage of classes.

Most of the “tables” in the OxiteXmlContext use the XmlTable class directly. Most classes which inherit from the NamedEntity base class in Oxite get handled by the OxiteEntityTable class, which adds default behavior on top of the XmlTable. Those classes which require additional logic when serializing / deserializing the entities are implemented as classes which inherit either from XmlTable or OxiteEntityTable, as shown in the class diagram above.

I have opted to not use the standard XML serialization classes for this, because I wanted to reuse the existing classes in the Oxite model, which aren’t decorated with any serialization attributes. This allows for the Oxite model to change somewhat without any maintenance being required for the XML Data Provider.

The other option had been to implement a layer on top of the Oxite model which has Xml serialization attributes, and although perhaps a better practice, it just seemed too redundant at this point.

Therefore I have written custom serialization and deserialization methods that use generics and reflection to achieve storage and retrieval.

The serialization/deserialization methods recognize all the standard value type codes in .NET, as well as Enums, Nullable<T>, Guid and the Uri types.

Basically, the deserialization process iterates all attributes and child elements of the entity element and invokes this method:

private static void SetPropertyValue(object obj,
    string propertyName, object value)
{
    if (obj == null || value == null)
        return;

    PropertyInfo propertyInfo = obj.GetType().GetProperty(
        propertyName, BINDING_FLAGS);

    // Skip non-existing properties. Will be handled with
    // custom deserialization by descendant classes
    if (propertyInfo == null)
        return;

    Type propertyType = propertyInfo.PropertyType;

    // If nullable generic type, use the generic
    // parameter instead
    if (propertyType.Name == "Nullable`1")
        propertyType = propertyType.GetGenericArguments()[0];

    if (Type.GetTypeCode(propertyType) == TypeCode.Object)
    {
        if (propertyType == typeof(Guid))
            value = new Guid(value.ToString());
        else if (propertyType == typeof(Uri))
            value = new Uri(value.ToString());
        else // Skip on unknown types
            return;
    }

    if (propertyType.IsEnum)
        value = Enum.Parse(propertyType, value.ToString());

    propertyInfo.SetValue(obj, Convert.ChangeType(value,
        propertyType, CultureInfo.InvariantCulture), null);
}

Most of the XML Data Provider is now complete. I opted for simplicity over completeness for the initial version, deferring caching in favor of a more straight-forward thread-safety mechanism which locks the class on operations that modify files. Currently this has the weakness of locking all file operations of the same type, regardless if they conflict or not. Two comments being saved at the same time for separate posts will be queued, despite them being saved to separate files.

At the moment I feel it’s more important to work out the kinks in the repository implementations and get to a point where everything works, before I polish the whole thing to a fancy shine.

What I have done so far, is write some generic Linq to XML classes that do most of the heavy lifting of storing and retrieving objects using reflection, and used those to implement the repositories.

I have then implemented a class called OxiteXmlContext which aims to resemble a traditional Linq to SQL data context. This class has properties like Tags, Sites, Languages, Phrases and so on. These “tables” wrap up all the functionality of storing, retrieving and removing objects in an XDocument (one for each table).

This has allowed me to reuse some of the query logic in the Linq to SQL provider. But in many cases I have been able to greatly simplify or remove the queries entirely. This, due to the fact that the XML provider does not have a second layer of classes on top of the native Oxite model, and thus not requiring any projection.

The larger storages, such as posts, pages, comments and so on, where it isn’t feasible to read everything into memory and sort it out afterwards, have been split into one folder per post/page. Each folder contains separate files for body, comments and trackbacks. This is to avoid having to rewrite the post body when a new comment is added. The relations between posts, pages, tags and areas have been indexed in separate files along with creation and publish dates, status and so on. These indexes might grow a bit once post count reaches a thousand or so. Hopefully if the author is diligent enough to post thousands of posts, the author in question will also be enough of an enthusiast to invest in an SQL storage instead.

As you can see by this class diagram, the hierarchy is quite straightforward.

If you look closely, you’ll see a property on the OxiteXmlContext called PostHeaders. This property is actually the index and translates to a class called PostHeader. PostHeader contains, as the name indicates, header fields for the post, such as Id, Title, Status, Publish date, Tags and so on. It also contains a method called GetPost, which fetches the post from disk by reading the body.xml, comments.xml and trackbacks.xml files in the post’s folder.

Saving of the post is done either in whole by calling the Save method on OxiteXmlContext or by saving individual parts of it by calling the SaveBody, SaveComments or SaveTrackbacks method.

Less complex types, such as Site and Plugin which also contain child objects, but don’t deserve having them stored in separate files like comments for posts, instead inherit from the XmlTable class and override the serialization methods to store/retrieve these sub items from the XDocument directly.

public class OxitePluginTable : XmlTable<Plugin>
{
    public OxitePluginTable(string baseDirectory)
        : base(baseDirectory, "ID")
    {
    }

    protected override XElement ProjectEntity(TEntity entity)
    {
        XElement element = base.ProjectEntity(entity);

        Plugin plugin = (Plugin)entity;

        element.Add(new XElement("settings",
            from r in plugin.Settings.AllKeys
            select new XElement(r, plugin.Settings[r])));

        return element;
    }

    protected override TEntity ProjectEntity(XElement element)
    {
        Plugin plugin = (Plugin)base.ProjectEntity(element);
        plugin.Settings = new NameValueCollection();

        element.Element("settings").Elements().ToList().ForEach(e =>
            plugin.Settings.Add(e.Name.ToString(), e.Value));

        return plugin;
    }
}

As you can see by the PluginRepository, the code is strikingly similar to that of Linq to SQL, yet not quite exactly the same.

public class PluginRepository : IPluginRepository
{
    private OxiteXmlContext mContext;

    public PluginRepository(Site site)
    {
        mContext = new OxiteXmlContext(site);
    }

    public IList<IPlugin> GetPlugins()
    {
        var query = from p in mContext.Plugins
                    orderby p.Category, p.Name
                    select p;

        return query.Cast<IPlugin>().ToList();
    }

    public IPlugin GetPlugin(Guid pluginID)
    {
        return mContext.Plugins.GetEntity(pluginID);
    }

    public bool GetPluginExists(Guid pluginID)
    {
        return mContext.Plugins.GetEntity(pluginID) != null;
    }

    public void Save(IPlugin plugin)
    {
        mContext.Plugins.Save(projectPlugin(plugin));
    }

    private Plugin projectPlugin(IPlugin p)
    {
        return new Plugin
        {
            Category = p.Category,
            Enabled = p.Enabled,
            ID = p.ID,
            Name = p.Name,
            Settings = p.Settings
        };
    }

    public void Save(IPlugin plugin, NameValueCollection settings)
    {
        Plugin p = projectPlugin(plugin);
        p.Settings = settings;
        mContext.Plugins.Save(p);
    }

    public NameValueCollection GetPluginSettings(Guid pluginID)
    {
        return GetPlugin(pluginID).Settings;
    }

    public void SaveSetting(Guid pluginID, string name, string value)
    {
        Plugin plugin = mContext.Plugins.GetEntity(pluginID);
        plugin.Settings[name] = value;
        mContext.Plugins.Save(plugin);
    }
}

What’s next?

IPageRepository

The page repository still remains to be implemented.

Caching

I aim to add a simple per-process in-memory cache of entities to avoid having to fetch them from disk each time they are requested. This not only helps performance each time a page is served, but also on a lower level, since the Linq queries can result in multiple hits on the same entity, which would result in the same entity being deserialized multiple times.

Tread-safety

None of the classes are currently thread-safe, which they need to be in order for Oxite to be able to serve more than one visitor at a time, lest two instances try and write to the same file at the same time! I have purposefully skipped this part is I will implement this as part of the caching mechanism and refactor the repositories to go through the cache which in turn will serialize requests into the store.

I would really have liked to use the Concurrent classes from .NET 4.0, but I’m going to take a stab in the dark here and guess that’s not an option until next year. Which means no SpinLock either. ReaderWriterLockSlim it is!

Refactoring

I will refactor XmlEntityTable to inherit from XmlTable instead of XmlTableBase and reuse what is implemented on XmlTable.

I will try and tidy up the xml storage classes so they can be reused in other projects that need xml database-like storage.

So, I decided to sit down, download the latest Oslo SDK and write a new rule engine based on a DSL implemented in MGrammar.

Basically, what I wanted to demonstrate, was how you can create a domain specific language, in which your business analysts, end-users and grease-monkeys can express business rules in natural-like-language, which you can then feed through MGrammar and parse into something relatively coherent.

Consider the following typical business rules at Northwind Traders Co.:

• Only supervisors may place orders with a discount higher than 7%
• The total price of a sales order must exceed the total cost.
• Even though the designers of the software that Northwind uses had left the field Credit Rating on the customer records as optional, Northwind now wants it to be mandatory when adding new customers as part of their new and improved risk management strategy.

Now, these rules can be expressed in many ways. Imagine that you have written a shrink-wrapped sales system which you sell from your website. You really don’t want your 2 411 customers to call you on the phone while you’re busy playing the beta of Mass Effect 2 just because they want some optional field to suddenly become a required field, or because they want to restrict the discount level for sales staff on Mondays if there’s a full moon and the employee has been with the company for less than six months and wears jeans to work. Yes, I know! Customers really do get the strangest and often misguided “requirements” into their heads.

And let’s be honest, you couldn’t possibly have imagined that your newest customer would [one month later] want to restrict the discount level that sales employees that wear jeans to work are allowed to give on Mondays when there’s a full moon! Yet, there they are, at your doorstep, in their tastefully chalk-streaked $2000 suits, pulling you away from pruning your blog and monitoring the Google analysis charts, wanting this very feature implemented!

If only you had supplied the sales software with a simple rules engine so that customers could take care of these things on their own!

Constraining business objects using a natural-like language

Using a domain specific language, the above bulleted rules could be expressed like this:

RuleSet Northwind
  // Max discount of 7%
  Add rule for Order that requires Discount to be
    less than or equal to "0.07" unless
    SalesPerson.Supervisor is true

  // Price must be gt cost
  Add rule for Order that requires TotalPrice to be
    greater than TotalCost

  // Credit rating is now a required field
  Add rule for Customer that requires CreditRating
    to not be empty
End RuleSet

It’s enough like plain English, that whoever writes these rules won’t need to learn another language and syntax, only some basic rules. That, and somehow be provided with a list of what fields there are. You could provide a user interface that adds the “Add rule for” text at the beginning of each new line as the user presses the enter key, and have a ListBox that shows a list of business objects such as Customer, Order, Product that the user can double-click on to insert into the text at the current cursor position. Well, you get the idea.

Now, in your code, you may have business objects (Linq to SQL or Entities or whatever), like this:

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string CreditRating { get; set; }
}

You could then implement an extension method called IsValid that will take care of all the heavy lifting for you (yes, very heavy…):

public static class RuleSet
{
    public static bool IsValid(this object value)
    {
        return evaluate(value);
    }
}

And invoke it like this:

// Read business rules from file or blob field in database
RuleSet.Add(resourceStream);

// Create a customer
Customer c = new Customer
{
    Id = 10,
    Name = "Contoso",
    CreditRating = null // <- Will cause validation to fail!
};

// Will print out: Customer valid: False
Console.WriteLine("Customer valid: {0}", c.IsValid());

c.CreditRating = "Excellent";

// Will print out: Customer valid: True
Console.WriteLine("Customer valid: {0}", c.IsValid());

What I do, is feed the business rules along with the DSL specification through MGrammar and project the result into a class library that uses reflection to validate the rules.

The MGrammar needed to parse and understand the above business rules is quite simple, actually:

module ObjectContraints
{
    export ObjectRules;

    language ObjectRules
    {
        // Basic tokens
        token Whitespace = (' ' | '\r' | '\n' );
        token Digit = ('0'..'9');
        token Identifier =
            ('A'..'Z' | 'a'..'z' | '.' | '_')+;
        token Linebreak = '\n' | '\r' | '\r\n';

        // Keywords
        @{Classification["Keyword"]}
        token RuleSet = 'RuleSet';
        @{Classification["Keyword"]}
        token End = 'End' | 'end';
        @{Classification["Keyword"]}
        token AddRuleFor = 'Add rule for';
        @{Classification["Keyword"]}
        token ThatRequires = 'that requires';
        @{Classification["Keyword"]}
        token ToBe = 'to be';
        @{Classification["Keyword"]}
        token ToNotBe = 'to not be';
        @{Classification["Keyword"]}
        token Is = 'is';
        @{Classification["Keyword"]}
        token IsNot = 'is not';
        @{Classification["Keyword"]}
        token When = 'when';
        @{Classification["Keyword"]}
        token Unless = 'unless';

        // Operators
        @{Classification["Keyword"]}
        token EqualTo = 'equal to';
        @{Classification["Keyword"]}
        token GreaterThan = 'greater than';
        @{Classification["Keyword"]}
        token GreaterThanOrEqualTo = 'greater than or equal to';
        @{Classification["Keyword"]}
        token LessThan = 'less than';
        @{Classification["Keyword"]}
        token LessThanOrEqualTo = 'less than or equal to';
        @{Classification["Keyword"]}
        token Empty = 'empty';
        @{Classification["Keyword"]}
        token True = 'true';
        @{Classification["Keyword"]}
        token False = 'false';

        // Comments
        @{Classification["Comment"]}
        token CommentToken = CommentDelimited | CommentLine;
        token CommentDelimited =
          "/*" CommentDelimitedContent* "*/";
        token CommentDelimitedContent = ^('*') | '*'  ^('/');  

        token CommentLine = "//" CommentLineContent*;
        token CommentLineContent
          = ^(
               '\u000A' // New Line
            |  '\u000D' // Carriage Return
            |  '\u0085' // Next Line
            |  '\u2028' // Line Separator
            |  '\u2029' // Paragraph Separator
            );  

        // Quoted values
        token QuoteDelimited =
          '"' c:QuoteDelimitedContent* '"' => c;
        token QuoteDelimitedContent = ^('"');              

        interleave Skippable = Whitespace | Comment;
        interleave Comment = CommentToken;

        // Main syntax
        syntax Main = RuleSet name:Identifier rules:Rule* End RuleSet
            => { Name => name, Rules => rules };

        // Single rule syntax
        syntax Rule = AddRuleFor className:Identifier ThatRequires
                expression:Expression1 condition:Condition?
            => { ClassName => className, Expression => expression,
                    Condition => condition };

        syntax Expression1 = propertyName:Identifier inverse:ToBeOrNotToBe
            operation:Operation =>
            { PropertyName => propertyName, Inverse => inverse,
              Comparison => operation };

        syntax Expression2 = propertyName:Identifier inverse:IsOrIsNot
            operation:Operation =>
            { PropertyName => propertyName, Inverse => inverse,
              Comparison => operation };

        syntax Operation =
                  EqualTo value:Value               =>
                        { Operator => "Eq", Value => value }
                | GreaterThanOrEqualTo value:Value  =>
                        { Operator => "GtEq", Value => value }
                | GreaterThan value:Value           =>
                        { Operator => "Gt", Value => value }
                | LessThanOrEqualTo value:Value     =>
                        { Operator => "LtEq", Value => value }
                | LessThan value:Value              =>
                        { Operator => "Lt", Value => value }
                | Empty                             =>
                        { Operator => "IsEmpty" }
                | True                              =>
                        { Operator => "IsTrue" }
                | False                             =>
                        { Operator => "IsFalse" };

        syntax Condition = c1:ConditionWhen => c1 | c2:ConditionUnless => c2;
        syntax ConditionWhen = When expression:Expression2 => expression;
        syntax ConditionUnless = Unless expression:Expression2 => expression;

        syntax ToBeOrNotToBe = ToNotBe => true | ToBe => false;
        syntax IsOrIsNot = IsNot => true | Is => false;

        syntax Value = value1:Identifier => Identifier { value1 }
                     | value2:QuoteDelimited => Literal { value2 };
    }
}

That’s it!

The class library that evaluates the business rules is also quite simple. The core method is Evaluate which is invoked by the IsValid extension method:

public bool Evaluate(object value)
{
    if (value == null)
        return false;

    if (PropertyInfo == null)
        return false;

    object propertyValue = PropertyInfo.GetValue(value, null);
    Type propertyType = PropertyInfo.PropertyType;

    bool result = false;
    switch (Operator)
    {
        case RuleOperator.Eq: result = (compare(propertyValue,
            getValue(value)) == 0); break;
        case RuleOperator.Gt: result = (compare(propertyValue,
            getValue(value)) == -1); break;
        case RuleOperator.GtEq: result = (compare(propertyValue,
            getValue(value)) >= 0); break;
        case RuleOperator.IsEmpty: result =
            (compare(propertyValue, null) == 0); break;
        case RuleOperator.IsFalse: result =
            (compare(propertyValue, false) == 0); break;
        case RuleOperator.IsTrue: result =
            (compare(propertyValue, true) == 0); break;
        case RuleOperator.Lt: result =
            (compare(propertyValue, getValue(value)) == 1); break;
        case RuleOperator.LtEq: result =
            (compare(propertyValue, getValue(value)) <= 0); break;
        default: return false;
    }
    return result ^ Inverse;
}

In fact, instead of projecting it into an expression tree-like class library and use reflection to validate the object, you could actually emit real IL code!

- I’ll leave that part as an exercise for the reader

Well, for now, here’s a natural-language-like business rules engine that validates objects using reflection.

Source code is for Visual Studio 2010 B1 with May 2009 CTP of Oslo.

Download source code:

Disclaimer: The source code has some limitations. It will not follow property paths (such as SalesPerson.Manager.IsSupervisor). It’s limited to simple literals and property names and the operators listed above. It is intended as a source of inspiration and not a third-party library that you can download and hook into your production code.

Oxite comes with an SQL data provider, which is great. But I wanted an XML data provider, so the content could be stored like in dasBlog.

As an experiment, I created an XSD schema from the database that ships with Oxite, and implemented a class called OxiteDbContext, which serves as a cache.

public static class OxiteDbContext
{
    private static OxiteDb mDatabase = new OxiteDb();
    private static string mFilename =
      HttpContext.Current.Server.MapPath(
      "~/App_Data/oxite.xml");

    static OxiteDbContext()
    {
        mDatabase.ReadXml(mFilename);
    }

    public static void Save()
    {
        lock (mDatabase)
        {
            mDatabase.AcceptChanges();
            mDatabase.WriteXml(mFilename);
        }
    }

    public static OxiteDb Data
    {
        get
        {
            return mDatabase;
        }
    }
}

I then copy/pasted the code from the SQL provider and re-mapped the LINQ to SQL code to the new typed DataSet, like so:

public Area GetArea(string areaName)
{
    return (from a in OxiteDbContext.Data.oxite_Area
            where a.SiteID == siteID && string.Compare(
            a.AreaName, areaName, true) == 0
            select ProjectArea(a)).FirstOrDefault();
}

It’s not exactly impressive, as it stores the entire dataset in a single XML file, and whenever it saves anything, it re-writes the entire XML file.

Imagine that you have 200 MB of posts on your Blog, someone adds a comment, and the blog re-writes 200 MB on the disk. Not exactly “best practice”, but it will suffice as a first experiment.

A better approach would be to make more use of the disk structure, and split the schema into separate XML files, to minimize disk access.

One plausible structure could be like this:

Much better!

Stay tuned for the next part in the series!

As always, source code included:

None of the shortcomings are show-stoppers as such, and it’s not intended to compete with the major actors out there—yet.

Most of the issues with Oxite are little things like lack of ready-made themes, plug-ins, statistics and the ability to post images and videos to the blog via the metaweblog API, instead requiring the user to mess around with FTP settings.

Despite the shortcomings, I’m quite excited. I’ve already picked it apart and put most of it back together (hence the lack of blog posts the past couple of weeks).

The first thing I did was create my own theme, tweak the styles and add menus and such. This required a whole bunch of CSS coding and some actual C# plumbing.

What struck me as a bit quaint, was that even though you can add your own content pages (applause!), those pages don’t automatically appear in any menus or anything. You actually need to hand-edit the C# code to add links to those pages in the menus.

One thing that I really like about dasBlog, is that it runs without  a relational database engine, such as Microsoft SQL Server, or MySQL. It operates purely on disk-based XML files. That right there just cut off 50% of the hosting fee.

Luckily, Oxite has a lot of extension points. Adding a data provider that is based on XML files instead of Microsoft SQL Server, shouldn’t be too much of a problem.

As I described in a previous post, I’ve been using the Windows 7 beta since it came out. My favorite operating system before that was Windows XP. I never liked Vista. I loved the eye candy and the new features, but I wasn’t willing to trade it for the performance and memory hit it required. Windows 7 truly is everything that Vista should have been.

I’ve been doing everything with and to my Windows 7 installations. I’ve coded and debugged, played games, watched movies, listened to music, installed all kinds of quirky software and utilities, and of course browsed the web. So far, it’s been the best and most solid operating system Microsoft has released since MS DOS 6.22. I mean, it’s difficult to compete with the solidity of MS DOS. After all, there wasn’t a lot in there. No pesky graphics drivers and so on.

I’ve not had a single crash since I first installed it. I’ve only had to reboot a few times after driver updates and I’ve only turned the computer off once (I was on a one week vacation). Other than that, my desktop computer has been running non-stop for almost four months without so much as a hiccup.

My laptop has far more battery life that those of my colleagues (exact same laptops, but with Windows Vista), and boots in one third of the time or less.

So far, after all my code-bashing and system abuse, the only problem I’ve had with Windows 7 is on my laptop, where the wireless adapter fails to recover from hibernation. Not exactly a show-stopper.

Both of my Wacom tablets work perfectly. Without any special drivers, I might add. All the hardware on all my installations is accounted for, except my HP LaserJet 1000 printer. Which is mostly because HP discontinued it years ago and the newest drivers available are for 32 bit Windows XP, and I don’t want to … soil … my 64 bit installation with 32 bit XP drivers, that’s even if I could get them to work in the first place. I couldn’t get them to work in Vista, so I didn’t even bother trying in Windows 7.

I instead export a PDF file to an UNC drop folder, which is then picked up by a little service running on one of my servers where the printer is attached and printed from there.

All in all, I can but tip my hat to Microsoft, for a job very well done!

Until I can confirm/sort this out, I’ve replaced the dasBlog email form with one of my own. I hope this will solve the problem.

Send me an email