Some things you will need to know

calendarId : if you don’t know how to find the google calendar Id start here once you’ve got that, the rest is fairly simple.

Adding the script to a spread sheet :

1. Open your spread sheet in question
2. click Tools
3. click Script Editor
4. Create Blank Project
5. Paste code below into project (over writing existing text)
6. save project (name doesn’t really matter)

Adding the hook for when the form is submitted :

while still in the scripting project window

1. click Resources
2. click All Your Triggers
3. click Add a new trigger
4. select getLatestAndSubmitToCalendar in first drop down
5. select from spread sheet in the second drop down
6. select on form submit in the third drop down
7. click Save

you will likely have to adjust the Id variables below to match which column contains those values in your spread sheet/form, but if all went well, now when you submit an event to your google form associated with your spread sheet, an event will be added to your calendar.

//this is the ID of the calendar to add the event to, this is found on the calendar settings page of the calendar in question
var calendarId = "CALENDAR_ID_HERE";

//below are the column ids of that represents the values used in the spreadsheet (these are non zero indexed)
var startDtId = 4;
var endDtId = 5;
var titleId = 3;
var descId = 2;
var formTimeStampId = 1;

function getLatestAndSubmitToCalendar() {
  var sheet = SpreadsheetApp.getActiveSheet();
  var rows = sheet.getDataRange();
  var numRows = rows.getNumRows();
  var values = rows.getValues();
  var lr = rows.getLastRow();
  var startDt = sheet.getRange(lr,startDtId,1,1).getValue();
  //set to first hour and minute of the day.
  startDt.setHours(0);
  startDt.setMinutes(00);
  var endDt = sheet.getRange(lr,endDtId,1,1).getValue();
  //set endDt to last hour and minute of the day
  endDt.setHours(23);
  endDt.setMinutes(59);
  var subOn = "Submitted on :"+sheet.getRange(lr,formTimeStampId,1,1).getValue();
  var desc = "Added by :"+sheet.getRange(lr,descId,1,1).getValue()+"\n"+subOn;
  var title = sheet.getRange(lr,titleId,1,1).getValue()+" Vacation";
    createEvent(calendarId,title,startDt,endDt,desc);
}​
  
  function createEvent(calendarId,title,startDt,endDt,desc) {
  var cal = CalendarApp.getCalendarById(calendarId);
  var start = new Date(startDt);
  var end = new Date(endDt);
  var loc = 'Script Center';

  var event = cal.createEvent(title, start, end, {
      description : desc,
      location : loc
  });
};

Download: DatabaseUtilities.zip

Lately I’ve been doing a lot of work with SqlCe, its a nice file based database, and works well for the project’s purposes, but there are issues, mounds of them in fact. The purpose of this article however isn’t to go into those problems but to help better deal with the situation when you do encounter a problem.

Often times on the Msdn and other locations on the web, when looking for information on dealing with sqlCeExceptions, you’ll find code very similar to this.

SqlCeConnection conn = new SqlCeConnection("Data Source=nonExistingSource.sdf;");

try
{
    conn.Open();
}
catch (SqlCeException e)
{
    // Use SqlCeException properties if you need specific
    // application logic depending on the error condition
    //
    if (25046 == e.NativeError /*SSCE_M_FILENOTFOUND*/)
    {
        // Error specific logic goes here...
        //
    }

    MessageBox.Show(e.Message);
}

Perhaps this is fine to some, but to do an equality of an error code against a numerical literal is a personal pet peeve of mine, its far to easy to confuse, transpose, and in the future is hard to remember what the literal means, if that error code changes, you have to go through your code and change it.

My solution was to create a helper class out of the information made available
on the Msdn site http://technet.microsoft.com/en-us/library/ms171849 which gives a fair amount of information about these errors.

the Helper contains an Enum of error codes to Token, so the code above could written like

SqlCeConnection conn = new SqlCeConnection("Data Source=nonExistingSource.sdf;");

