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> /// Performs input validation and gets activity libraries that match with search /// parameters without including assemblies. /// </summary> /// <param name="request">GetLibraryAndActivitiesDC.</param> /// <returns>GetLibraryAndActivitiesDC object.</returns> public static GetAllActivityLibrariesReplyDC GetActivityLibrariesWithoutDlls(GetAllActivityLibrariesRequestDC request) { ActivityLibraryDC newRequest = null; if (request != null) { newRequest = new ActivityLibraryDC(); newRequest.Name = null; newRequest.VersionNumber = null; newRequest.Incaller = request.Incaller; newRequest.IncallerVersion = request.IncallerVersion; } GetAllActivityLibrariesReplyDC reply = new GetAllActivityLibrariesReplyDC(); try { // Validates the input and throws ValidationException for any issues found. newRequest.ValidateGetRequest(); // Gets the activity libraries that match search criteria. reply.List = ActivityLibraryRepositoryService.GetActivityLibraries(newRequest, false); } catch (ValidationException e) { e.HandleException(); } catch (DataAccessException e) { e.HandleException(); } return reply; }
/// <summary> /// Get an activity library by ID if a positive ID value is provided. Otherwise, gets by GUID /// if a non-empty GUID is provided. If the ID is not positive and the GUID is empty, then /// a list of activity libraries matching the name and version combination. /// </summary> /// <param name="request">ActivityLibraryDC</param> /// <param name="includeDll">Flag that indicates whether the DLL binaries should be included in the response.</param> /// <returns>List of activity libraries.</returns> public static List<ActivityLibraryDC> GetActivityLibraries(ActivityLibraryDC request, bool includeDll) { var reply = new List<ActivityLibraryDC>(); var status = new StatusReplyDC(); Database database = null; DbCommand command = null; string outErrorString = string.Empty; try { database = DatabaseFactory.CreateDatabase(); command = database.GetStoredProcCommand(StoredProcNames.ActivityLibraryGet); database.AddParameter(command, "@inCaller", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.Incaller); database.AddParameter(command, "@inCallerVersion", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.IncallerVersion); database.AddParameter(command, "@InId", DbType.Int32, ParameterDirection.Input, null, DataRowVersion.Default, request.Id); database.AddParameter(command, "@InGuid", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, Convert.ToString(request.Guid)); database.AddParameter(command, "@InName", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, Convert.ToString(request.Name)); database.AddParameter(command, "@InVersion", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, Convert.ToString(request.VersionNumber)); database.AddParameter(command, "@ReturnValue", DbType.Int32, ParameterDirection.ReturnValue, null, DataRowVersion.Default, 0); using (IDataReader reader = database.ExecuteReader(command)) { while (reader.Read()) { var activeLibraryDCreply = new ActivityLibraryDC(); activeLibraryDCreply.AuthGroupId = Convert.ToInt32(reader["AuthGroupId"]); activeLibraryDCreply.AuthGroupName = Convert.ToString(reader["AuthGroupName"]); activeLibraryDCreply.Category = (reader["Category"] == DBNull.Value) ? Guid.Empty : new Guid(Convert.ToString(reader["Category"])); activeLibraryDCreply.CategoryId = (reader["CategoryId"] == DBNull.Value) ? 0 : Convert.ToInt32(reader["CategoryId"]); activeLibraryDCreply.Description = Convert.ToString(reader["Description"]) ?? string.Empty; activeLibraryDCreply.Guid = (reader["Guid"] == DBNull.Value) ? Guid.Empty : new Guid(Convert.ToString(reader["Guid"])); activeLibraryDCreply.HasActivities = (reader["HasActivities"] == DBNull.Value) ? false : Convert.ToBoolean(reader["HasActivities"]); activeLibraryDCreply.Id = Convert.ToInt32(reader["Id"]); activeLibraryDCreply.ImportedBy = Convert.ToString(reader["ImportedBy"]); activeLibraryDCreply.MetaTags = Convert.ToString(reader["MetaTags"]) ?? string.Empty; activeLibraryDCreply.Name = Convert.ToString(reader["Name"]); activeLibraryDCreply.Status = (reader["Status"] == DBNull.Value) ? 0 : Convert.ToInt32(reader["Status"]); activeLibraryDCreply.StatusName = Convert.ToString(reader["StatusName"]); activeLibraryDCreply.VersionNumber = Convert.ToString(reader["VersionNumber"]); activeLibraryDCreply.FriendlyName = Convert.ToString(reader["FriendlyName"]); activeLibraryDCreply.ReleaseNotes = Convert.ToString(reader["ReleaseNotes"]); activeLibraryDCreply.HasExecutable = reader["Executable"] != DBNull.Value; if (includeDll) { activeLibraryDCreply.Executable = (reader["Executable"] == DBNull.Value) ? null : (byte[])reader["Executable"]; } reply.Add(activeLibraryDCreply); } } } catch (SqlException e) { e.HandleException(); } return reply; }
/// <summary> /// Performs input validation and gets activity libraries that match with search /// parameters while including assemblies with each activity library entry found. /// </summary> /// <param name="request">ActivityLibraryDC data contract.</param> /// <returns>List of ActivityLibraryDC.</returns> public static List<ActivityLibraryDC> GetActivityLibraries(ActivityLibraryDC request) { List<ActivityLibraryDC> reply = null; try { // Validates the input and throws ValidationException for any issues found. request.ValidateGetRequest(); // Gets the activity libraries that match search criteria. reply = ActivityLibraryRepositoryService.GetActivityLibraries(request, true); } catch (ValidationException e) { e.HandleException(); } catch (DataAccessException e) { e.HandleException(); } return reply; }
/// <summary> /// Performs input validation and 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 GetActivitiesByActivityLibraryNameAndVersionReplyDC GetActivitiesByActivityLibrary(GetActivitiesByActivityLibraryNameAndVersionRequestDC request, bool includeXaml) { var reply = new GetActivitiesByActivityLibraryNameAndVersionReplyDC(); try { // Validates the input and throws ValidationException for any issues found. request.ValidateRequest(); var newRequest = new GetLibraryAndActivitiesDC(); var activityLibraryDC = new ActivityLibraryDC(); var newReply = new List<GetLibraryAndActivitiesDC>(); activityLibraryDC.IncallerVersion = request.IncallerVersion; activityLibraryDC.Incaller = request.Incaller; activityLibraryDC.Name = request.Name; activityLibraryDC.VersionNumber = request.VersionNumber; newRequest.ActivityLibrary = activityLibraryDC; newReply = ActivityRepositoryService.GetActivitiesByActivityLibrary(newRequest, includeXaml); if (newReply != null && newReply.Count > 0) { reply.List = newReply[0].StoreActivitiesList; } } catch (ValidationException e) { e.HandleException(); } catch (DataAccessException e) { e.HandleException(); } return reply; }
/// <summary> /// Verify CreateOrUpdate FROM etblActivityLibraries Table. This will be a create since id is null. /// </summary> /// <param name="name">name to be created</param> /// <param name="description">description to do a create or update on.</param> /// <param name="version">version to do a create or update on.</param> /// <param name="authGroupName">authGroupName to do a create or update on.</param> /// <param name="categoryName">categoryName to do a create or update on.</param> /// <returns>returns the id created</returns> private int CreateActivityLibrariesWithNullID(string name, string description, string version, string authGroupName, string categoryName) { createOrUpdateRequest = new ActivityLibraryDC(); createOrUpdateReply = null; //Populate the request data createOrUpdateRequest.Incaller = IN_CALLER; createOrUpdateRequest.IncallerVersion = IN_CALLER_VERSION; createOrUpdateRequest.Guid = Guid.NewGuid(); createOrUpdateRequest.Name = name; createOrUpdateRequest.Description = description; createOrUpdateRequest.InsertedByUserAlias = USER; createOrUpdateRequest.UpdatedByUserAlias = USER; createOrUpdateRequest.VersionNumber = version; createOrUpdateRequest.AuthGroupName = authGroupName; createOrUpdateRequest.CategoryName = categoryName; createOrUpdateRequest.StatusName = STATUS; createOrUpdateRequest.Status = STATUSCODE; try { createOrUpdateReply = devBranchProxy.ActivityLibraryCreateOrUpdate(createOrUpdateRequest); } catch (FaultException e) { Assert.Fail("Failed to createOrUpdate data from etblActivityLibraries: {0}", e.Message); } catch (Exception ex) { Assert.Fail("Failed to createOrUpdate data from etblActivityLibraries: {0}", ex.Message); } Assert.IsNotNull(createOrUpdateReply, "ActivityLibraryDC object null"); Assert.IsNotNull(createOrUpdateReply.StatusReply, "createOrUpdateReply.StatusReply is null"); Assert.AreEqual(SprocValues.REPLY_ERRORCODE_VALUE_OK, createOrUpdateReply.StatusReply.Errorcode, "createOrUpdateReply.StatusReply.Errorcode is not 0. Instead it is {0}.", createOrUpdateReply.StatusReply.Errorcode); Assert.IsTrue(string.IsNullOrEmpty(createOrUpdateReply.StatusReply.ErrorMessage), "createOrUpdateReply.StatusReply.ErrorMessage is not null"); Assert.IsTrue(string.IsNullOrEmpty(createOrUpdateReply.StatusReply.ErrorGuid), "createOrUpdateReply.StatusReply.ErrorGuid is not null"); int id = GetActivityLibrariesForValidNameAndValidateForMaxID(name); GetActivityLibrariesForValidID(id); Assert.IsNotNull(getReplyList, "getReplyList is null."); Assert.AreNotEqual(0, getReplyList.Count, " getReply.List.Count is 0."); Assert.AreEqual(description, getReplyList[0].Description, "Description did not get inserted or updated correctly"); Assert.AreEqual(name, getReplyList[0].Name, "Name did not get inserted or updated correctly"); return id; }
/// <summary> /// Create activity library entry and store activity entries /// </summary> /// <param name="activityLibraryDC"></param> /// <param name="storeActivityDC"></param> private void CreateActivityLibraryAndStoreActivities(out ActivityLibraryDC activityLibraryDC, out List<StoreActivitiesDC> storeActivityDC) { List<StoreActivitiesDC> storeActivityRequestList = new List<StoreActivitiesDC>(); ActivityLibraryDC activityLibraryDCTemp = new ActivityLibraryDC(); // create activity library entry activityLibraryDCTemp.Incaller = IN_CALLER; activityLibraryDCTemp.IncallerVersion = IN_CALLER_VERSION; activityLibraryDCTemp.Guid = Guid.NewGuid(); activityLibraryDCTemp.Name = TEST_STRING; activityLibraryDCTemp.AuthGroupName = AUTH_GROUP_NAME2; activityLibraryDCTemp.CategoryName = CATEGORY_NAME2; activityLibraryDCTemp.Category = Guid.Empty; activityLibraryDCTemp.Executable = new byte[4]; activityLibraryDCTemp.HasActivities = true; activityLibraryDCTemp.ImportedBy = USER; activityLibraryDCTemp.Description = TEST_STRING; activityLibraryDCTemp.InsertedByUserAlias = USER; activityLibraryDCTemp.VersionNumber = VERSIONNUMBER1; activityLibraryDCTemp.UpdatedByUserAlias = USER; activityLibraryDCTemp.Status = STATUSCODE; activityLibraryDCTemp.StatusName = STATUS; // Create 40 store activities and let it crank for (int i = 0; i < 40; i++) { storeActivityRequestList.Add(CreateStoreActivity(STOREACTIVITYNAME, "3.1.0." + i, new Guid(), activityLibraryDCTemp.Name, activityLibraryDCTemp.VersionNumber)); } activityLibraryDC = activityLibraryDCTemp; storeActivityDC = storeActivityRequestList; }
/// <summary> /// The assembly name local location location to activity library dc. /// </summary> /// <param name="aai"> /// The assemblyLocationItems. /// </param> /// <returns> /// Converted ActivityLibraryDC instance /// </returns> public static ActivityLibraryDC AssemblyItemToActivityLibraryDataContract(ActivityAssemblyItem aai) { var activityLibrary = new ActivityLibraryDC(); activityLibrary.Name = aai.AssemblyName.Name; activityLibrary.VersionNumber = aai.Version.ToString(); // TODO: remove these activityLibrary.Incaller = Utility.GetCallerName(); activityLibrary.IncallerVersion = Utility.GetCallerVersion(); activityLibrary.Guid = Guid.NewGuid(); activityLibrary.AuthGroupName = aai.AuthorityGroup; activityLibrary.CategoryName = aai.Category ?? "OAS Basic Controls"; activityLibrary.Category = Guid.Empty; activityLibrary.Executable = new byte[4]; activityLibrary.HasActivities = false; activityLibrary.ImportedBy = Utility.GetCurrentUserName(); activityLibrary.Description = aai.Description; activityLibrary.Status = 1; return activityLibrary; }
private static ActivityLibraryDC GetActivityLibraryDC( string libraryName, string category, string description, string insertBy, string version, string status) { var library = new ActivityLibraryDC() { Name = libraryName, Executable = null, AuthGroupName = AuthorizationService.GetWorkflowAuthGroupName(), CategoryName = category, ImportedBy = Utility.GetCurrentUserName(), Description = description, InsertedByUserAlias = !String.IsNullOrEmpty(insertBy) ? insertBy : Utility.GetCurrentUserName(), VersionNumber = version, UpdatedByUserAlias = Utility.GetCurrentUserName(), Guid = Guid.NewGuid(), StatusName = status }; return library; }
public void GetActivityLibraryAndStoreActivities() { List<CWF.DataContracts.GetLibraryAndActivitiesDC> reply = null; CWF.DataContracts.GetLibraryAndActivitiesDC request = new CWF.DataContracts.GetLibraryAndActivitiesDC(); CWF.DataContracts.ActivityLibraryDC activityLibraryDC = new CWF.DataContracts.ActivityLibraryDC(); activityLibraryDC.IncallerVersion = INCALLERVERSION; activityLibraryDC.Incaller = INCALLER; activityLibraryDC.Name = "OASP.Core2"; activityLibraryDC.VersionNumber = "1.0.0.0"; activityLibraryDC.Id = 0; request.ActivityLibrary = activityLibraryDC; try { reply = ActivityRepositoryService.GetActivitiesByActivityLibrary(request, false); } catch (Exception ex) { string faultMessage = ex.Message; Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.DAL.Activities.GetActivityLibraryAndStoreActivities(request);"); } Assert.IsNotNull(reply); }
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); }
/// <summary> /// Verify GET FROM etblActivityLibraries Table for Invalid IDs /// </summary> /// <param name="nonExistingID">id of row to do a get on</param> private void VerifyGetActivityLibrariesForInvalidIDs(int nonExistingID) { getRequest = new ActivityLibraryDC(); // Populate Request getRequest.Incaller = IN_CALLER; getRequest.IncallerVersion = IN_CALLER_VERSION; getRequest.InsertedByUserAlias = USER; getRequest.UpdatedByUserAlias = USER; getRequest.Id = nonExistingID; getReplyList = new List<ActivityLibraryDC>(); try { getReplyList = new List<ActivityLibraryDC>(devBranchProxy.ActivityLibraryGet(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 = 0; // No error expected 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}.", nonExistingID, getReplyList.Count); Assert.IsNotNull(getReplyList[0].StatusReply, "getReply.StatusReply is null"); Assert.IsNull(getReplyList[0].StatusReply.ErrorMessage, "Error Message is null"); Assert.AreEqual(errorConstant, getReplyList[0].StatusReply.Errorcode, "Service returned unexpected error code. Expected: {0}, Returned: {1}", errorConstant, getReplyList[0].StatusReply.Errorcode); }
/// <summary> /// Verify GET FROM etblActivityLibraries Table for softDeleted IDs /// </summary> /// <param name="softDeletedID">id of row to do a get on</param> private void GetActivityLibrariesForSoftDeletedIDs(int softDeletedID) { getRequest = new ActivityLibraryDC(); getReplyList = new List<ActivityLibraryDC>(); //Populate the request data getRequest.Incaller = IN_CALLER; getRequest.IncallerVersion = IN_CALLER_VERSION; getRequest.Id = softDeletedID; try { getReplyList = new List<ActivityLibraryDC>(devBranchProxy.ActivityLibraryGet(getRequest)); } catch (FaultException e) { Assert.Fail("Failed to get data from etblActivityLibraries: {0}", e.Message); } catch (Exception ex) { Assert.Fail("Failed to get data from etblActivityLibraries: {0}", ex.Message); } int errorConstant = GetErrorConstantSoftDeletedID(); Assert.IsNotNull(getReplyList, "getReplyList is null"); Assert.AreEqual(1, getReplyList.Count, "Get returned the wrong number of entries. InId: {0}. It should have returned 1 but instead returned {1}.", softDeletedID, getReplyList.Count); Assert.IsNotNull(getReplyList[0].StatusReply, "getReply.Status is null"); Assert.AreEqual(errorConstant, getReplyList[0].StatusReply.Errorcode, "Returned the wrong status error code. InId: {0}.", softDeletedID); }
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); }
public void ActivityLibraryCreateANDUpdate() { CWF.DataContracts.ActivityLibraryDC reply = null; CWF.DataContracts.ActivityLibraryDC request = new CWF.DataContracts.ActivityLibraryDC(); //// UPDATE try { request.Incaller = INCALLER; request.IncallerVersion = INCALLERVERSION; request.Description = "In NEW Description"; request.Id = 100000; request.InsertedByUserAlias = INSERTEDBYUSERALIAS; request.UpdatedByUserAlias = UPDATEDBYUSERALIAS; try { reply = ActivityLibrary.ActivityLibraryCreateOrUpdate(request); } catch (Exception deleteEx) { string faultMessage = deleteEx.Message; Assert.Fail(faultMessage + "-catch (Exception deleteEx) in reply = CWF.DAL.Activities.ActivityLibraryCreateOrUpdate(request);"); } // TODO Unit testing fails(too many parameters) while TEST Harness works - Assert.AreEqual(reply.StatusReply.Errorcode, -60); //// update request.Guid = new Guid("ACE00000-0000-0000-0000-000000000000"); request.Name = "TEST#200"; request.AuthGroupName = "pqocwfauthors"; request.CategoryName = "OAS Basic Controls"; request.Category = Guid.Empty; request.Executable = new byte[4]; request.HasActivities = true; request.ImportedBy = "REDMOND\v-stska"; request.Description = "TEST DESCRIPTION"; request.InsertedByUserAlias = INCALLER; request.VersionNumber = "1.0.0.1"; request.Status = 990; request.UpdatedByUserAlias = "REDMOND\v-stska"; //// update try { reply = ActivityLibrary.ActivityLibraryCreateOrUpdate(request); } catch (Exception ex) { string faultMessage = ex.Message; Assert.Fail(faultMessage + "-catch (Exception ex) in reply = CWF.DAL.Activities.ActivityLibraryCreateOrUpdate(request);"); } Assert.IsNotNull(reply); // TODO Unit testing fails(too many parameters) while TEST Harness works - Assert.AreEqual(reply.StatusReply.Errorcode, SprocValues.UPDATE_INVALID_ID); } catch (Exception ex) { string faultMessage = ex.Message; // TODO Unit testing fails(too many parameters) while TEST Harness works - Assert.Fail(faultMessage + "-catch (Exception ex) in reply = CWF.DAL.Activities.ActivityLibraryCreateOrUpdate(request);"); } Assert.IsNotNull(reply); // TODO Unit testing fails(too many parameters) while TEST Harness works - Assert.AreEqual(reply.StatusReply.Errorcode, SprocValues.UPDATE_INVALID_ID); }
public void BALActivityLibraryGet() { CWF.DataContracts.ActivityLibraryDC request = new CWF.DataContracts.ActivityLibraryDC(); List<CWF.DataContracts.ActivityLibraryDC> reply = null; request.Incaller = INCALLER; request.IncallerVersion = INCALLERVERSION; try { reply = ActivityLibraryBusinessService.GetActivityLibraries(request); } catch (Exception ex) { string faultMessage = ex.Message; Assert.Fail(faultMessage + "-catch (Exception ex) in reply = Microsoft.Support.Workflow.Service.BusinessServices.ActivityLibraryBusinessService.ActivityLibraryGet(request);"); } Assert.IsNotNull(reply); Assert.AreEqual(reply[0].StatusReply.Errorcode, SprocValues.REPLY_ERRORCODE_VALUE_OK); }
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 GetMissingActivityLibraries() { var request = new CWF.DataContracts.GetMissingActivityLibrariesRequest(); var reply = new List<CWF.DataContracts.ActivityLibraryDC>(); CWF.DataContracts.ActivityLibraryDC activityLibraryDC = new CWF.DataContracts.ActivityLibraryDC(); activityLibraryDC.IncallerVersion = INCALLERVERSION; activityLibraryDC.Incaller = INCALLER; activityLibraryDC.Name = "OASP.Core2"; activityLibraryDC.VersionNumber = "1.0.0.0"; activityLibraryDC.Id = 0; request.Incaller = INCALLER; request.IncallerVersion = INCALLERVERSION; request.ActivityLibrariesList = new List<ActivityLibraryDC> { activityLibraryDC }; try { reply = ActivityLibraryRepositoryService.GetMissingActivityLibraries(request); } catch (Exception ex) { string faultMessage = ex.Message; Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.BAL.StoreActivityLibraryDependencies.StoreActivityLibraryDependencyList(request);"); } Assert.IsNotNull(reply); }
/// <summary> /// Verify CreateOrUpdate FROM etblActivityLibraries Table /// </summary> /// <param name="id"> id to do a create or update on. id is 0 if it will be a create.</param> /// <param name="name">name to do a create or update on.</param> /// <param name="description">description to do a create or update on.</param> /// <param name="version">version to do a create or update on.</param> /// <param name="authGroupName">authGroupName to do a create or update on.</param> /// <param name="categoryName">categoryName to do a create or update on.</param> private void CreateOrUpdateActivityLibraries(int id, string name, string description, string version, string authGroupName, string categoryName) { createOrUpdateRequest = new ActivityLibraryDC(); createOrUpdateReply = null; //Populate the request data createOrUpdateRequest.Incaller = IN_CALLER; createOrUpdateRequest.IncallerVersion = IN_CALLER_VERSION; createOrUpdateRequest.Id = id; createOrUpdateRequest.Guid = Guid.NewGuid(); createOrUpdateRequest.Name = name; createOrUpdateRequest.Description = description; createOrUpdateRequest.InsertedByUserAlias = USER; createOrUpdateRequest.UpdatedByUserAlias = USER; createOrUpdateRequest.VersionNumber = version; createOrUpdateRequest.AuthGroupName = authGroupName; createOrUpdateRequest.CategoryName = categoryName; createOrUpdateRequest.StatusName = STATUS; createOrUpdateRequest.Status = STATUSCODE; try { createOrUpdateReply = devBranchProxy.ActivityLibraryCreateOrUpdate(createOrUpdateRequest); } catch (FaultException e) { Assert.Fail("Failed to createOrUpdate data from etblActivityLibraries: {0}", e.Message); } catch (Exception ex) { Assert.Fail("Failed to createOrUpdate data from etblActivityLibraries: {0}", ex.Message); } Assert.IsNotNull(createOrUpdateReply, "ActivityLibraryDC object null"); Assert.IsNotNull(createOrUpdateReply.StatusReply, "createOrUpdateReply.StatusReply is null"); Assert.AreEqual(0, createOrUpdateReply.StatusReply.Errorcode, "createOrUpdateReply.StatusReply.Errorcode is not 0. Instead it is {0}.", createOrUpdateReply.StatusReply.Errorcode); Assert.IsTrue(string.IsNullOrEmpty(createOrUpdateReply.StatusReply.ErrorMessage), "createOrUpdateReply.StatusReply.ErrorMessage is not null"); Assert.IsTrue(string.IsNullOrEmpty(createOrUpdateReply.StatusReply.ErrorGuid), "createOrUpdateReply.StatusReply.ErrorGuid is not null"); }
/// <summary> /// Verify GET FROM etblActivityLibraries 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 VerifyGetActivityLibrariesForValidNameAndInvalidVersion(string name, string version) { getRequest = new ActivityLibraryDC(); getReplyList = null; //Populate the request data getRequest.Incaller = IN_CALLER; getRequest.IncallerVersion = IN_CALLER_VERSION; getRequest.Name = name; getRequest.VersionNumber = version; getReplyList = new List<ActivityLibraryDC>(devBranchProxy.ActivityLibraryGet(getRequest)); Assert.IsNotNull(getReplyList, "getReply.List is null"); Assert.AreEqual(0, getReplyList.Count, "Get returned the wrong number of entries. name: {0}, version: {1}. It should have returned 0 but instead returned {2}.", name, version, getReplyList.Count); }
/// <summary> /// Verify CreateOrUpdate FROM etblActivityLibraries Table for Invalid IDs. id is invalid if it's not 0 or not already in the table. /// </summary> /// <param name="id">id to try to insert or update</param> /// <param name="name">name to try to insert or update</param> /// <param name="description">description to do a create or update on.</param> /// <param name="version">version to do a create or update on.</param> /// <param name="authGroupName">authGroupName to do a create or update on.</param> /// <param name="categoryName">categoryName to do a create or update on.</param> private void CreateOrUpdateActivityLibrariesForInvalidIds(int id, string name, string description, string version, string authGroupName, string categoryName) { createOrUpdateRequest = new ActivityLibraryDC(); createOrUpdateReply = null; //Populate the request data createOrUpdateRequest.Incaller = IN_CALLER; createOrUpdateRequest.IncallerVersion = IN_CALLER_VERSION; createOrUpdateRequest.Id = id; createOrUpdateRequest.Guid = Guid.NewGuid(); createOrUpdateRequest.Name = name; createOrUpdateRequest.Description = description; createOrUpdateRequest.InsertedByUserAlias = USER; createOrUpdateRequest.UpdatedByUserAlias = USER; createOrUpdateRequest.VersionNumber = version; createOrUpdateRequest.AuthGroupName = authGroupName; createOrUpdateRequest.CategoryName = categoryName; createOrUpdateRequest.StatusName = STATUS; createOrUpdateRequest.Status = STATUSCODE; try { createOrUpdateReply = devBranchProxy.ActivityLibraryCreateOrUpdate(createOrUpdateRequest); } catch (FaultException e) { Assert.Fail("Failed to createOrUpdate data from etblActivityLibraries: {0}", e.Message); } catch (Exception ex) { Assert.Fail("Failed to createOrUpdate data from etblActivityLibraries: {0}", ex.Message); } int errorConstant = SprocValues.UPDATE_INVALID_ID; Assert.IsNotNull(createOrUpdateReply, "ActivityLibraryDC object null"); Assert.IsNotNull(createOrUpdateReply.StatusReply, "getReply.Status is null"); Assert.AreEqual(errorConstant, createOrUpdateReply.StatusReply.Errorcode, "Returned the wrong status error code. InId: {0}", id); Assert.IsNotNull(createOrUpdateReply.StatusReply.ErrorMessage, "createOrUpdateReply.StatusReply.ErrorMessage is null"); }
/// <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 etblActivityLibraries 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 GetActivityLibrariesForValidNameAndValidateForMaxID(string name) { getRequest = new ActivityLibraryDC(); getReplyList = new List<ActivityLibraryDC>(); //Populate the request data getRequest.Incaller = IN_CALLER; getRequest.IncallerVersion = IN_CALLER_VERSION; getRequest.Name = name; try { getReplyList = new List<ActivityLibraryDC>(devBranchProxy.ActivityLibraryGet(getRequest)); } catch (FaultException e) { Assert.Fail("Failed to get data from etblActivityLibraries: {0}", e.Message); } catch (Exception ex) { Assert.Fail("Failed to get data from etblActivityLibraries: {0}", ex.Message); } Assert.IsNotNull(getReplyList, "getReplyList is null"); Assert.AreNotEqual(0, getReplyList.Count, "Get returned the wrong number of entries. InName: {0}. It should not have returned 0.", name); Assert.IsNotNull(getReplyList[0].StatusReply, "getReplyList[0].StatusReply is null"); int index = getReplyList.Count - 1; int id = getReplyList[index].Id; return id; }
public void GetActivitiesByActivityLibrary() { List<CWF.DataContracts.GetLibraryAndActivitiesDC> reply = null; var request = new CWF.DataContracts.GetLibraryAndActivitiesDC(); var activityLibraryDC = new CWF.DataContracts.ActivityLibraryDC(); activityLibraryDC.IncallerVersion = INCALLERVERSION; activityLibraryDC.Incaller = INCALLER; activityLibraryDC.Name = "OASP.Core"; activityLibraryDC.VersionNumber = "2.2.108.0"; activityLibraryDC.Id = 0; request.ActivityLibrary = activityLibraryDC; try { reply = CWF.BAL.Services.GetLibraryAndActivities(request); } catch (Exception ex) { string faultMessage = ex.Message; Assert.Fail(faultMessage + "-catch (Exception ex) on reply = CWF.BAL.GetLibrary.GetLibraryAndActivities(request);"); } Assert.IsNotNull(reply); Assert.AreEqual(reply[0].StatusReply.Errorcode, 0); }
/// <summary> /// Verify GET FROM etblActivityLibraries Table for Valid guid /// </summary> /// <param name="guid">guid of row to do a get on</param> private void VerifyGetActivityLibrariesForValidGuid(Guid guid) { getRequest = new ActivityLibraryDC(); getReplyList = null; //Populate the request data getRequest.Incaller = IN_CALLER; getRequest.IncallerVersion = IN_CALLER_VERSION; getRequest.InsertedByUserAlias = USER; getRequest.UpdatedByUserAlias = USER; getRequest.Guid = guid; try { getReplyList = new List<ActivityLibraryDC>(devBranchProxy.ActivityLibraryGet(getRequest)); } catch (FaultException e) { Assert.Fail("Failed to get data from etblActivityLibraries: {0}", e.Message); } catch (Exception ex) { Assert.Fail("Failed to get data from etblActivityLibraries: {0}", ex.Message); } Assert.IsNotNull(getReplyList, "getReply.List is null"); Assert.AreEqual(1, getReplyList.Count, "Get returned the wrong number of entries. guid: {0}. It should have returned 1 but instead returned {1}.", guid, 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.Guid, getReplyList[0].Guid, "Get returned wrong data"); }
/// <summary> /// If the parameter request.InId is valid, it is an update, otherwise it is a create operation. /// </summary> /// <param name="request">request object</param> /// <returns>ActivityLibraryDC object</returns> public static ActivityLibraryDC ActivityLibraryCreateOrUpdate(ActivityLibraryDC request) { var reply = new ActivityLibraryDC(); var status = new StatusReplyDC(); int retValue = 0; Database db = null; DbCommand cmd = null; string outErrorString = string.Empty; try { db = DatabaseFactory.CreateDatabase(); cmd = db.GetStoredProcCommand(StoredProcNames.ActivityLibraryCreateOrUpdate); 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, "@InGUID", DbType.Guid, ParameterDirection.Input, null, DataRowVersion.Default, request.Guid); db.AddParameter(cmd, "@InName", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.Name); db.AddParameter(cmd, "@InAuthGroup", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.AuthGroupName); db.AddParameter(cmd, "@InCategoryGUID", DbType.Guid, ParameterDirection.Input, null, DataRowVersion.Default, request.Category); db.AddParameter(cmd, "@InCategoryName", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.CategoryName); db.AddParameter(cmd, "@InExecutable", DbType.Binary, ParameterDirection.Input, null, DataRowVersion.Default, request.Executable); db.AddParameter(cmd, "@InHasActivities", DbType.Boolean, ParameterDirection.Input, null, DataRowVersion.Default, request.HasActivities); db.AddParameter(cmd, "@InDescription", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.Description); db.AddParameter(cmd, "@InImportedBy", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.ImportedBy); db.AddParameter(cmd, "@InVersionNumber", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.VersionNumber); db.AddParameter(cmd, "@InMetaTags", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.MetaTags); db.AddParameter(cmd, "@InInsertedByUserAlias", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.InsertedByUserAlias); db.AddParameter(cmd, "@InUpdatedByUserAlias", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.UpdatedByUserAlias); db.AddParameter(cmd, "@InFriendlyName", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.FriendlyName); db.AddParameter(cmd, "@InReleaseNotes", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.ReleaseNotes); db.AddParameter(cmd, "@inStatusName", DbType.String, ParameterDirection.Input, null, DataRowVersion.Default, request.StatusName); db.AddParameter(cmd, "@ReturnValue", DbType.Int32, ParameterDirection.ReturnValue, null, DataRowVersion.Default, 0); db.AddOutParameter(cmd, "@outErrorString", DbType.String, 300); db.ExecuteScalar(cmd); retValue = Convert.ToInt32(cmd.Parameters["@ReturnValue"].Value); outErrorString = Convert.ToString(cmd.Parameters["@outErrorString"].Value); if (retValue != 0) { status.ErrorMessage = outErrorString; status.Errorcode = retValue; Logging.Log(retValue, EventLogEntryType.Error, SprocValues.ACTIVITY_LIBRARY_CREATE_OR_UPDATE_CALL_ERROR_MSG, outErrorString); } } catch (Exception ex) { status.ErrorMessage = SprocValues.ACTIVITY_LIBRARY_CREATE_OR_UPDATE_CALL_ERROR_MSG + ex.Message; status.Errorcode = SprocValues.GENERIC_CATCH_ID; Logging.Log(SprocValues.GENERIC_CATCH_ID, EventLogEntryType.Error, SprocValues.ACTIVITY_LIBRARY_CREATE_OR_UPDATE_CALL_ERROR_MSG, ex); } reply.StatusReply = status; return reply; }
/// <summary> /// Verify GET FROM etblActivityLibraries 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 VerifyGetActivityLibrariesForValidNameAndVersion(string name, string version) { getRequest = new ActivityLibraryDC(); getReplyList = new List<ActivityLibraryDC>(); VerifyGetForValidNameAndVersion(name, version, getRequest, getReplyList); }
/// <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> /// The activity library dc to activity assembly item. /// </summary> /// <param name="activityLibraryDC"> /// The activity library dc. /// </param> /// <param name="assemblyReferences"> /// Referenced assemblies for this ActivityLibraryDC. Use this parameter when you are actually downloading the library /// to cache and use, vs. just displaying it in a Select screen. It would be great if this info were actually part of /// ActivityLibraryDC but it isn't so we have to collect it separately. /// </param> /// <returns> /// Converted ActivityAssemblyItem instance /// </returns> public static ActivityAssemblyItem ActivityLibraryDCToActivityAssemblyItem(ActivityLibraryDC activityLibraryDC, IEnumerable<AssemblyName> assemblyReferences = null) { var activityAssemblyItem = new ActivityAssemblyItem(); Version version; activityAssemblyItem.ActivityItems = new ObservableCollection<ActivityItem>(); activityAssemblyItem.Assembly = null; activityAssemblyItem.AssemblyName = new AssemblyName(activityLibraryDC.Name); System.Version.TryParse(activityLibraryDC.VersionNumber, out version); activityAssemblyItem.Version = version; activityAssemblyItem.AuthorityGroup = activityLibraryDC.AuthGroupName; activityAssemblyItem.CachingStatus = CachingStatus.None; activityAssemblyItem.Category = activityLibraryDC.CategoryName; activityAssemblyItem.Description = activityLibraryDC.Description; activityAssemblyItem.DisplayName = activityLibraryDC.Name; activityAssemblyItem.Status = activityLibraryDC.StatusName; activityAssemblyItem.Tags = activityLibraryDC.MetaTags; if (assemblyReferences != null) { activityAssemblyItem.SetDatabaseReferences(assemblyReferences); } activityAssemblyItem.UserSelected = false; activityAssemblyItem.ReleaseNotes = activityLibraryDC.ReleaseNotes; activityAssemblyItem.FriendlyName = activityLibraryDC.FriendlyName; return activityAssemblyItem; }
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); }