public static void CreateActivityLibraryAndStoreActivities(out CWF.DataContracts.ActivityLibraryDC activityLibraryDC, out List<CWF.DataContracts.StoreActivitiesDC> storeActivityDC)
{
//// Setup the base request objects in request
List<CWF.DataContracts.StoreActivitiesDC> storeActivityRequest = new List<CWF.DataContracts.StoreActivitiesDC>();
CWF.DataContracts.ActivityLibraryDC alDC = new CWF.DataContracts.ActivityLibraryDC();
CWF.DataContracts.StoreActivitiesDC saDC = new CWF.DataContracts.StoreActivitiesDC();
//// population the request object
//// create activity library entry
alDC.Incaller = INCALLER;
alDC.IncallerVersion = INCALLERVERSION;
alDC.Guid = Guid.NewGuid();
alDC.Name = "TEST#421A";
alDC.AuthGroupName = "pqocwfauthors";
alDC.CategoryName = "OAS Basic Controls";
alDC.Category = Guid.Empty;
alDC.Executable = new byte[4];
alDC.HasActivities = true;
alDC.ImportedBy = "REDMOND\v-stska";
alDC.Description = "TEST#421A DESCRIPTION";
alDC.InsertedByUserAlias = "v-stska";
alDC.VersionNumber = "1.0.0.8";
alDC.Status = 1;
alDC.StatusName = "Private";
alDC.UpdatedByUserAlias = "REDMOND\v-stska1";
//// Create store activity entries
storeActivityRequest.Add(CreateSA("TEST#300", "1.1.0.0", new Guid(), alDC.Name, alDC.VersionNumber));
activityLibraryDC = alDC;
storeActivityDC = storeActivityRequest;
}
/// <summary>
/// gets all StoreActivities rows that are of template type and not marked softdelete
/// </summary>
/// <param name="request">RequestHeader object</param>
/// <param name="categoryType">categoryType string</param>
/// <returns>List of StoreActivitiesDC type</returns>
public static StatusReplyDC CheckActivityExists(StoreActivitiesDC request)
{
var reply = new StatusReplyDC();
Database db = null;
DbCommand cmd = null;
string outErrorString = string.Empty;
int retValue = 0;
try
{
db = DatabaseFactory.CreateDatabase();
cmd = db.GetStoredProcCommand(StoredProcNames.ActivityCheckExists);
db.AddParameter(cmd, "@InName", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.Name);
db.AddParameter(cmd, "@InVersion", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.Version);
reply.Output = Convert.ToString(false);
using (IDataReader reader = db.ExecuteReader(cmd))
{
if (reader.Read())
{
reply.Output = Convert.ToString(true);
}
}
}
catch (SqlException ex)
{
ex.HandleException();
}
return reply;
}
/// <summary>
/// Gets activities by activity library ID or Name & Version combination.
/// </summary>
/// <param name="request">Request that specifies activity library identifier info.</param>
/// <param name="includeXaml">Flag that indicates whether activity XAML should be returned.</param>
/// <returns>Response that contains a list of activities.</returns>
public static List<GetLibraryAndActivitiesDC> GetActivitiesByActivityLibrary(GetLibraryAndActivitiesDC request, bool includeXaml)
{
List<GetLibraryAndActivitiesDC> reply = null;
try
{
Database database = DatabaseFactory.CreateDatabase();
DbCommand command = database.GetStoredProcCommand(StoredProcNames.ActivityGetByActivityLibrary);
database.AddParameter(command, StoredProcParamNames.Id, DbType.Int32, ParameterDirection.Input, null, DataRowVersion.Default, request.ActivityLibrary.Id);
database.AddParameter(command, StoredProcParamNames.Name, DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.ActivityLibrary.Name);
database.AddParameter(command, StoredProcParamNames.Version, DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.ActivityLibrary.VersionNumber);
StoreActivitiesDC activity = null;
List<StoreActivitiesDC> activities = new List<StoreActivitiesDC>();
using (IDataReader reader = database.ExecuteReader(command))
{
while (reader.Read())
{
activity = new StoreActivitiesDC();
activity.ActivityCategoryName = Convert.ToString(reader[DataColumnNames.ActivityCategoryName]);
activity.ActivityLibraryName = Convert.ToString(reader[DataColumnNames.ActivityLibraryName]);
activity.Name = Convert.ToString(reader[DataColumnNames.Name]);
activity.Description = Convert.ToString(reader[DataColumnNames.Description]) ?? string.Empty;
activity.DeveloperNotes = Convert.ToString(reader[DataColumnNames.DeveloperNotes]);
activity.Id = Convert.ToInt32(reader[DataColumnNames.Id]);
activity.IsCodeBeside = reader[DataColumnNames.IsCodeBeside] != DBNull.Value ? Convert.ToBoolean(reader[DataColumnNames.IsCodeBeside]) : false;
activity.IsService = Convert.ToBoolean(reader[DataColumnNames.IsService]);
activity.Locked = reader[DataColumnNames.Locked] != DBNull.Value ? Convert.ToBoolean(reader[DataColumnNames.Locked]) : false;
activity.LockedBy = Convert.ToString(reader[DataColumnNames.LockedBy]) ?? string.Empty;
activity.MetaTags = Convert.ToString(reader[DataColumnNames.MetaTags]) ?? string.Empty;
activity.Namespace = Convert.ToString(reader[DataColumnNames.Namespace]) ?? string.Empty;
activity.Guid = new Guid(Convert.ToString(reader[DataColumnNames.Guid]));
activity.ToolBoxtab = reader[DataColumnNames.ToolBoxtab] != DBNull.Value ? Convert.ToInt32(reader[DataColumnNames.ToolBoxtab]) : 0;
activity.Version = Convert.ToString(reader[DataColumnNames.Version]);
activity.WorkflowTypeName = Convert.ToString(reader[DataColumnNames.WorkflowTypeName]);
if (includeXaml)
{
activity.Xaml = Convert.ToString(reader[DataColumnNames.Xaml]) ?? string.Empty;
}
activities.Add(activity);
}
}
reply = new List<GetLibraryAndActivitiesDC>();
reply.Add(new GetLibraryAndActivitiesDC());
reply[0].StoreActivitiesList = activities;
}
catch (SqlException e)
{
e.HandleException();
}
return reply;
}
/// <summary>
/// The activity item to store activity dc.
/// </summary>
/// <param name="activityItem">
/// The activity item.
/// </param>
/// <returns>
/// Converted StoreActivitiesDC instance
/// </returns>
public static StoreActivitiesDC ActivityItemToStoreActivitiyDC(ActivityItem activityItem)
{
var storeActivity = new StoreActivitiesDC();
storeActivity.ActivityCategoryName = activityItem.Category;
storeActivity.Description = activityItem.Description;
storeActivity.Name = activityItem.FullName;
storeActivity.ShortName = activityItem.Name;
storeActivity.IsCodeBeside = activityItem.HasCodeBehind;
storeActivity.Version = activityItem.Version;
storeActivity.Xaml = activityItem.XamlCode;
storeActivity.MetaTags = activityItem.Tags;
storeActivity.AuthGroupName = AuthorizationService.GetWorkflowAuthGroupName();
storeActivity.ActivityCategoryName = activityItem.Category;
storeActivity.Incaller = Utility.GetCallerName();
storeActivity.IncallerVersion = Utility.GetCallerVersion();
storeActivity.DeveloperNotes = activityItem.DeveloperNote;
storeActivity.InsertedDateTime = activityItem.CreateDateTime;
storeActivity.InsertedByUserAlias = !String.IsNullOrEmpty(activityItem.CreatedBy) ? activityItem.CreatedBy : Environment.UserName;
storeActivity.IsCodeBeside = true;
storeActivity.StatusCodeName = activityItem.Status;
storeActivity.Guid = Guid.NewGuid();
storeActivity.UpdatedByUserAlias = Utility.GetCurrentUserName();
storeActivity.Locked = false;
storeActivity.LockedBy = Environment.UserName;
storeActivity.UpdatedByUserAlias = activityItem.UpdatedBy;
storeActivity.UpdatedDateTime = activityItem.UpdateDateTime;
storeActivity.OldVersion = activityItem.OldVersion;
if (activityItem is WorkflowItem)
{
storeActivity.WorkflowTypeName = ((WorkflowItem)activityItem).WorkflowType;
storeActivity.IsService = ((WorkflowItem)activityItem).IfNotNull(wfi => wfi.IsService);
}
else
{
//Save default values to the store. When saving the different activities, only the root activity will be a
//workflow item, the rest sub-activities will be saved with WorkflowType "metadata" until we remove WorkflowTypeID
//From the Store Activities table. There is already an ActivityLibraryID to check the library that contains the activity,
//so this workflowType is not being used at all and should be removed.
storeActivity.WorkflowTypeName = "Metadata";
storeActivity.IsService = false;
}
return storeActivity;
}
/// <summary>
/// Performs input validation and checks if an activity exists in the data store
/// </summary>
/// <param name="request">Request that specifies activity identifier info.</param>
/// <returns>Result of the operation.</returns>
public static StatusReplyDC CheckActivityExists(StoreActivitiesDC request)
{
var reply = new StatusReplyDC();
try
{
// Validates the input and throws ValidationException for any issues found.
request.ValidateRequest();
reply = ActivityRepositoryService.CheckActivityExists(request);
}
catch (ValidationException e)
{
e.HandleException();
}
catch (DataAccessException e)
{
e.HandleException();
}
return reply;
}
/// <summary>
/// Checks the rules for versioning. If the rules are incorrect, it returns false and a string detailing what the error
/// was, and a human readable string to display to the user.
/// </summary>
/// <param name="workflowToCheck">the StoreActivity record we care about versioning</param>
/// <param name="requestedOperation">The state of the object being saved. I.e., is this a new record, an update, etc.
/// Save, AddNew, Compile (and for future use), Delete. "Null" means "figure it out from what's in the database"</param>
/// <param name="workflowRecordState">Public, Private, Retired. </param>
/// <param name="userName">the user making the request</param>
/// <returns>
/// a tuple with a bool indicating pass/fail and a description of what needs to change (if any)
/// Message is a message describing the problem, and Rule is the rule that was applied/tested against.
/// </returns>
public static Tuple<bool, string, Rule> CheckVersioningRules(StoreActivitiesDC workflowToCheck,
RequestedOperation? requestedOperation,
string userName)
{
var isRulePassed = true;
bool isPublic;
bool isRetired;
var errorString = String.Empty;
var previousVersions = Activities.StoreActivitiesGetByName(workflowToCheck.Name, userName);
Rule rule = null;
if (!IsValidMarketplaceVersion(workflowToCheck.Version))
throw new VersionException(string.Format(InvalidVersionNumberMessage, workflowToCheck.Version), null);
previousVersions = previousVersions.Where(item => Version.Parse(item.Version) >= Version.Parse(workflowToCheck.Version)).ToList();
if (null == requestedOperation)
requestedOperation = previousVersions.Any()
? RequestedOperation.Update : RequestedOperation.AddNew;
if (!string.IsNullOrEmpty(workflowToCheck.StatusCodeName))
workflowToCheck.WorkflowRecordState = (WorkflowRecordState)Enum.Parse(typeof(WorkflowRecordState), workflowToCheck.StatusCodeName);
if (null == workflowToCheck.WorkflowRecordState)
workflowToCheck.WorkflowRecordState = WorkflowRecordState.Private;
isPublic = workflowToCheck.WorkflowRecordState == WorkflowRecordState.Public;
isRetired = workflowToCheck.WorkflowRecordState == WorkflowRecordState.Retired;
if ((previousVersions.Count == 0) && !isPublic)
return new Tuple<bool, string, Rule>(true, String.Empty, null);
// find the rule that matches the current condition
var ruleQuery = (from candidateRule in versioningRules
where (candidateRule.ActionType == requestedOperation)
&& (candidateRule.IsPublic == isPublic)
&& (candidateRule.IsRetired == isRetired)
select candidateRule)
.ToList();
if (ruleQuery.Any())
{
rule = ruleQuery.First();
if (rule.NameRequiredChange != RequiredChange.NoActionRequired)
{
// VersionRequiredActionEnum.MustChange is the only valid action here - check to make sure this name does not exist in the database
isRulePassed = (previousVersions.Count == 0);
if (!isRulePassed)
errorString += string.Format(NameMustBeChangedMessage);
}
var major = GetVersionSection(workflowToCheck.Version, Section.Major);
if ((from workflow in previousVersions
where GetVersionSection(workflow.Version, Section.Major) > major
select workflow).Any())
{
isRulePassed = false;
errorString += string.Format(MustBeIncrementedMessage, Section.Major.ToString());
}
// when checking minor, build, revision, we only care about number ranges within the major build.
// for instance, there can be a build 5 in major version 2, even though the max build number might be 10 in another major version
previousVersions = (from workflow in previousVersions
where GetVersionSection(workflow.Version, Section.Major) == major
select workflow)
.ToList();
isRulePassed &= CheckVersionSection(rule, Section.Major, previousVersions, workflowToCheck, ref errorString);
isRulePassed &= CheckVersionSection(rule, Section.Minor, previousVersions, workflowToCheck, ref errorString);
isRulePassed &= CheckVersionSection(rule, Section.Build, previousVersions, workflowToCheck, ref errorString);
isRulePassed &= CheckVersionSection(rule, Section.Revision, previousVersions, workflowToCheck, ref errorString);
}
else
{
// TODO: Provide the correct associated error code when the error handling refactoring is performed.
throw new BusinessException(-1, string.Format(NoRuleDefinedMessage, requestedOperation, workflowToCheck.WorkflowRecordState));
}
return new Tuple<bool, string, Rule>(isRulePassed, errorString.Trim(), rule);
}
public static void MyClassInitialize(TestContext testContext)
{
string nameModifier = "Test_" + Guid.NewGuid().ToString();
CWF.DataContracts.StoreLibraryAndActivitiesRequestDC request = new CWF.DataContracts.StoreLibraryAndActivitiesRequestDC();
List<CWF.DataContracts.StoreActivitiesDC> reply = null;
request.IncallerVersion = INCALLERVERSION;
request.Incaller = INCALLER;
request.InInsertedByUserAlias = INCALLER;
request.InUpdatedByUserAlias = INCALLER;
request.EnforceVersionRules = true;
// Create ActivityLibrary object and add to request object
CWF.DataContracts.ActivityLibraryDC activityLibraryDC = new CWF.DataContracts.ActivityLibraryDC();
// create storeActivitiesDC list and individual objects and add to request
List<CWF.DataContracts.StoreActivitiesDC> storeActivitiesDCList = new List<CWF.DataContracts.StoreActivitiesDC>();
CWF.DataContracts.StoreActivitiesDC storeActivitiesDC = new CWF.DataContracts.StoreActivitiesDC();
DALUnitTest.CreateActivityLibraryAndStoreActivities(out activityLibraryDC, out storeActivitiesDCList);
request.ActivityLibrary = activityLibraryDC;
request.StoreActivitiesList = storeActivitiesDCList;
request.StoreActivitiesList.ForEach(record =>
{
record.Name += nameModifier;
record.ActivityLibraryName += nameModifier;
record.ShortName += nameModifier;
});
activityLibraryDC.Name += nameModifier;
request.StoreActivityLibraryDependenciesGroupsRequestDC = new StoreActivityLibraryDependenciesGroupsRequestDC()
{
Name = activityLibraryDC.Name,
Version = activityLibraryDC.VersionNumber,
List = new List<StoreActivityLibraryDependenciesGroupsRequestDC>
{
new StoreActivityLibraryDependenciesGroupsRequestDC
{
IncallerVersion = INCALLERVERSION,
Incaller = INCALLER,
Name = "PublishingInfo",
Version = "1.0.0.1"
},
}
};
reply = CWF.BAL.Services.UploadActivityLibraryAndDependentActivities(request);
Assert.IsNotNull(reply);
activityId = reply[0].Id;
Assert.IsTrue(activityId > 0);
//Test Create or Update
Guid taskGuid = Guid.NewGuid();
TaskActivityDC reply1 = null;
TaskActivityDC request1 = new TaskActivityDC()
{
ActivityId = activityId,
Guid = taskGuid,
Incaller = INCALLER,
IncallerVersion = INCALLERVERSION,
AssignedTo = OWNER
};
try
{
reply1 = TaskActivityRepositoryService.TaskActivitiesCreateOrUpdate(request1);
}
catch (Exception ex)
{
string faultMessage = ex.Message;
Assert.Fail(faultMessage + "-catch exception in reply = TaskActivityRepository.CreateOrUpdate(request)");
}
Assert.IsNotNull(reply1);
Assert.IsTrue(reply1.Id > 0);
Assert.AreEqual(SprocValues.REPLY_ERRORCODE_VALUE_OK, reply1.StatusReply.Errorcode);
}
/// <summary>
/// Verify GET FROM etblStoreActivities Table for a valid name
/// </summary>
/// <param name="name">name from row to do a get on</param>
/// <returns>returns the id of this row</returns>
private int VerifyGetStoreActivitiesForValidNamesForMaxID(string name)
{
getRequest = new StoreActivitiesDC();
getReplyList = null;
// Populate Request
getRequest.Incaller = IN_CALLER;
getRequest.IncallerVersion = IN_CALLER_VERSION;
getRequest.Name = name;
try
{
getReplyList = new List<StoreActivitiesDC>(devBranchProxy.StoreActivitiesGet(getRequest));
}
catch (FaultException ex)
{
Assert.Fail("Caught WCF FaultExceptionException: Message: {0} \n Stack Trace: {1}", ex.Message, ex.StackTrace);
}
catch (Exception e)
{
Assert.Fail("Caught Exception Invoking the Service. Message: {0} \n Stack Trace: {1}", e.Message, e.StackTrace);
}
// Validate
Assert.IsNotNull(getReplyList, "getReply.List is null");
Assert.AreEqual(1, getReplyList.Count, "Get returned the wrong number of entries. name: {0}. It should have returned 1 but instead returned {1}.", name, getReplyList.Count);
Assert.IsNotNull(getReplyList[0].StatusReply, "getReply.StatusReply is null");
Assert.AreEqual(0, getReplyList[0].StatusReply.Errorcode, "StatusReply returned the wrong error code. Expected: 0. Actual: {0}", getReplyList[0].StatusReply.Errorcode);
Assert.AreEqual(name, getReplyList[0].Name, "Get returned the wrong name. name: {0} Expected: {1}", getReplyList[0].Name, name);
int index = getReplyList.Count - 1;
int id = getReplyList[index].Id;
//id = getReplyList.Last().Id; // todo: next sprint
return id;
}
public void TESTBalUploadActivityLibraryAndDependentActivitiesRepeat()
{
var nameModifier = Guid.NewGuid().ToString();
CWF.DataContracts.StoreLibraryAndActivitiesRequestDC request = new CWF.DataContracts.StoreLibraryAndActivitiesRequestDC();
List<CWF.DataContracts.StoreActivitiesDC> reply = null;
request.IncallerVersion = INCALLERVERSION;
request.Incaller = INCALLER;
request.InInsertedByUserAlias = INCALLER;
request.InUpdatedByUserAlias = INCALLER;
request.EnforceVersionRules = true;
// Create ActivityLibrary object and add to request object
CWF.DataContracts.ActivityLibraryDC activityLibraryDC = new CWF.DataContracts.ActivityLibraryDC();
// create storeActivitiesDC list and individual objects and add to request
List<CWF.DataContracts.StoreActivitiesDC> storeActivitiesDCList = new List<CWF.DataContracts.StoreActivitiesDC>();
CWF.DataContracts.StoreActivitiesDC storeActivitiesDC = new CWF.DataContracts.StoreActivitiesDC();
CreateActivityLibraryAndStoreActivities(out activityLibraryDC, out storeActivitiesDCList);
request.ActivityLibrary = activityLibraryDC;
request.StoreActivitiesList = storeActivitiesDCList;
request.StoreActivitiesList.ForEach(record =>
{
record.Name += nameModifier;
record.ActivityLibraryName += nameModifier;
record.ShortName += nameModifier;
});
activityLibraryDC.Name = "PublishingInfo";
activityLibraryDC.VersionNumber = "1.0.0.1";
request.StoreActivityLibraryDependenciesGroupsRequestDC = new StoreActivityLibraryDependenciesGroupsRequestDC()
{
Name = activityLibraryDC.Name,
Version = activityLibraryDC.VersionNumber,
List = new List<StoreActivityLibraryDependenciesGroupsRequestDC>
{
new StoreActivityLibraryDependenciesGroupsRequestDC
{
IncallerVersion = INCALLERVERSION,
Incaller = INCALLER,
Name = "PublishingInfo",
Version = "1.0.0.1"
},
}
};
try
{
reply = CWF.BAL.Services.UploadActivityLibraryAndDependentActivities(request);
}
catch (Exception ex)
{
string faultMessage = ex.Message;
Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.BAL.Services.UploadActivityLibraryAndDependentActivities(request);");
}
Assert.IsNotNull(reply);
}
public static WorkflowItem StoreActivitiyDCToWorkflowItem(
StoreActivitiesDC dc,
ActivityAssemblyItem parentAssemblyItem,
List<ActivityAssemblyItem> references = null,
bool isTask = false)
{
var workflowItem = new WorkflowItem(dc.Name, dc.Name, dc.Xaml, dc.WorkflowTypeName, references);
workflowItem.CachingStatus = CachingStatus.None;
workflowItem.Category = dc.ActivityCategoryName;
workflowItem.CreateDateTime = dc.InsertedDateTime;
workflowItem.CreatedBy = dc.InsertedByUserAlias;
workflowItem.Description = dc.Description;
workflowItem.FullName = dc.Name;
workflowItem.Name = dc.Name;
workflowItem.DisplayName = dc.ShortName ?? dc.Name;
workflowItem.HasCodeBehind = dc.IsCodeBeside;
workflowItem.ParentAssemblyItem = parentAssemblyItem;
workflowItem.Status = dc.StatusCodeName;
workflowItem.UpdatedBy = dc.UpdatedByUserAlias;
workflowItem.UpdateDateTime = dc.UpdatedDateTime;
workflowItem.IsSavedToServer = true;
workflowItem.Version = workflowItem.OldVersion = dc.Version;
workflowItem.IsDataDirty = false;
workflowItem.Tags = dc.MetaTags;
workflowItem.XamlCode = dc.Xaml;
workflowItem.WorkflowType = dc.WorkflowTypeName;
workflowItem.IsOpenFromServer = true;
workflowItem.IsTask = isTask;
return workflowItem;
}
public static TaskActivityDC TaskActivityGet(TaskActivityDC request)
{
TaskActivityDC reply = new TaskActivityDC();
StatusReplyDC status = new StatusReplyDC();
string outErrorString = string.Empty;
Database db = null;
DbCommand cmd = null;
int retValue = 0;
try
{
db = DatabaseFactory.CreateDatabase();
cmd = db.GetStoredProcCommand(StoredProcNames.TaskActivityGet);
db.AddParameter(cmd, "@inCaller", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.Incaller);
db.AddParameter(cmd, "@inCallerVersion", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.IncallerVersion);
db.AddParameter(cmd, "@InId", DbType.Int32, ParameterDirection.Input, null, DataRowVersion.Default, request.Id);
db.AddParameter(cmd, "@InTaskActivityGUID", DbType.Guid, ParameterDirection.Input, null, DataRowVersion.Default, request.Guid);
db.AddParameter(cmd, "@InActivityId", DbType.Int32, ParameterDirection.Input, null, DataRowVersion.Default, request.ActivityId);
db.AddParameter(cmd, "@ReturnValue", DbType.Int32, ParameterDirection.ReturnValue, null, DataRowVersion.Default, 0);
db.AddOutParameter(cmd, "@outErrorString", DbType.String, 300);
using (IDataReader reader = db.ExecuteReader(cmd))
{
while (reader.Read())
{
reply = new TaskActivityDC();
StoreActivitiesDC sab = new StoreActivitiesDC();
sab.ActivityCategoryName = Convert.ToString(reader["ActivityCategoryName"]);
if (reader["ActivityLibraryName"] == DBNull.Value)
sab.ActivityLibraryName = string.Empty;
else
sab.ActivityLibraryName = Convert.ToString(reader["ActivityLibraryName"]);
if (reader["ActivityLibraryId"] == DBNull.Value)
sab.ActivityLibraryId = 0;
else
sab.ActivityLibraryId = Convert.ToInt32(reader["ActivityLibraryId"]);
sab.ActivityLibraryVersion = Convert.ToString(reader["ActivityLibraryVersion"]);
sab.AuthGroupName = Convert.ToString(reader["AuthgroupName"]);
sab.Name = Convert.ToString(reader["Name"]);
sab.ShortName = Convert.ToString(reader["ShortName"]);
sab.Description = Convert.ToString(reader["Description"]);
sab.DeveloperNotes = Convert.ToString(reader["DeveloperNotes"]);
sab.Id = Convert.ToInt32(reader["Id"]);
if (reader["IsCodeBeside"] == DBNull.Value)
sab.IsCodeBeside = false;
else
sab.IsCodeBeside = Convert.ToBoolean(reader["IsCodeBeside"]);
sab.IsService = Convert.ToBoolean(reader["IsService"]);
if (reader["Locked"] == DBNull.Value)
sab.Locked = false;
else
sab.Locked = Convert.ToBoolean(reader["Locked"]);
sab.LockedBy = Convert.ToString(reader["LockedBy"]) ?? string.Empty;
sab.MetaTags = Convert.ToString(reader["MetaTags"]) ?? string.Empty;
sab.Xaml = Convert.ToString(reader["XAML"]) ?? string.Empty;
sab.Name = Convert.ToString(reader["Name"]);
sab.Namespace = Convert.ToString(reader["Namespace"]) ?? string.Empty;
sab.Guid = new Guid(Convert.ToString(reader["Guid"]));
sab.ToolBoxtab = reader["ToolBoxtab"] == DBNull.Value ? 0 : Convert.ToInt32(reader["ToolBoxtab"]);
sab.Version = Convert.ToString(reader["Version"]);
sab.WorkflowTypeName = Convert.ToString(reader["WorkFlowTypeName"]);
sab.InsertedByUserAlias = Convert.ToString(reader["InsertedByUserAlias"]);
sab.InsertedDateTime = Convert.ToDateTime(reader["InsertedDateTime"]);
sab.UpdatedByUserAlias = Convert.ToString(reader["UpdatedByUserAlias"]);
sab.UpdatedDateTime = Convert.ToDateTime(reader["UpdatedDateTime"]);
sab.StatusCodeName = Convert.ToString(reader["StatusCodeName"]);
reply.Id = Convert.ToInt32(reader["TaskActivityId"]);
reply.ActivityId = Convert.ToInt32(reader["ActivityId"]);
if (reader["AssignedTo"] != DBNull.Value)
reply.AssignedTo = Convert.ToString(reader["AssignedTo"]);
if (reader["Status"] != DBNull.Value)
reply.Status = (TaskActivityStatus)Enum.Parse(typeof(TaskActivityStatus), Convert.ToString(reader["Status"]));
reply.Guid = new Guid(Convert.ToString(reader["TaskActivityGuid"]));
reply.Activity = sab;
}
retValue = Convert.ToInt32(cmd.Parameters["@ReturnValue"].Value);
outErrorString = Convert.ToString(cmd.Parameters["@outErrorString"].Value);
if (retValue != 0)
{
status.ErrorMessage = Convert.ToString(cmd.Parameters["@outErrorString"].Value);
status.Errorcode = retValue;
Logging.Log(retValue,
EventLogEntryType.Error,
"TaskActivity_Get_ERROR_MSG",
outErrorString);
}
}
}
catch (Exception ex)
{
status = Logging.Log(SprocValues.GENERIC_CATCH_ID,
EventLogEntryType.Error,
"TaskActivity_Get_ERROR_MSG",
ex);
}
reply.StatusReply = status;
return reply;
}
/// <summary>
/// Gets the Workflow Template Activity Item based on the Selected Workflow Template, and its dependencies
/// </summary>
/// <returns>The Activity Item that will have the XAML required to create the workflow from the specified Workflow Template</returns>
private WorkflowItem GetWorkflowTemplateActivityExecute(IWorkflowsQueryService client)
{
WorkflowItem workflowActivityTemplateItem = null;
List<StoreActivitiesDC> storeActivitiesList = null;
ActivityAssemblyItem workflowActivityTemplateItemAssembly = null;
StoreActivitiesDC targetDC = null;
ActivityLibraryDC targetLibrary = null;
List<ActivityLibraryDC> activityLibraryList;
// Throw if nothing selected. CanExecute should prevent this.
if (null == SelectedWorkflowTemplateItem)
throw new ArgumentNullException();
// Create the Activity request
var requestActivity = new StoreActivitiesDC()
{
Incaller = Assembly.GetExecutingAssembly().GetName().Name,
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
Id = SelectedWorkflowTemplateItem.WorkflowTemplateId
};
// Get the List of Activities that qualify, should only be one
storeActivitiesList = client.StoreActivitiesGet(requestActivity);
storeActivitiesList[0].StatusReply.CheckErrors();
if (null != storeActivitiesList)
{
// Get the first or one and only StoreActivity
targetDC = storeActivitiesList.First();
// We have to get the Activity Library associated with the Store Activity
if (0 != targetDC.ActivityLibraryId)
{
List<ActivityAssemblyItem> references = new List<ActivityAssemblyItem>();
Utility.DoTaskWithBusyCaption("Loading...",() =>
{
// Create the Library request
var requestLibrary = new ActivityLibraryDC
{
Incaller = Assembly.GetExecutingAssembly().GetName().Name,
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
Id = targetDC.ActivityLibraryId
};
// Get the list
try
{
activityLibraryList = client.ActivityLibraryGet(requestLibrary);
}
catch (FaultException<ServiceFault> ex)
{
throw new CommunicationException(ex.Detail.ErrorMessage);
}
catch (FaultException<ValidationFault> ex)
{
throw new BusinessValidationException(ex.Detail.ErrorMessage);
}
catch (Exception ex)
{
throw new CommunicationException(ex.Message);
}
// Get the First one or null, should only be one
targetLibrary = activityLibraryList.FirstOrDefault();
workflowActivityTemplateItemAssembly = DataContractTranslator.ActivityLibraryDCToActivityAssemblyItem(targetLibrary);
// download dependencies
references = Caching.CacheAndDownloadAssembly(client, Caching.ComputeDependencies(client, workflowActivityTemplateItemAssembly));
});
workflowActivityTemplateItem = DataContractTranslator.StoreActivitiyDCToWorkflowItem(targetDC, workflowActivityTemplateItemAssembly, references);
workflowActivityTemplateItem.WorkflowType = SelectedWorkflowTemplateItem.WorkflowTypeName;
workflowActivityTemplateItem.IsOpenFromServer = false;
}
}
return workflowActivityTemplateItem; // Return the ActivityItem
}
/// <summary>
/// Set lock status for store activities by following parameters: Name / Version / Locked / LockedBy
/// </summary>
/// <param name="name">The name of store activity</param>
/// <param name="version">The version number of store activity</param>
/// <param name="locked">If user want to lock this item</param>
/// <param name="lockedBy">The user who want to lock this item</param>
/// <returns></returns>
private CWF.DataContracts.StatusReplyDC SetLockForStoreActivity(string name, string version, bool locked, string lockedBy)
{
getRequest = new StoreActivitiesDC();
//Populate the request data
getRequest.Incaller = IN_CALLER;
getRequest.IncallerVersion = IN_CALLER_VERSION;
getRequest.Name = name;
getRequest.Version = version;
getRequest.Locked = locked;
getRequest.LockedBy = lockedBy;
try
{
return devBranchProxy.StoreActivitiesSetLock(getRequest, DateTime.Now);
}
catch (FaultException e)
{
Assert.Fail("Failed to get data from etblStoreActivities: {0}", e.Message);
return null;
}
catch (Exception ex)
{
Assert.Fail("Failed to get data from etblStoreActivities: {0}", ex.Message);
return null;
}
}
public void TestUploadTaskActivity()
{
string nameModifier = "Test_" + Guid.NewGuid().ToString();
CWF.DataContracts.StoreLibraryAndTaskActivityRequestDC request = new CWF.DataContracts.StoreLibraryAndTaskActivityRequestDC();
List<CWF.DataContracts.TaskActivityDC> reply = null;
request.IncallerVersion = INCALLERVERSION;
request.Incaller = INCALLER;
request.InInsertedByUserAlias = INCALLER;
request.InUpdatedByUserAlias = INCALLER;
request.EnforceVersionRules = true;
// Create ActivityLibrary object and add to request object
CWF.DataContracts.ActivityLibraryDC activityLibraryDC = new CWF.DataContracts.ActivityLibraryDC();
// create storeActivitiesDC list and individual objects and add to request
List<CWF.DataContracts.StoreActivitiesDC> storeActivitiesDCList = new List<CWF.DataContracts.StoreActivitiesDC>();
CWF.DataContracts.StoreActivitiesDC storeActivitiesDC = new CWF.DataContracts.StoreActivitiesDC();
DALUnitTest.CreateActivityLibraryAndStoreActivities(out activityLibraryDC, out storeActivitiesDCList);
request.ActivityLibrary = activityLibraryDC;
storeActivitiesDCList.ForEach(record =>
{
record.Name += nameModifier;
record.ActivityLibraryName += nameModifier;
record.ShortName += nameModifier;
});
List<TaskActivityDC> taskActivityList = storeActivitiesDCList.Select(sa => new TaskActivityDC()
{
Activity = sa,
AssignedTo = OWNER,
Guid = Guid.NewGuid(),
Incaller = INCALLER,
IncallerVersion = INCALLERVERSION
}).ToList();
request.TaskActivitiesList = taskActivityList;
activityLibraryDC.Name += nameModifier;
request.StoreActivityLibraryDependenciesGroupsRequestDC = new StoreActivityLibraryDependenciesGroupsRequestDC()
{
Name = activityLibraryDC.Name,
Version = activityLibraryDC.VersionNumber,
List = new List<StoreActivityLibraryDependenciesGroupsRequestDC>
{
new StoreActivityLibraryDependenciesGroupsRequestDC
{
IncallerVersion = INCALLERVERSION,
Incaller = INCALLER,
Name = "PublishingInfo",
Version = "1.0.0.1"
},
}
};
reply = CWF.BAL.Services.UploadLibraryAndTaskActivities(request);
Assert.IsNotNull(reply);
}
public void StoreActivitiesUpdateLock()
{
CWF.DataContracts.StoreActivitiesDC request = new CWF.DataContracts.StoreActivitiesDC();
request.Incaller = INCALLER;
request.IncallerVersion = INCALLERVERSION;
request.Name = "PublishingWorkflow";
request.Version = "1.0.1.0";
request.Locked = true;
request.LockedBy = OWNER;
CWF.DataContracts.StoreActivitiesDC reply = null;
try
{
reply = Activities.StoreActivitiesUpdateLock(request, DateTime.Now);
}
catch (Exception ex)
{
string faultMessage = ex.Message;
Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.DAL.Activities.StoreActivityUpdateLock(request);");
}
Assert.IsNotNull(reply);
Assert.AreEqual(reply.StatusReply.Errorcode, SprocValues.REPLY_ERRORCODE_VALUE_OK);
}
public void StoreActivitiesGetByName()
{
CWF.DataContracts.StoreActivitiesDC request = new CWF.DataContracts.StoreActivitiesDC();
request.Incaller = INCALLER;
request.IncallerVersion = INCALLERVERSION;
request.Name = "PublishingWorkflow";
List<CWF.DataContracts.StoreActivitiesDC> reply = null;
try
{
reply = Activities.StoreActivitiesGetByName(request.Name, string.Empty);
}
catch (Exception ex)
{
string faultMessage = ex.Message;
Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.DAL.Activities.StoreActivitiesGetByName('PublishingWorkflow','');");
}
Assert.IsNotNull(reply);
Assert.IsTrue(reply.Any());
Assert.AreEqual("setup", reply[0].InsertedByUserAlias);
Assert.IsNotNull(reply[0].InsertedDateTime);
}
public void StoreActivitiesGet()
{
CWF.DataContracts.StoreActivitiesDC request = new CWF.DataContracts.StoreActivitiesDC();
request.Incaller = INCALLER;
request.IncallerVersion = INCALLERVERSION;
//// request.Id = 53;
request.Name = "PublishingWorkflow";
request.Version = "1.0.1.0";
List<CWF.DataContracts.StoreActivitiesDC> reply = null;
try
{
reply = Activities.StoreActivitiesGet(request);
}
catch (Exception ex)
{
string faultMessage = ex.Message;
Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.DAL.Activities.StoreActivitiesGet(request);");
}
Assert.IsNotNull(reply);
Assert.AreEqual(reply[0].StatusReply.Errorcode, SprocValues.REPLY_ERRORCODE_VALUE_OK);
}
/// <summary>
/// Creates a store activity for TEST
/// </summary>
/// <param name="name">store activity name</param>
/// <param name="version">version string</param>
/// <param name="guid">GUID identifier</param>
/// <param name="activityLibraryName">activityLibraryName identifier</param>
/// <param name="activityLibraryVersion">activityLibraryVersion identifier</param>
/// <returns>StoreActivitiesDC object</returns>
public static CWF.DataContracts.StoreActivitiesDC CreateSA(string name, string version, Guid guid, string activityLibraryName, string activityLibraryVersion)
{
CWF.DataContracts.StoreActivitiesDC storeActivitiesDC = new CWF.DataContracts.StoreActivitiesDC();
storeActivitiesDC.ActivityLibraryName = activityLibraryName;
storeActivitiesDC.ActivityLibraryVersion = activityLibraryVersion;
storeActivitiesDC.ActivityCategoryName = "OAS Basic Controls";
storeActivitiesDC.AuthGroupName = "pqocwfadmin";
storeActivitiesDC.Description = "TEST type";
storeActivitiesDC.Incaller = INCALLER;
storeActivitiesDC.IncallerVersion = INCALLERVERSION;
storeActivitiesDC.InsertedByUserAlias = INSERTEDBYUSERALIAS;
storeActivitiesDC.IsCodeBeside = true;
storeActivitiesDC.IsService = true;
storeActivitiesDC.Locked = true;
storeActivitiesDC.LockedBy = "v-stska";
storeActivitiesDC.MetaTags = "Meta, Tags, TEST";
storeActivitiesDC.Name = name;
storeActivitiesDC.ShortName = name;
storeActivitiesDC.Namespace = "Namespace1";
storeActivitiesDC.StatusCodeName = "Private";
storeActivitiesDC.Guid = Guid.NewGuid();
//// saDC.Guid = new Guid("AAAAAAAA-1A29-44D1-B783-0A3659F1CDB2");
storeActivitiesDC.ToolBoxtab = 1;
storeActivitiesDC.UpdatedByUserAlias = UPDATEDBYUSERALIAS;
storeActivitiesDC.Version = version;
storeActivitiesDC.OldVersion = version;
//// saDC.Version = "1.0.0.0";
storeActivitiesDC.WorkflowTypeName = "Workflow";
storeActivitiesDC.Xaml = "<XamlBeginTag></XamlBeginTag>";
return storeActivitiesDC;
}
public void TestBalStoreActivitiesSetLock()
{
CWF.DataContracts.StoreActivitiesDC request = new CWF.DataContracts.StoreActivitiesDC();
request.Incaller = INCALLER;
request.IncallerVersion = INCALLERVERSION;
request.Name = "PublishingWorkflow";
request.Version = "1.0.1.0";
request.Locked = true;
request.LockedBy = "v-ery";
DateTime lockedTime = DateTime.Now;
CWF.DataContracts.StatusReplyDC result = null;
try
{
result = Services.StoreActivitiesSetLock(request, lockedTime);
}
catch (Exception ex)
{
string faultMessage = ex.Message;
Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.DAL.Activities.StoreActivitiesGet(request);");
}
Assert.IsNotNull(result);
Assert.AreEqual(SprocValues.REPLY_ERRORCODE_VALUE_OK, result.Errorcode);
}
public static Version GetNextVersion(StoreActivitiesDC request)
{
Func<int, int> incrementOnlyAction = (i => i + 1); // the lambda to pass in to the section handling routine when all we need is a simple increment
var workflowToTest = request;
var existingRecords = Activities.StoreActivitiesGetByName(workflowToTest.Name, request.Incaller);
int major;
int minor;
int build;
int revision;
Version theVersion;
Rule rule;
if (!IsValidMarketplaceVersion(request.Version))
throw new VersionException(string.Format(InvalidVersionNumberMessage, request.Version), null);
Version maxVersion = (from record in existingRecords
select new Version(record.Version))
.Max();
if (null == maxVersion)
return new Version(
versionSectionResetValues[Section.Major],
versionSectionResetValues[Section.Minor],
versionSectionResetValues[Section.Build],
versionSectionResetValues[Section.Revision]
);
if (new Version(request.Version) < maxVersion)
request.Version = maxVersion.ToString();
theVersion = new Version(request.Version);
major = theVersion.Major;
minor = theVersion.Minor;
build = theVersion.Build;
revision = theVersion.Revision;
rule = CheckVersioningRules(workflowToTest, null, request.Incaller).Item3;
major = HandleVersionSectionChange(rule.MajorRequiredChange,
initialValue =>
{
minor = versionSectionResetValues[Section.Minor];
build = versionSectionResetValues[Section.Build];
revision = versionSectionResetValues[Section.Revision];
return initialValue + 1;
},
major,
versionSectionResetValues[Section.Major]);
minor = HandleVersionSectionChange(rule.MinorRequiredChange,
initialValue =>
{
var result = initialValue + 1;
if (result > MaximumMinorSectionValue)
{
major++;
result = versionSectionResetValues[Section.Minor];
}
return result;
},
minor,
versionSectionResetValues[Section.Minor]);
build = HandleVersionSectionChange(rule.BuildRequiredChange, incrementOnlyAction, build, versionSectionResetValues[Section.Build]);
revision = HandleVersionSectionChange(rule.RevisionRequiredChange, incrementOnlyAction, revision, versionSectionResetValues[Section.Revision]);
return new Version(major, minor, build, revision);
}
private static bool CheckVersionSection(Rule rule,
Section section,
IEnumerable<StoreActivitiesDC> previousVersions,
StoreActivitiesDC workflowToTest,
ref string errorString)
{
var isRulePassed = true; // defaults to a state of passing the section
// make a lookup so we can easily determine the required change, without resorting to a switch statement or similar
var ruleActions = new Dictionary<Section, RequiredChange>
{
{Section.Major, rule.MajorRequiredChange},
{Section.Minor, rule.MinorRequiredChange},
{Section.Build, rule.BuildRequiredChange},
{Section.Revision, rule.RevisionRequiredChange},
};
var ruleAction = ruleActions.First(ruleAction1 => ruleAction1.Key == section).Value;
if (ruleAction != RequiredChange.NoActionRequired)
{
var sectionValue = GetVersionSection(workflowToTest.Version, section); // the value of the specified piece of the version number
switch (ruleAction)
{
case RequiredChange.MustIncrement:
if (previousVersions.Any())
isRulePassed = previousVersions
.Select(workflow => GetVersionSection(workflow.Version, section))
.Max() < sectionValue;
if (!isRulePassed)
errorString += string.Format(MustBeIncrementedMessage, section.ToString());
break;
case RequiredChange.MustReset:
isRulePassed = (sectionValue == versionSectionResetValues[section]);
if (!isRulePassed)
errorString += string.Format(MustBeResetMessage, section, versionSectionResetValues[section]);
break;
default:
throw new NotImplementedException();
}
}
return isRulePassed;
}
/// <summary>
/// Verify GET FROM etblStoreActivities Table for softDeleted IDs
/// </summary>
/// <param name="softDeletedID">id of row to do a get on</param>
private void VerifyGetStoreActivitiesForSoftDeletedID(int softDeletedID)
{
getRequest = new StoreActivitiesDC();
// Populate Request
getRequest.Incaller = IN_CALLER;
getRequest.IncallerVersion = IN_CALLER_VERSION;
getRequest.Id = softDeletedID;
getReplyList = null;
try
{
getReplyList = new List<StoreActivitiesDC>(devBranchProxy.StoreActivitiesGet(getRequest));
}
catch (FaultException ex)
{
Assert.Fail("Caught WCF FaultExceptionException: Message: {0} \n Stack Trace: {1}", ex.Message, ex.StackTrace);
}
catch (Exception e)
{
Assert.Fail("Caught Exception Invoking the Service. Message: {0} \n Stack Trace: {1}", e.Message, e.StackTrace);
}
int errorConstant = SprocValues.GET_INVALID_GETID_ON_SOFTDELETEDROW_ID;
Assert.IsNotNull(getReplyList, "getReplyList is null.");
Assert.AreEqual(1, getReplyList.Count, "Service returned wrong number of records. InId= {0}. It should have returned 1 but instead returned {1}.", softDeletedID, getReplyList.Count);
Assert.IsNotNull(getReplyList[0].StatusReply, "getReplyList[0].StatusReply is null");
Assert.AreEqual(errorConstant, getReplyList[0].StatusReply.Errorcode, "StatusReply returned the wrong error code. Expected: {0}. Actual: {1}", errorConstant, getReplyList[0].StatusReply.Errorcode);
Assert.IsNotNull(getReplyList[0].StatusReply.ErrorMessage, "StatusReply.ErrorMessage is null");
}
/// <summary>
/// Save downloaded projects to local machine
/// </summary>
/// <param name="wfs"></param>
/// <param name="filePath"></param>
public void SaveProjectsToLocal(StoreActivitiesDC activity, List<ActivityAssemblyItem> references)
{
if (activity == null)
return;
try
{
string targetFileName = Utility.GetProjectsDirectoryPath() + "\\" + activity.ActivityLibraryName + "_" + activity.ActivityLibraryVersion + ".wf";
using (var stream = File.Open(targetFileName, FileMode.Create))
{
var formatter = new BinaryFormatter();
WorkflowItem wfItem = null;
ActivityAssemblyItem assembly = new ActivityAssemblyItem { Name = activity.Name, Version = System.Version.Parse(activity.Version) };
wfItem = DataContractTranslator.StoreActivitiyDCToWorkflowItem(activity, assembly, references);
formatter.Serialize(stream, wfItem);
}
}
catch (Exception ex)//net work exception
{
MarketplaceExceptionHandler.HandleSaveProjectsException(ex);
}
}
/// <summary>
/// Creates a store activity for test automation
/// </summary>
/// <param name="name">name to be insterted</param>
/// <param name="version">version to be insterted</param>
/// <param name="guid">guid to be insterted</param>
/// <param name="activityLibraryName">activityLibraryName to be insterted</param>
/// <param name="activityLibraryVersion">activityLibraryVersion to be insterted</param>
/// <returns>StoreActivitiesDC object</returns>
private static StoreActivitiesDC CreateStoreActivity(string name, string version, Guid guid, string activityLibraryName, string activityLibraryVersion)
{
StoreActivitiesDC storeActivityDC = new StoreActivitiesDC();
storeActivityDC.ActivityLibraryName = activityLibraryName;
storeActivityDC.ActivityLibraryVersion = activityLibraryVersion;
storeActivityDC.ActivityCategoryName = CATEGORY_NAME2;
storeActivityDC.AuthGroupName = AUTH_GROUP_NAME3;
storeActivityDC.Description = TEST_STRING;
storeActivityDC.Incaller = IN_CALLER;
storeActivityDC.IncallerVersion = IN_CALLER_VERSION;
storeActivityDC.InsertedByUserAlias = USER;
storeActivityDC.IsCodeBeside = true;
storeActivityDC.IsService = true;
storeActivityDC.Locked = true;
storeActivityDC.LockedBy = USER;
storeActivityDC.MetaTags = TEST_STRING;
storeActivityDC.Name = name;
storeActivityDC.Namespace = TEST_STRING;
storeActivityDC.StatusCodeName = STATUSCODENAME;
storeActivityDC.Guid = Guid.NewGuid();
storeActivityDC.ToolBoxtab = 1;
storeActivityDC.UpdatedByUserAlias = USER;
storeActivityDC.Version = version;
storeActivityDC.WorkflowTypeName = WORKFLOWTYPENAME;
storeActivityDC.Xaml = XAML;
storeActivityDC.ShortName = TEST_STRING;
return storeActivityDC;
}
/// <summary>
/// The store activity dc to activity item.
/// </summary>
/// <param name="dc">
/// The StoreActivitiesDC data contract instance.
/// </param>
/// <param name="parentAssemblyItem">
/// The parent assembly item.
/// </param>
/// <returns>
/// Converted ActivityItem instance
/// </returns>
public static ActivityItem StoreActivitiyDCToActivityItem(
StoreActivitiesDC dc, ActivityAssemblyItem parentAssemblyItem)
{
var activityItem = new ActivityItem();
activityItem.CachingStatus = CachingStatus.None;
activityItem.Category = dc.ActivityCategoryName;
activityItem.CreateDateTime = dc.InsertedDateTime;
activityItem.CreatedBy = dc.InsertedByUserAlias;
activityItem.Description = dc.Description;
activityItem.FullName = dc.Name;
activityItem.Name = dc.ShortName ?? dc.Name;
activityItem.DisplayName = dc.ShortName ?? dc.Name;
activityItem.HasCodeBehind = dc.IsCodeBeside;
activityItem.IsReadOnly = true; // TODO: Need to find out where this is in the Model
activityItem.IsUserFavorite = false; // TODO: This needs to be added to the Database, DAL, BAL and/or DataContract reply
activityItem.ParentAssemblyItem = parentAssemblyItem;
activityItem.Status = dc.StatusCodeName;
activityItem.UpdatedBy = dc.UpdatedByUserAlias;
activityItem.UpdateDateTime = dc.UpdatedDateTime;
activityItem.UserSelected = true; // TODO: Why is this set to true?
activityItem.Version = activityItem.OldVersion = dc.Version;
activityItem.XamlCode = dc.Xaml;
return activityItem;
}
/// <summary>
/// Verify GET FROM etblStoreActivities Table for valid name and version
/// </summary>
/// <param name="name">name of row to do a get on</param>
/// <param name="version">version of name to do a get on</param>
private void VerifyGetStoreActivitiesForValidNameAndVersion(string name, string version)
{
getRequest = new StoreActivitiesDC();
getReplyList = new List<StoreActivitiesDC>();
VerifyGetForValidNameAndVersion(name, version, getRequest, getReplyList);
}
/// <summary>
/// Verify GET FROM etblStoreActivities Table for Valid IDs
/// </summary>
/// <param name="id">id of row to do a get on</param>
private void VerifyGetStoreActivitiesForValidID(int id)
{
getRequest = new StoreActivitiesDC();
getReplyList = null;
//Populate the request data
getRequest.Incaller = IN_CALLER;
getRequest.IncallerVersion = IN_CALLER_VERSION;
getRequest.Id = id;
try
{
getReplyList = new List<StoreActivitiesDC>(devBranchProxy.StoreActivitiesGet(getRequest));
}
catch (FaultException e)
{
Assert.Fail("Failed to get data from etblStoreActivities: {0}", e.Message);
}
catch (Exception ex)
{
Assert.Fail("Failed to get data from etblStoreActivities: {0}", ex.Message);
}
Assert.IsNotNull(getReplyList, "getReply.List is null");
Assert.AreEqual(1, getReplyList.Count, "Get returned the wrong number of entries. id: {0}. It should have returned 1 but instead returned {1}.", id, getReplyList.Count);
Assert.IsNotNull(getReplyList[0].StatusReply, "getReply.StatusReply is null");
Assert.AreEqual(0, getReplyList[0].StatusReply.Errorcode, "StatusReply returned the wrong error code. Expected: 0. Actual: {0}", getReplyList[0].StatusReply.Errorcode);
Assert.AreEqual(getRequest.Id, getReplyList[0].Id, "Get returned wrong data");
}
public void TESTBalUploadActivityLibraryAndDependentActivitiesAndUpdateVersionAndSaveStoreActivitiesFailed()
{
//var nameModifier = Guid.NewGuid().ToString();
CWF.DataContracts.StoreLibraryAndActivitiesRequestDC request = new CWF.DataContracts.StoreLibraryAndActivitiesRequestDC();
List<CWF.DataContracts.StoreActivitiesDC> reply = null;
request.IncallerVersion = INCALLERVERSION;
request.Incaller = INCALLER;
request.InInsertedByUserAlias = INCALLER;
request.InUpdatedByUserAlias = INCALLER;
request.EnforceVersionRules = false;
// Create ActivityLibrary object and add to request object
CWF.DataContracts.ActivityLibraryDC activityLibraryDC = new CWF.DataContracts.ActivityLibraryDC();
// create storeActivitiesDC list and individual objects and add to request
List<CWF.DataContracts.StoreActivitiesDC> storeActivitiesDCList = new List<CWF.DataContracts.StoreActivitiesDC>();
CWF.DataContracts.StoreActivitiesDC storeActivitiesDC = new CWF.DataContracts.StoreActivitiesDC();
CreateActivityLibraryAndStoreActivities(out activityLibraryDC, out storeActivitiesDCList);
request.ActivityLibrary = activityLibraryDC;
request.StoreActivitiesList = new List<StoreActivitiesDC> { CreateSA(string.Empty, string.Empty, new Guid(), activityLibraryDC.Name, activityLibraryDC.VersionNumber) };
request.StoreActivityLibraryDependenciesGroupsRequestDC = new StoreActivityLibraryDependenciesGroupsRequestDC()
{
Name = activityLibraryDC.Name,
Version = activityLibraryDC.VersionNumber,
List = new List<StoreActivityLibraryDependenciesGroupsRequestDC>
{
new StoreActivityLibraryDependenciesGroupsRequestDC
{
IncallerVersion = INCALLERVERSION,
Incaller = INCALLER,
Name = "PublishingInfo",
Version = "1.0.0.1"
},
}
};
try
{
reply = CWF.BAL.Services.UploadActivityLibraryAndDependentActivities(request);
}
catch (Exception ex)
{
string faultMessage = ex.Message;
Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.BAL.Services.UploadActivityLibraryAndDependentActivities(request);");
}
Assert.IsNotNull(reply);
Assert.AreEqual(reply[0].StatusReply.Errorcode, 55106);
}
/// <summary>
/// Verify UploadActivityLibrariesAndDependentActivities FROM etblActivityLibraries Table
/// </summary>
private void VerifyUploadActivityLibraryAndDependentActivities(string incaller, int errorCode)
{
storeLibraryAndActivitiesRequest = new StoreLibraryAndActivitiesRequestDC();
// reply = null;
storeLibraryAndActivitiesRequest.IncallerVersion = IN_CALLER_VERSION;
storeLibraryAndActivitiesRequest.Incaller = incaller;
storeLibraryAndActivitiesRequest.InInsertedByUserAlias = USER;
storeLibraryAndActivitiesRequest.InUpdatedByUserAlias = USER;
// Create ActivityLibrary object and add to request object
ActivityLibraryDC activityLibraryDC = new ActivityLibraryDC();
// create storeActivitiesDC list and individual objects and add to request
List<StoreActivitiesDC> storeActivitiesDCList = new List<StoreActivitiesDC>();
StoreActivitiesDC storeActivitiesDC = new StoreActivitiesDC();
CreateActivityLibraryAndStoreActivities(out activityLibraryDC, out storeActivitiesDCList);
storeLibraryAndActivitiesRequest.ActivityLibrary = activityLibraryDC;
storeLibraryAndActivitiesRequest.StoreActivityLibraryDependenciesGroupsRequestDC = CreateStoreActivityLibraryDependenciesGroupsRequestDC();
storeLibraryAndActivitiesRequest.StoreActivitiesList = storeActivitiesDCList;
storeActivitiesDCList.ForEach(record => record.Version = VersionHelper.GetNextVersion(record).ToString());
try
{
replyList = new List<StoreActivitiesDC>(devBranchProxy.UploadActivityLibraryAndDependentActivities(storeLibraryAndActivitiesRequest));
}
catch (FaultException e)
{
Assert.Fail("Failed to upload from etblActivityLibraries: {0}", e.Message);
}
catch (Exception ex)
{
Assert.Fail("Failed to upload from etblActivityLibraries: {0}", ex.Message);
}
Assert.IsNotNull(replyList, "Reply is null");
Assert.AreEqual(errorCode, replyList[0].StatusReply.Errorcode, "UploadActivityLibraryAndDependentActivities not successful.");
}
/// <summary>
/// Verify GET FROM etblStoreActivities Table for valid name and invalid version
/// </summary>
/// <param name="name">name of row to do a get on</param>
/// <param name="version">version of name to do a get on</param>
private void VerifyGetStoreActivitiesForValidNameAndInvalidVersion(string name, string version)
{
getRequest = new StoreActivitiesDC();
getReplyList = null;
//Populate the request data
getRequest.Incaller = IN_CALLER;
getRequest.IncallerVersion = IN_CALLER_VERSION;
getRequest.Name = name;
getRequest.Version = version;
try
{
getReplyList = new List<StoreActivitiesDC>(devBranchProxy.StoreActivitiesGet(getRequest));
}
catch (FaultException e)
{
Assert.Fail("Failed to get data from etblStoreActivities: {0}", e.Message);
}
catch (Exception ex)
{
Assert.Fail("Failed to get data from etblStoreActivities: {0}", ex.Message);
}
Assert.IsNotNull(getReplyList, "getReply.List is null");
Assert.AreEqual(1, getReplyList.Count, "Get returned the wrong number of entries. name: {0}, version: {1}. It should have returned 1 but instead returned {2}.", name, version, getReplyList.Count);
Assert.IsNotNull(getReplyList[0].StatusReply, "getReply.StatusReply is null");
Assert.AreEqual(SprocValues.GET_INVALID_GETNAMEVERSION_ID, getReplyList[0].StatusReply.Errorcode, "StatusReply returned the wrong error code. Expected: 0. Actual: {0}", getReplyList[0].StatusReply.Errorcode);
}