try
{
    conn.Open();
}
catch (SqlCeException e)
{
    // Use SqlCeException properties if you need specific
    // application logic depending on the error condition
    //
    if (SqlCeErrorDetails.SqlCeNativeErrorNumToToken.SSCE_M_FILENOTFOUND == e.NativeError)
    {
      //error code
    }

    MessageBox.Show(e.Message);
}

the helper also contains a dictionary to get back a object containing detailed information about the error you are having to use it, you do something like the following.

...
catch (SqlCeException ceException)
{
 
if (SqlCeErrorDetails.SqlCeErrorDetailDictionary.ContainsKey((uint)ceException.NativeError))
  {
    SqlCeErrorDetails.SqlCeErrorDetail errorDetail = SqlCeErrorDetails.SqlCeErrorDetailDictionary[(uint)ceException.NativeError];
        //errorDetail exposes the following info
	//errorDetail.Code;
	//errorDetail.Description;
	//errorDetail.ErrorCategory;
	//errorDetail.ErrorToken;
	//errorDetail.NumericParameter;
	//errorDetail.StringParameter;
  }
 else
  {
   //unknown error code
  }
}

This information is a lot more useful when logging, and you can get fairly specific details out of it. Regardless, its useful to me, so I thought I would put it up here.

I would also suggest that if you are going to deal with SqlCe at all, you should really check out http://erikej.blogspot.com/. Erik is super knowledgable on the subject and you will find him to be the source of a lot of sqlce answer on stackoverflow and microsoft forums.

Download: DatabaseUtilities.zip

 TestClass tmpClass = null;

if(/*logic about tmpClass related stuff*/)
{
   if(tmpClass = null)
    {
     tmpClass = new TestClass();
    }
}

(ok, probably not that big a situation, but it does come up, and can get ugly.)
My solution to the situation is this.

public T IfNullObjReturnNewObj<T>(T obj) where T : class, new()
{
	if (obj == null)
	{
		return new T();
	}
	else
	{
		return obj;
	}
}


private class TestClass
{
	public TestClass()  //must have blank constructor
	{
	
	}
}


void Main()
{
	TestClass tmp = null;

	if(tmp == null)
	{
		"Null".Dump();
	}

	tmp = IfNullObjReturnNewObj<TestClass>(tmp);

	if(tmp == null)
	{
		"Null".Dump();
	}
	else
	{
		"Not Null".Dump();
	}
}

Also, you may notice the .Dump() calls, this is from Linq Pad, a wonderful program for prototyping out C# (or vb.net) code, its a wonderful tool, and the intellisense is worth the price of the upgrade.

This allows you to easily validate the values of a class, and skip fields you don’t want validated, this again is quick and dirty example code, and not meant to be directly implemented.
this is largely, based off of dotnetperls.com code example for static classes.

		public bool Validate<T>(T objToValidate, List<string> doNotValidate)
		{
			Type type = typeof(T); // Get type pointer
	
			foreach (var property in type.GetProperties()) // Loop through properties
			{
				string name = property.Name; // Get string name
				object temp = property.GetValue(objToValidate,null); // Get value
				
				if (!doNotValidate.Contains(name))
				{
				/*  Add Validation Logic Here */

					if (temp is int) // See if it is an integer.
					{
						int value = (int)temp;
						//if our int values are null or not greater than 0 config is not valid
						if (value == null || value <= 0)
						{						
							return false;
						}
					}
					else if (temp is string) // See if it is a string.
					{
						string value = temp as string;
						//if the value is null or an empty string config is not valid
						if (String.IsNullOrEmpty(value))
						{						
							return false;
						}

					}
				}
			}			

			return true;
		}
	
	public class IpcPluginConfig
	{
		public int AlarmListIntervalMs { get; set; }
		public int AlarmHistoryIntervalMs { get; set; }
		public int KranProductionIntervalMs { get; set; }
		public int KranFhuererIntervalMs { get; set; }
		public int LastaufnahmeIntervalMs { get; set; }
		public int IpcMachineTimeIntervalMs { get; set; }

		//UNCAccessWithCredentials values
		public string uncPath { get; set; }
		public string uncUserName { get; set; }
		public string uncDomain { get; set; }
		public string uncPassword { get; set; }

		public string IpcConnectionString { get; set; }
		public string IpcProviderName { get; set; }

		public string HtpcConnectionString { get; set; }
		public string HtpcProviderName { get; set; }


	}



