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); }