public bool Import(string sUserID, string sTaskIDs, ref string sErr)
{
string sSQL = "";
dataAccess.acTransaction oTrans = new dataAccess.acTransaction(ref sErr);
//we're doing this in a loop
//why? because each row may have different import requirements
//(overwrite, new version, etc.)
//Now we are adding different import types not necessarily tied to task/proc.
//for now we're still just doing it all here until there's a good reason to split it out
if (sTaskIDs.Length > 0)
{
sSQL = "select task_id, task_code, task_name, import_mode from import_task" +
" where user_id = '" + sUserID + "'" +
" and task_id in (" + sTaskIDs + ")";
DataTable dt = new DataTable();
if (!dc.sqlGetDataTable(ref dt, sSQL, ref sErr))
{
throw new Exception(sErr);
}
if (dt.Rows.Count > 0)
{
foreach (DataRow dr in dt.Rows)
{
string sTaskID = dr["task_id"].ToString();
string sNewTaskID = dr["task_id"].ToString();
string sTaskCode = dr["task_code"].ToString();
string sImportMode = dr["import_mode"].ToString();
string sOTID = "";
int iCount = 0;
switch (sImportMode)
{
case "New":
//just jam in the new row, IF there are no GUID conflicts.
//~~~ NEW tasks get manipulated.
//* MIGHT have their ID changed if there's a collision
//* WILL have the original_task_id reset
//* WILL have the version reset to 1.000
//* WILL be loaded as 'Development' status
//* WILL be the default version
//check ID
oTrans.Command.CommandText = "select count(*) from task" +
" where task_id = '" + sTaskID + "'";
if (!oTrans.ExecGetSingleInteger(ref iCount, ref sErr))
{
throw new Exception("Unable to check for GUID conflicts.<br />" + sErr);
}
//if there's a GUID conflict then just generate a new guid for this task.
if (iCount > 0)
{
sNewTaskID = ui.NewGUID();
}
//check the steps to see if there are any GUID conflicts
//and repair them if necessary
if (!ReIDSteps(ref oTrans, sUserID, sTaskID, ref sErr))
{
throw new Exception("Unable to issue new Step GUIDs.<br />" + sErr);
}
//insert the manipulated TASK
oTrans.Command.CommandText = "insert into task" +
" (task_id, original_task_id, version," +
" task_name, task_code, task_desc, task_status," +
" use_connector_system, default_version," +
" concurrent_instances, queue_depth, parameter_xml, created_dt)" +
" select" +
" '" + sNewTaskID + "', '" + sNewTaskID + "', 1.000," +
" task_name, task_code, task_desc, 'Development'," +
" use_connector_system, 1," +
" concurrent_instances, queue_depth, parameter_xml, created_dt" +
" from import_task" +
" where user_id = '" + sUserID + "'" +
" and task_id = '" + sTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
{
throw new Exception(sErr);
}
ui.WriteObjectAddLog(Globals.acObjectTypes.Task, sNewTaskID, dr["task_code"].ToString() + " - " + dr["task_name"].ToString(), "New - Created via Import");
break;
case "New Version":
//if it's a new version, we need to make sure the "original_task_id"
//is correct in the target database.
//(no guarantee the original_id in the source db is correct.)
//just jam in the new row, IF there are no GUID conflicts.
//~~~ NEW VERSION tasks get manipulated.
//* MIGHT have their ID changed if there's a collision
//* MIGHT have the original_task_id reset (to match the target)
//* WILL have the version reset to the user selection
//* WILL be loaded as 'Development' status
//* WILL NOT be the default version
//check ID
oTrans.Command.CommandText = "select count(*) from task" +
" where task_id = '" + sTaskID + "'";
if (!oTrans.ExecGetSingleInteger(ref iCount, ref sErr))
{
throw new Exception("Unable to check for GUID conflicts.<br />" + sErr);
}
//if there's a GUID conflict then just generate a new guid for this task.
//and re-id the steps
if (iCount > 0)
{
sNewTaskID = ui.NewGUID();
}
//check the steps to see if there are any GUID conflicts
//and repair them if necessary
if (!ReIDSteps(ref oTrans, sUserID, sTaskID, ref sErr))
{
throw new Exception("Unable to issue new Step GUIDs.<br />" + sErr);
}
//NOW, we need to make sure this task is connected to it's family
//we do this by ensuring the original_task_id matches.
//BUT, we got here by assuming the task_code was the key.
//so... find the original_task_id for this task_code
oTrans.Command.CommandText = "select original_task_id" +
" from task where task_code = '" + sTaskCode + "' limit 1";
if (!oTrans.ExecGetSingleString(ref sOTID, ref sErr))
{
throw new Exception("Unable to get original task ID for [" + sTaskCode + "].<br />" + sErr);
}
//insert the manipulated TASK
oTrans.Command.CommandText = "insert into task" +
" (task_id, original_task_id, version," +
" task_name, task_code, task_desc, task_status," +
" use_connector_system, default_version," +
" concurrent_instances, queue_depth, parameter_xml, created_dt)" +
" select" +
" '" + sNewTaskID + "', '" + sOTID + "', version," +
" task_name, task_code, task_desc, 'Development'," +
" use_connector_system, 0," +
" concurrent_instances, queue_depth, parameter_xml, created_dt" +
" from import_task" +
" where user_id = '" + sUserID + "'" +
" and task_id = '" + sTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
{
throw new Exception(sErr);
}
ui.WriteObjectAddLog(Globals.acObjectTypes.Task, sNewTaskID, dr["task_code"].ToString() + " - " + dr["task_name"].ToString(), "New Version - Created via Import");
break;
/*
* Note: I stopped here because I'm not convinced that "Overwrite" is a safe or useful
* feature.
*
* So, we'll come back to it if needed.
*
* Be aware, this was pseudocode... it never worked, was just placeholder stuff and ideas.
*/
//case "Overwrite":
// //stomp it, but make sure to set the task_id/original_task_id
// //to match in the target db.
// //just because the code matches doesn't mean the ID's do.
// //we can just UPDATE the task row
// //DON'T FORGET to DELETE the existing steps and codeblocks
// //we need to make sure the "original_task_id"
// //is correct in the target database.
// //(no guarantee the original_id in the source db is correct.)
// //~~~ OVERWRITE tasks get manipulated.
// //* MIGHT have their ID changed to match the code/version being imported
// //* MIGHT have the original_task_id reset (to match the target)
// //* WILL have the version reset to the user selection
// //* WILL be loaded as 'Development' status
// //* MIGHT be the default version (not gonna update that value)
// //NOW, we need to make sure this task is connected to it's family
// //we do this by ensuring the original_task_id matches.
// //BUT, we got here by assuming the task_code was the key.
// //so... find the task AND original_task_id for this task_code
// oTrans.Command.CommandText = "select top 1 task_id" +
// " from task where task_code = '" + sTaskCode + "'";
// if (!oTrans.ExecGetSingleString(ref sNewTaskID, ref sErr))
// throw new Exception("Unable to get task ID for [" + sTaskCode + "].<br />" + sErr);
// oTrans.Command.CommandText = "select top 1 original_task_id" +
// " from task where task_code = '" + sTaskCode + "'";
// if (!oTrans.ExecGetSingleString(ref sOTID, ref sErr))
// throw new Exception("Unable to get original task ID for [" + sTaskCode + "].<br />" + sErr);
// //get a datareader on the import_task row
// sSQL = "select task_desc, manual_or_digital, use_connector_system," +
// " concurrent_instances, queue_depth, parameter_xml, created_dt" +
// " from import_task" +
// " where user_id = '" + sUserID + "'" +
// " and task_id = '" + sTaskID + "'";
// OdbcDataReader drTaskRow = null;
// if (!dc.sqlGetDataReader(ref drTaskRow, sSQL, ref sErr)) return false;
// if (drTaskRow.HasRows)
// {
// //insert the manipulated TASK
// //THIS WAS NEVER TESTED
// oTrans.Command.CommandText = "update task" +
// " set task_desc = ''," +
// " manual_or_digital = ''," +
// " use_connector_system = ''," +
// " concurrent_instances = ''," +
// " queue_depth = ''," +
// " parameter_xml = ''," +
// " created_dt = ''" +
// " select" +
// " '" + sNewTaskID + "', '" + sOTID + "', version," +
// " task_name, task_code, task_desc, 'Development', manual_or_digital," +
// " use_connector_system, 0," +
// " concurrent_instances, queue_depth, parameter_xml, created_dt" +
// " from import_task" +
// " where user_id = '" + sUserID + "'" +
// " and task_id = '" + sTaskID + "'";
// if (!oTrans.ExecUpdate(ref sErr))
// throw new Exception(sErr);
// }
// ui.WriteObjectAddLog(Globals.acObjectTypes.Task, sNewTaskID, dr["task_code"].ToString() + " - " + dr["task_name"].ToString(), "Overwritten by Import");
// break;
default:
break;
}
//CODEBLOCKS AND STEPS can be done here... they are just inserted
// (because they were manipulated already if needed)
//CODEBLOCKS
oTrans.Command.CommandText = "insert into task_codeblock" +
" (task_id, codeblock_name)" +
" select" +
" '" + sNewTaskID + "', codeblock_name" +
" from import_task_codeblock" +
" where user_id = '" + sUserID + "'" +
" and task_id = '" + sTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
{
throw new Exception(sErr);
}
//STEPS
oTrans.Command.CommandText = "insert into task_step" +
" (step_id, task_id, codeblock_name, step_order, commented," +
" locked, function_name, function_xml, step_desc, output_parse_type," +
" output_row_delimiter, output_column_delimiter, variable_xml)" +
" select" +
" step_id, '" + sNewTaskID + "', codeblock_name, step_order, commented," +
" locked, function_name, function_xml, step_desc, output_parse_type," +
" output_row_delimiter, output_column_delimiter, variable_xml" +
" from import_task_step" +
" where user_id = '" + sUserID + "'" +
" and task_id = '" + sTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
{
throw new Exception(sErr);
}
}
}
else
{
sErr = "No Task import items were found.";
oTrans.RollBack();
return(false);
}
//whack those rows from the import table.
//why? their disposition has now changed, and we don't wanna accidentally reload them.
//or add confusion to the user.
oTrans.Command.CommandText = "delete from import_task where user_id = '" + sUserID + "' and task_id in (" + sTaskIDs + ")";
if (!oTrans.ExecUpdate(ref sErr))
{
throw new Exception(sErr);
}
oTrans.Command.CommandText = "delete from import_task_codeblock where user_id = '" + sUserID + "' and task_id in (" + sTaskIDs + ")";
if (!oTrans.ExecUpdate(ref sErr))
{
throw new Exception(sErr);
}
oTrans.Command.CommandText = "delete from import_task_step where user_id = '" + sUserID + "' and task_id in (" + sTaskIDs + ")";
if (!oTrans.ExecUpdate(ref sErr))
{
throw new Exception(sErr);
}
}
//all done with everything... close it out
oTrans.Commit();
return(true);
}
private string CopyTask(int iMode, string sSourceTaskID, string sNewTaskName, string sNewTaskCode)
{
//iMode 0=new task, 1=new major version, 2=new minor version
dataAccess dc = new dataAccess();
acUI.acUI ui = new acUI.acUI();
string sErr = "";
string sSQL = "";
string sNewTaskID = ui.NewGUID();
int iIsDefault = 0;
string sTaskName = "";
double dVersion = 1.000;
double dMaxVer = 0.000;
string sOTID = "";
//do it all in a transaction
dataAccess.acTransaction oTrans = new dataAccess.acTransaction(ref sErr);
//figure out the new name and selected version
oTrans.Command.CommandText = "select task_name, version, original_task_id from task where task_id = '" + sSourceTaskID + "'";
DataRow dr = null;
if (!oTrans.ExecGetDataRow(ref dr, ref sErr))
throw new Exception("Unable to find task for ID [" + sSourceTaskID + "]." + sErr);
sTaskName = dr["task_name"].ToString();
dVersion = Convert.ToDouble(dr["version"]);
sOTID = dr["original_task_id"].ToString();
//figure out the new version
switch (iMode)
{
case 0:
sTaskName = sNewTaskName;
iIsDefault = 1;
dVersion = 1.000;
sOTID = sNewTaskID;
break;
case 1:
//gotta get the highest version
sSQL = "select max(version) from task where task_id = '" + sOTID + "'";
dc.sqlGetSingleDouble(ref dMaxVer, sSQL, ref sErr);
if (sErr != "")
{
oTrans.RollBack();
throw new Exception(sErr);
}
dVersion = dMaxVer + 1;
break;
case 2:
sSQL = "select max(version) from task where task_id = '" + sOTID + "'" +
" and cast(version as unsigned) = " + Convert.ToInt32(dVersion);
dc.sqlGetSingleDouble(ref dMaxVer, sSQL, ref sErr);
if (sErr != "")
{
oTrans.RollBack();
throw new Exception(sErr);
}
dVersion = dMaxVer + 0.001;
break;
default: //a iMode is required
throw new Exception("A mode required for this copy operation." + sErr);
}
//if we are versioning, AND there are not yet any 'Approved' versions,
//we set this new version to be the default
//(that way it's the one that you get taken to when you pick it from a list)
if (iMode > 0)
{
sSQL = "select case when count(*) = 0 then 1 else 0 end" +
" from task where original_task_id = '" + sOTID + "'" +
" and task_status = 'Approved'";
dc.sqlGetSingleInteger(ref iIsDefault, sSQL, ref sErr);
if (sErr != "")
{
oTrans.RollBack();
throw new Exception(sErr);
}
}
//start copying
oTrans.Command.CommandText = "create temporary table _copy_task" +
" select * from task where task_id = '" + sSourceTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//update the task_id
oTrans.Command.CommandText = "update _copy_task set" +
" task_id = '" + sNewTaskID + "'," +
" original_task_id = '" + sOTID + "'," +
" version = '" + dVersion + "'," +
" task_name = '" + sTaskName + "'," +
" default_version = " + iIsDefault.ToString() + "," +
" task_status = 'Development'," +
" created_dt = now()";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//update the task_code if necessary
if (iMode == 0)
{
oTrans.Command.CommandText = "update _copy_task set task_code = '" + sNewTaskCode + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
}
//codeblocks
oTrans.Command.CommandText = "create temporary table _copy_task_codeblock" +
" select '" + sNewTaskID + "' as task_id, codeblock_name" +
" from task_codeblock where task_id = '" + sSourceTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//USING TEMPORARY TABLES... need a place to hold step ids while we manipulate them
oTrans.Command.CommandText = "create temporary table _step_ids" +
" select distinct step_id, uuid() as newstep_id" +
" from task_step where task_id = '" + sSourceTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//steps temp table
oTrans.Command.CommandText = "create temporary table _copy_task_step" +
" select step_id, '" + sNewTaskID + "' as task_id, codeblock_name, step_order, commented," +
" locked, function_name, function_xml, step_desc, output_parse_type, output_row_delimiter," +
" output_column_delimiter, variable_xml" +
" from task_step where task_id = '" + sSourceTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//update the step id
oTrans.Command.CommandText = "update _copy_task_step a, _step_ids b" +
" set a.step_id = b.newstep_id" +
" where a.step_id = b.step_id";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//update steps with codeblocks that reference a step (embedded steps)
oTrans.Command.CommandText = "update _copy_task_step a, _step_ids b" +
" set a.codeblock_name = b.newstep_id" +
" where b.step_id = a.codeblock_name";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//spin the steps and update any embedded step id's in the commands
oTrans.Command.CommandText = "select step_id, newstep_id from _step_ids";
DataTable dtStepIDs = new DataTable();
if (!oTrans.ExecGetDataTable(ref dtStepIDs, ref sErr))
throw new Exception("Unable to get step ids." + sErr);
foreach (DataRow drStepIDs in dtStepIDs.Rows)
{
oTrans.Command.CommandText = "update _copy_task_step" +
" set function_xml = replace(lower(function_xml), '" + drStepIDs["step_id"].ToString().ToLower() + "', '" + drStepIDs["newstep_id"].ToString() + "')" +
" where function_name in ('if','loop','exists')";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
}
//finally, put the temp steps table in the real steps table
oTrans.Command.CommandText = "insert into task select * from _copy_task";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
oTrans.Command.CommandText = "insert into task_codeblock select * from _copy_task_codeblock";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
oTrans.Command.CommandText = "insert into task_step select * from _copy_task_step";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//finally, if we versioned up and we set this one as the new default_version,
//we need to unset the other row
if (iMode > 0 && iIsDefault == 1)
{
oTrans.Command.CommandText = "update task" +
" set default_version = 0" +
" where original_task_id = '" + sOTID + "'" +
" and task_id <> '" + sNewTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
}
oTrans.Commit();
return sNewTaskID;
}
public bool Import(string sUserID, string sTaskIDs, ref string sErr)
{
string sSQL = "";
dataAccess.acTransaction oTrans = new dataAccess.acTransaction(ref sErr);
//we're doing this in a loop
//why? because each row may have different import requirements
//(overwrite, new version, etc.)
//Now we are adding different import types not necessarily tied to task/proc.
//for now we're still just doing it all here until there's a good reason to split it out
if (sTaskIDs.Length > 0)
{
sSQL = "select task_id, task_code, task_name, import_mode from import_task" +
" where user_id = '" + sUserID + "'" +
" and task_id in (" + sTaskIDs + ")";
DataTable dt = new DataTable();
if (!dc.sqlGetDataTable(ref dt, sSQL, ref sErr))
throw new Exception(sErr);
if (dt.Rows.Count > 0)
{
foreach (DataRow dr in dt.Rows)
{
string sTaskID = dr["task_id"].ToString();
string sNewTaskID = dr["task_id"].ToString();
string sTaskCode = dr["task_code"].ToString();
string sImportMode = dr["import_mode"].ToString();
string sOTID = "";
int iCount = 0;
switch (sImportMode)
{
case "New":
//just jam in the new row, IF there are no GUID conflicts.
//~~~ NEW tasks get manipulated.
//* MIGHT have their ID changed if there's a collision
//* WILL have the original_task_id reset
//* WILL have the version reset to 1.000
//* WILL be loaded as 'Development' status
//* WILL be the default version
//check ID
oTrans.Command.CommandText = "select count(*) from task" +
" where task_id = '" + sTaskID + "'";
if (!oTrans.ExecGetSingleInteger(ref iCount, ref sErr))
throw new Exception("Unable to check for GUID conflicts.<br />" + sErr);
//if there's a GUID conflict then just generate a new guid for this task.
if (iCount > 0)
{
sNewTaskID = ui.NewGUID();
}
//check the steps to see if there are any GUID conflicts
//and repair them if necessary
if (!ReIDSteps(ref oTrans, sUserID, sTaskID, ref sErr))
throw new Exception("Unable to issue new Step GUIDs.<br />" + sErr);
//insert the manipulated TASK
oTrans.Command.CommandText = "insert into task" +
" (task_id, original_task_id, version," +
" task_name, task_code, task_desc, task_status," +
" use_connector_system, default_version," +
" concurrent_instances, queue_depth, parameter_xml, created_dt)" +
" select" +
" '" + sNewTaskID + "', '" + sNewTaskID + "', 1.000," +
" task_name, task_code, task_desc, 'Development'," +
" use_connector_system, 1," +
" concurrent_instances, queue_depth, parameter_xml, created_dt" +
" from import_task" +
" where user_id = '" + sUserID + "'" +
" and task_id = '" + sTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
ui.WriteObjectAddLog(Globals.acObjectTypes.Task, sNewTaskID, dr["task_code"].ToString() + " - " + dr["task_name"].ToString(), "New - Created via Import");
break;
case "New Version":
//if it's a new version, we need to make sure the "original_task_id"
//is correct in the target database.
//(no guarantee the original_id in the source db is correct.)
//just jam in the new row, IF there are no GUID conflicts.
//~~~ NEW VERSION tasks get manipulated.
//* MIGHT have their ID changed if there's a collision
//* MIGHT have the original_task_id reset (to match the target)
//* WILL have the version reset to the user selection
//* WILL be loaded as 'Development' status
//* WILL NOT be the default version
//check ID
oTrans.Command.CommandText = "select count(*) from task" +
" where task_id = '" + sTaskID + "'";
if (!oTrans.ExecGetSingleInteger(ref iCount, ref sErr))
throw new Exception("Unable to check for GUID conflicts.<br />" + sErr);
//if there's a GUID conflict then just generate a new guid for this task.
//and re-id the steps
if (iCount > 0)
sNewTaskID = ui.NewGUID();
//check the steps to see if there are any GUID conflicts
//and repair them if necessary
if (!ReIDSteps(ref oTrans, sUserID, sTaskID, ref sErr))
throw new Exception("Unable to issue new Step GUIDs.<br />" + sErr);
//NOW, we need to make sure this task is connected to it's family
//we do this by ensuring the original_task_id matches.
//BUT, we got here by assuming the task_code was the key.
//so... find the original_task_id for this task_code
oTrans.Command.CommandText = "select original_task_id" +
" from task where task_code = '" + sTaskCode + "' limit 1";
if (!oTrans.ExecGetSingleString(ref sOTID, ref sErr))
throw new Exception("Unable to get original task ID for [" + sTaskCode + "].<br />" + sErr);
//insert the manipulated TASK
oTrans.Command.CommandText = "insert into task" +
" (task_id, original_task_id, version," +
" task_name, task_code, task_desc, task_status," +
" use_connector_system, default_version," +
" concurrent_instances, queue_depth, parameter_xml, created_dt)" +
" select" +
" '" + sNewTaskID + "', '" + sOTID + "', version," +
" task_name, task_code, task_desc, 'Development'," +
" use_connector_system, 0," +
" concurrent_instances, queue_depth, parameter_xml, created_dt" +
" from import_task" +
" where user_id = '" + sUserID + "'" +
" and task_id = '" + sTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
ui.WriteObjectAddLog(Globals.acObjectTypes.Task, sNewTaskID, dr["task_code"].ToString() + " - " + dr["task_name"].ToString(), "New Version - Created via Import");
break;
/*
Note: I stopped here because I'm not convinced that "Overwrite" is a safe or useful
feature.
So, we'll come back to it if needed.
Be aware, this was pseudocode... it never worked, was just placeholder stuff and ideas.
*/
//case "Overwrite":
// //stomp it, but make sure to set the task_id/original_task_id
// //to match in the target db.
// //just because the code matches doesn't mean the ID's do.
// //we can just UPDATE the task row
// //DON'T FORGET to DELETE the existing steps and codeblocks
// //we need to make sure the "original_task_id"
// //is correct in the target database.
// //(no guarantee the original_id in the source db is correct.)
// //~~~ OVERWRITE tasks get manipulated.
// //* MIGHT have their ID changed to match the code/version being imported
// //* MIGHT have the original_task_id reset (to match the target)
// //* WILL have the version reset to the user selection
// //* WILL be loaded as 'Development' status
// //* MIGHT be the default version (not gonna update that value)
// //NOW, we need to make sure this task is connected to it's family
// //we do this by ensuring the original_task_id matches.
// //BUT, we got here by assuming the task_code was the key.
// //so... find the task AND original_task_id for this task_code
// oTrans.Command.CommandText = "select top 1 task_id" +
// " from task where task_code = '" + sTaskCode + "'";
// if (!oTrans.ExecGetSingleString(ref sNewTaskID, ref sErr))
// throw new Exception("Unable to get task ID for [" + sTaskCode + "].<br />" + sErr);
// oTrans.Command.CommandText = "select top 1 original_task_id" +
// " from task where task_code = '" + sTaskCode + "'";
// if (!oTrans.ExecGetSingleString(ref sOTID, ref sErr))
// throw new Exception("Unable to get original task ID for [" + sTaskCode + "].<br />" + sErr);
// //get a datareader on the import_task row
// sSQL = "select task_desc, manual_or_digital, use_connector_system," +
// " concurrent_instances, queue_depth, parameter_xml, created_dt" +
// " from import_task" +
// " where user_id = '" + sUserID + "'" +
// " and task_id = '" + sTaskID + "'";
// OdbcDataReader drTaskRow = null;
// if (!dc.sqlGetDataReader(ref drTaskRow, sSQL, ref sErr)) return false;
// if (drTaskRow.HasRows)
// {
// //insert the manipulated TASK
// //THIS WAS NEVER TESTED
// oTrans.Command.CommandText = "update task" +
// " set task_desc = ''," +
// " manual_or_digital = ''," +
// " use_connector_system = ''," +
// " concurrent_instances = ''," +
// " queue_depth = ''," +
// " parameter_xml = ''," +
// " created_dt = ''" +
// " select" +
// " '" + sNewTaskID + "', '" + sOTID + "', version," +
// " task_name, task_code, task_desc, 'Development', manual_or_digital," +
// " use_connector_system, 0," +
// " concurrent_instances, queue_depth, parameter_xml, created_dt" +
// " from import_task" +
// " where user_id = '" + sUserID + "'" +
// " and task_id = '" + sTaskID + "'";
// if (!oTrans.ExecUpdate(ref sErr))
// throw new Exception(sErr);
// }
// ui.WriteObjectAddLog(Globals.acObjectTypes.Task, sNewTaskID, dr["task_code"].ToString() + " - " + dr["task_name"].ToString(), "Overwritten by Import");
// break;
default:
break;
}
//CODEBLOCKS AND STEPS can be done here... they are just inserted
// (because they were manipulated already if needed)
//CODEBLOCKS
oTrans.Command.CommandText = "insert into task_codeblock" +
" (task_id, codeblock_name)" +
" select" +
" '" + sNewTaskID + "', codeblock_name" +
" from import_task_codeblock" +
" where user_id = '" + sUserID + "'" +
" and task_id = '" + sTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
//STEPS
oTrans.Command.CommandText = "insert into task_step" +
" (step_id, task_id, codeblock_name, step_order, commented," +
" locked, function_name, function_xml, step_desc, output_parse_type," +
" output_row_delimiter, output_column_delimiter, variable_xml)" +
" select" +
" step_id, '" + sNewTaskID + "', codeblock_name, step_order, commented," +
" locked, function_name, function_xml, step_desc, output_parse_type," +
" output_row_delimiter, output_column_delimiter, variable_xml" +
" from import_task_step" +
" where user_id = '" + sUserID + "'" +
" and task_id = '" + sTaskID + "'";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
}
}
else
{
sErr = "No Task import items were found.";
oTrans.RollBack();
return false;
}
//whack those rows from the import table.
//why? their disposition has now changed, and we don't wanna accidentally reload them.
//or add confusion to the user.
oTrans.Command.CommandText = "delete from import_task where user_id = '" + sUserID + "' and task_id in (" + sTaskIDs + ")";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
oTrans.Command.CommandText = "delete from import_task_codeblock where user_id = '" + sUserID + "' and task_id in (" + sTaskIDs + ")";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
oTrans.Command.CommandText = "delete from import_task_step where user_id = '" + sUserID + "' and task_id in (" + sTaskIDs + ")";
if (!oTrans.ExecUpdate(ref sErr))
throw new Exception(sErr);
}
//all done with everything... close it out
oTrans.Commit();
return true;
}