void Main()
{
	var tmp = new IpcPluginConfig();
	tmp.AlarmHistoryIntervalMs = 1;
	tmp.AlarmListIntervalMs = 1;
	tmp.HtpcConnectionString = "test";
	tmp.HtpcProviderName = "test";
	tmp.IpcConnectionString = "test";
	tmp.IpcProviderName = "test";
	tmp.KranFhuererIntervalMs = 1;
	tmp.KranProductionIntervalMs = 1;
	tmp.LastaufnahmeIntervalMs = 1;
	tmp.IpcMachineTimeIntervalMs = 1;
	
	var doNotValidate = new List<string>();
	doNotValidate.Add("uncPath");
	doNotValidate.Add("uncUserName");
	doNotValidate.Add("uncDomain");
	doNotValidate.Add("uncPassword");
	
	Validate<IpcPluginConfig>(tmp, doNotValidate);
	
	
	
}

I will rely more on inline code commenting to explain what I post rather than lengthy explanations, this may not be the best method of presenting data, but I do feel it will encourage me to post more, and ultimately share more information I feel is useful to the those that would care to see it.

Preface

Let me first start by saying that I am writing this example after I spent many hours frustrated at the lack of documentation, the abundance of disinformation, and the endless chasing of MSDN dead links. The information contained here is based off many sources all over the net. Though I did not find a single one that clearly laid out how to do it all at once. I will attempt to do that here, in a clear manner; these are the steps that I took to get consistent working results. There may be steps here that are not needed, though I have worked to remove as many of them as time would allow some may have slipped by.

My examples and screen shots will be from
Visual Studio 2005, Standard Edition, Frame work ver. 2.0.5xxx sp2
Web server this example was deployed on was
Windows 2003 Standard running IIS 6.0 / ASP 3.0

The first thing you are going to need to get this project off the ground is a Library DLL. There are a few changes you need to be aware before writing your Library DLL.

Methods should not be static

I am guessing here, due to the fact that asp classic does not support static classes, it stands to reason, it can’t reference one in a DLL library. I attempted a few different was to get this to work and constantly received the following error
“Microsoft VBScript runtime error ’800a01b6′ Object doesn’t support this property or method: ‘myMethod’.”
My advice, save the headache and avoid the static methods, if you are reading this, and know a solution please comment.

Dll must be marked as Com-visible

To make a DLL com-visible, you need to modify the assembly information. There are multiple ways of doing this, the easiest method is to use visual studio, go to your projects properties then click the “Assembly Information” button and check the checkbox at the bottom of the window that says “Make assembly COM-Visible” (as seen below)

you can also do this by hand by manually editing the AssemblyInfo.cs and adding the following code

[assembly: ComVisible(true)]

Lastly, you can make these changes at run time. I don’t suggest doing that, but if you must, googling “Com-visible runtime” will likely bring you to the right place for it, (I’d post a link to the MSDN page, but in my experience it will change in the future and ultimately be useless.) Another important note, you should not confuse this with, “Register for COM interop” in the build section of the projects properties. In fact you need to make sure this option is UNCHECKED as it will cause problems later, I’ll explain more on this in the following steps.

Your Project Should be Signed

Long story short this step, is done mainly to avoid warnings and possible issues of entering your assembly into the GAC (Global Assembly Cache). This step is easily done using the Visual studio IDE, and Googling “signing assemblies” will show many tutorials on how to do this from the command line if you wish to do so. Signing an Assembly will also protect your libaray from being confused or replaced by other assemblies by mistake, or through nefarious means.

Building the Installer

Now that you have got the prep work done and your code written, you will need to get your library on to your web server, once again this can be done by hand through various command line methods. But the easiest and most convent way for the developer, and web server management is to do this via a setup project, using the installer will add an easy way to add and remove your library to the server. To do this you need to create a new setup project.

