/// <summary> /// Update (PUT) an artifact to a URL - usually the URL for an existing OSLC artifact /// </summary> /// <param name="url"></param> /// <param name="artifact"></param> /// <param name="mediaType"></param> /// <param name="acceptType"></param> /// <returns></returns> public HttpResponseMessage UpdateResource( string url, object artifact, string mediaType, string acceptType, Dictionary <String, String> headers) { client.DefaultRequestHeaders.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(acceptType)); client.DefaultRequestHeaders.Add(OSLCConstants.OSLC_CORE_VERSION, "2.0"); AddAuthorizationHeader(); foreach (KeyValuePair <string, string> entry in headers) { client.DefaultRequestHeaders.Add(entry.Key, entry.Value); } MediaTypeHeaderValue mediaTypeValue = new MediaTypeHeaderValue(mediaType); MediaTypeFormatter formatter = new MediaTypeFormatterCollection(formatters).FindWriter(artifact.GetType(), mediaTypeValue); HttpResponseMessage response = null; bool redirect = false; do { ObjectContent content = new ObjectContent(artifact.GetType(), artifact, formatter); content.Headers.ContentType = mediaTypeValue; // Write the content of the object to the log. The writing of the object is an async operation, so // will get compiler warning if not await execution. OK to proceed here, so avoid warning by assigning // variable. See also http://msdn.microsoft.com/en-us/library/hh873131.aspx. Task t = HandlerSettings.LogMessage("Object PUT: ", content, url, HandlerSettings.LoggingLevel.INFO); response = client.PutAsync(url, content).Result; if ((response.StatusCode == HttpStatusCode.MovedPermanently) || (response.StatusCode == HttpStatusCode.Moved)) { url = response.Headers.Location.AbsoluteUri; response.ConsumeContent(); redirect = true; } else { redirect = false; } } while (redirect); return(response); }
// Read TFS Filed names from config file public static bool initTFSFieldNames(XElement config) { String readProperties = ""; try { XElement fieldEntries = config.Element("tfsFields"); if (fieldEntries == null) { HandlerSettings.LogMessage( "No 'tfsFields' properties found - needed for connection. Exit.", HandlerSettings.LoggingLevel.ERROR); return(false); } TFS_STATE = fieldEntries.Element("state").Attribute("key").Value; TFS_SUBSTATE = fieldEntries.Element("subState").Attribute("key").Value; TFS_OWNER = fieldEntries.Element("owner").Attribute("key").Value; TFS_FAULTY_PRODUCT = fieldEntries.Element("faultyProduct").Attribute("key").Value; TFS_CUSTOMERS_AFFECTED = fieldEntries.Element("customersAffected").Attribute("key").Value; TFS_DUPLICATEID = fieldEntries.Element("duplicate").Attribute("key").Value; TFS_SUBSTATE_DUPLICATE = fieldEntries.Element("duplicateValue").Attribute("key").Value; TFS_HISTORY = fieldEntries.Element("history").Attribute("key").Value; TFS_DESCRIPTION = fieldEntries.Element("description").Attribute("key").Value; ERICSSON_DEFECT_STATE_FIELD = fieldEntries.Element("trState").Attribute("key").Value; ERICSSON_DEFECT_LINK_FIELD = fieldEntries.Element("trLink").Attribute("key").Value; ERICSSON_DEFECT_SYNCSTATE = fieldEntries.Element("trSyncState").Attribute("key").Value; ERICSSON_DEFECT_CREATETR = fieldEntries.Element("trCreate").Attribute("key").Value; } catch (Exception e) { HandlerSettings.LogMessage( String.Format( "Exception when getting a tfsField property: {0}. Exit." + "\nThe tfsField properties read before exception: {1}", e.Message, readProperties), HandlerSettings.LoggingLevel.ERROR); return(false); } HandlerSettings.LogMessage("The tfsField properties read: " + readProperties, HandlerSettings.LoggingLevel.INFO); return(true); }
public List <String> mapToEcr(String ecmProperty, WorkItem workItem) { List <String> mappedValues = new List <String>(); List <Property> properties = AttributesMapper.getInstance().getInverseProperties(ecmProperty); if (properties == null) { // Property has no inverse entry in mapping - inconsistent state HandlerSettings.LogMessage( String.Format("Property: {0} has no inverse entry in mapping file", ecmProperty), HandlerSettings.LoggingLevel.WARN); return(mappedValues); } foreach (Property property in properties) { // Get the TFS fieldName mapped to the ecmProperty String fieldName = property.getValue(); // Get the TFS fieldValue for the fieldName String fieldValue = getFieldValue(workItem, fieldName); // Handle "use" case String useMapping = property.getUseMapping(); if (useMapping != null && useMapping.Equals("ProductMapping")) { PRIMProduct primProduct = ProductMapper.getInstance().GetProduct(fieldValue); if (primProduct == null) { // No product found for release, so this is not a maintenance Bug. // Should likely have been caught before this, but return empty. return(mappedValues); } String useKey = property.getUseKey(); if (useKey != null) { if (useKey.Equals("primProdNo")) { mappedValues.Add(primProduct.getPrimProdNo()); } else if (useKey.Equals("primRState")) { mappedValues.Add(primProduct.getPrimRState()); } } return(mappedValues); } // Get or adjust the TFS value in case of complex mapping fieldValue = getTFSFieldValue(workItem, fieldName, fieldValue); // Lookup value in the property value map table. If mapped value is found, // this is added. Else if defaultValue is defined, this is used. Else the // fieldValue itself is returned. List <String> values = property.getInverse(fieldValue, workItem); if (values != null) { foreach (String mappedValue in values) { String adjustedValue = adjustTFSFieldValue(workItem, fieldName, mappedValue); mappedValues.Add(adjustedValue); } } } return(mappedValues); }