Once you have your setup project added to your library solution,

1. Click on the setup project in the solution explorer window, you should now see a new set of icons for this type of project
2. The second icon is for the “File System Editor” click this and it will bring up a new window for “File System on Target Machine“
3. Right click in the left hand side of the window and select “Add Special Folder” select “Global Assembly Cache Folder.”
4. Single Click the “Global Assembly Cache Folder.” once highlighted, right click on it and select “Add, the select “Product output“
5. In the popup window select “Primary Output“

See screen shot below


At this point, you should be ready to build the project and produce your installer, the setup MSI and setup.exe should be in the setup projects Release or Debug folder depending on the option you chose during build time.

Note:
If you are have a .tlb file being placed in your CAG folder along with your primary output, this is a result of having “Register for COM interop” checked in your coding projects build options, to resolve this, either uncheck the box in the build options, or add a “ExcludeFilter” for *.tlb in your installer project.

Installing

Copy the Msi and setup.exe over to your web server and install your Library, this should be done from an administrator account. Assuming all went well in your install process you should check the GAC,Typically (c:\windows\assembly) to make sure your library is registered. while here you will need to gather a bit of information so that we can reference the library in our asp.net website. you are going to need the
Name:
Culture:
Version:
Public Key Token:
You can do this by right clicking on your assembly and going to properties.

Using the Code

Once you have this information, you are ready to start using your library on your site, first we will cover using the code in asp.net(c#). The first thing we need to do, is to add the assembly to your web.config for your site. To do this, add the following code to your web.config
(you shouldn’t need to add the system.web its there to show placement)

<system.web>
  <compilation>	
    <assemblies>
      <add assembly="MyAssembly, Version=1.0.0.1, Culture=neutral,PublicKeyToken=8c7fff0114cec090" />
    </assemblies>
  </compilation>
</system.web>

Once you have the assembly information added to your web.config, you can use the assembly like any other referenced library. Here is an Example

public partial class _Default : System.Web.UI.Page 
{
    protected void Page_Load(object sender, EventArgs e)
    {
     MyAssembly.Crypto tmpExample = new MyAssembly.Crypto();

     string phrase = "test";
     string crypted = tmpExample.Encrypting(phrase);     
     string decrypted = tmpExample.Decrypting(crypted);

     Response.Write("Test phrase " + phrase+"<br>");
     Response.Write("encrypted " + crypted + "<br>");
     Response.Write("decypted " + decrypted + "<br>");
    }
}

Since you have made the Library available system wide, and made it com-visible, you won’t have to do
anything to make it visible to asp classic, other than adding it to the code itself. Here is an example of how to use the Library in asp classic (vbscript)

Dim tmpExample 
Set tmpExample = Server.CreateObject("MyAssembly.Crypto")

phrase = "test"
crypted = tmpExample.Encrypting(phrase)     
decrypted = tmpExample.Decrypting(crypted)

Response.Write("Test phrase " + phrase+"<br>")
Response.Write("encrypted " + crypted + "<br>")
Response.Write("decypted " + decrypted + "<br>")

Conclusion

I have tried to be as detailed as possible without being to verbose, but it is possible some details may have slipped past me. So if I have made a mistake, feel free to leave a comment, and I will work hard to resolve the issue. Also, I have found other partial examples on the net that suggest doing the same thing, but in different ways. Some of these examples turned out to be either unnecessary, or completely wrong. What I have posted here is the a method I have found to be the fastest, easiest, and most reliable way of sharing the library DLL between asp.net and asp classic via COM.

Another possible use for this method is context based captcha, so say for example you presented your user with the following picture

What show am I on?

<?php
$cc_hashtable["star trek"] = "img/sjirlzqoaopd.jpg";
$cc_hashtable["startrek"] = "img/sjirlzqoaopd.jpg";
$cc_hashtable["star trek: TOS"] = "img/sjirlzqoaopd.jpg";
$cc_hashtable["old star trek"] = "img/sjirlzqoaopd.jpg";
...
?> 

There are limitations to this method, such as language issues, for example, due to my poor choice in question construction if someone from German came across my form they may enter “Raumschiff Enterprise” which is correct to them, but would not work for your site. So be aware of that, it is best to come up with single answer questions, and localization may require a hash for each language.

With all that said, the first thing you will need to do is to gain access to images that contain captcha data, the easiest way to do this, is to find a site that can dynamically generate captcha images and copy and image from there, and refresh and repeat till you have built up enough images to meet your needs, the more images, the more the system will seem dynamic, and decrease the chances of your method being found out. Once you have your images, you want to add them to the cc_hash.php, you also want to load the captcha phrase from each image as its key in the hash table.

The second thing is to integrate the code into your form, the functions are set up in such away placing the following function calls in your form will generate two new fields in your form variables

adds the captcha image to the form.

<?=cc_form_image($cc_hashtable)?>

adds the input field for the captcha to the form

<?=cc_form_text_field()?>

try it out for yourself

Cheap Check Example

continue reading for the code examples.

Each of the images in the hash, should contain the phrase that is used as its key, so that if a user’s randomly loaded captcha image is the file “ptytfyiwonsq.jpg” his correct challenge input would be rwet
I separate this file from the rest, because it is likely that I would use a database to populate $cc_hashtable, but have not for this example.

<?php
$cc_hashtable['wert'] = "img/sjirlzqoaopd.jpg";
$cc_hashtable['rwet'] = "img/ptytfyiwonsq.jpg";
$cc_hashtable['bars'] = "img/rmglpqghaozm.jpg";
?>

This is the core file of the script, it contains the configuration, as well as the 3 primary functions used to make this method work

<?php
/*#######################################################################
this program is designed to recreate the dynamic images on many contact 
forms used to prevent automated emailers from spamming via contact forms.
#######################################################################*/

/*Config*/
$GLOBALS['cc_error'] = "";
$GLOBALS['cc_form_text_field_name'] = "cc_contacttext";
$GLOBALS['cc_form_image_name'] = "cc_contactimage";
 /*if they enter a key that exist but not the correct one*/
$GLOBALS['cc_error_match_fail'] = "Input does not match current image";
/*if they enter completely incorrect input*/
$GLOBALS['cc_error_invalid_input'] = $GLOBALS['cc_error_match_fail'];  

/*file containing hash of images and phrases*/
require "cc_hash.php";

/*#######################################################################
######################Do not edit below#######################################
#######################################################################*/

function cc_parser($cc_posted_image,$cc_posted_text,$cc_hashtable)
{
 if(array_key_exists($cc_posted_text,$cc_hashtable))
  {
   if($cc_hashtable[$cc_posted_text] == $cc_posted_image)
    {
	 return true;
	}
  else
   {
    $GLOBALS['cc_error'] = $GLOBALS['cc_error_match_fail'];
    return false;
   }	  
  }
 else
  {
  $GLOBALS['cc_error'] = $GLOBALS['cc_error_invalid_input'];
   return false;
  } 
}

function cc_form_image($cc_hashtable)
{
 $foo = $cc_hashtable[array_rand($cc_hashtable)];
 return "<img src="".$foo."">";
}

function cc_form_text_field()
{
 return "";
}

?>

Below is an example of how one can deploy the script

<?php
require "cc_functions.php";

function print_form($cc_hashtable)
{
?>


<?=cc_form_image($cc_hashtable)?>


<?=cc_form_text_field()?>


<?

}


if($_POST)
{
	if(cc_parser($_POST['cc_contactimage'],$_POST['cc_contacttext'],$cc_hashtable))
	 {
	  //process form 
	  echo "Success";
	 }
	else
	 {
	 	echo "Image verification failed ";
		print_form($cc_hashtable);
	 }
}
else
 {
  print_form($cc_hashtable);
 }
?>

(the cc_ prefix used in the code stands for “cheap check” and is used to reduce the likelihood of conflicting function names.)