protected virtual void HandleRow(bool hasBackOffice, FieldElementSection rawDataFields, FieldElementSection metaDataFields, SqlCommand insertCommand, Dictionary <string, string> gatewayNameFields, XmlTextReader xmlReader) { InitalizeNullValues(insertCommand, rawDataFields, metaDataFields); InitalizeRawDataFromXml(rawDataFields, metaDataFields, insertCommand, xmlReader); InitalizeMetaDataParameters(insertCommand, xmlReader, hasBackOffice, gatewayNameFields); InsertRowToDB(insertCommand); }
/// <summary> /// Initalize the relevent field (fieldName) with fieldValue. /// </summary> /// <param name="fieldName">The name of the field to initalize.</param> /// <param name="fieldValue">The value of to set in the required field.</param> /// <param name="rawDataFields">FieldElementSection that contain all the required raw data fields from the DB.</param> /// <param name="insertCommand"></param> private void HandleNode(string fieldName, string fieldValue, FieldElementSection rawDataFields, SqlCommand insertCommand) { if (rawDataFields.Fields[fieldName] != null && rawDataFields.Fields[fieldName].InsertToDB && rawDataFields.Fields[fieldName].Enabled) { if (fieldValue != AnanlyticsNullValue) { insertCommand.Parameters["@" + rawDataFields.Fields[fieldName].DBFieldName].Value = Convert.ChangeType(fieldValue, Type.GetType(_tableTypeMappings[rawDataFields.Fields[fieldName].DBFieldType.ToLower()])); } else { // Initalize null value. if (rawDataFields.Fields[fieldName].DBDefaultValue == null) { insertCommand.Parameters["@" + rawDataFields.Fields[fieldName].DBFieldName].Value = DBNull.Value; } else { insertCommand.Parameters["@" + rawDataFields.Fields[fieldName].DBFieldName].Value = Convert.ChangeType(rawDataFields.Fields[fieldName].DBDefaultValue, Type.GetType(_tableTypeMappings[rawDataFields.Fields[fieldName].DBFieldType.ToLower()])); } } } }
/// <summary> /// Get all the fields from the xml row. when we get to the end of the row /// we initalzie null values and all the required meta data fields.s /// </summary> /// <remarks> /// Analytics works in nodes format and not attribute format like adwords. /// That mean that each row contain nodes which are the fields of the row. /// Each node that is dimension or metric is being handled. /// </remarks> /// <param name="hasBackOffice"></param> /// <param name="rawDataFields"></param> /// <param name="metaDataFields"></param> /// <param name="insertCommand"></param> /// <param name="gatewayNameFields"></param> /// <param name="xmlReader"></param> /// <param name="retriveredDate">Required date.</param> protected override void HandleRow(bool hasBackOffice, FieldElementSection rawDataFields, FieldElementSection metaDataFields, SqlCommand insertCommand, Dictionary <string, string> gatewayNameFields, XmlTextReader xmlReader) { switch (xmlReader.NodeType) { case XmlNodeType.Element: if (xmlReader.Name == "dxp:dimension" || xmlReader.Name == "dxp:metric") { HandleNode(xmlReader.GetAttribute("name"), xmlReader.GetAttribute("value"), rawDataFields, insertCommand); } break; case XmlNodeType.EndElement: // Arrived to end of row. if (xmlReader.Name.ToLower().Contains(XmlRowName.ToLower())) { //InitalizeNullValues(metaDataFields, insertCommand, xmlReader); InitalizeMetaDataParameters(insertCommand, xmlReader, hasBackOffice, gatewayNameFields); // Execute command. InsertRowToDB(insertCommand); } break; default: break; } }
protected virtual void InitalizeRawDataFromXml(FieldElementSection rawDataFields, FieldElementSection metaDataFields, SqlCommand insertCommand, XmlTextReader xmlReader) { // Initalize the insertCommand with the values from the xmlReader. foreach (FieldElement fe in rawDataFields.Fields) { if (!fe.InsertToDB || !fe.Enabled) { continue; } if (!String.IsNullOrEmpty(xmlReader.GetAttribute(fe.Value))) { insertCommand.Parameters["@" + fe.DBFieldName].Value = Convert.ChangeType(xmlReader.GetAttribute(fe.Value), Type.GetType(_tableTypeMappings[fe.DBFieldType.ToLower()])); InitalizeGatewayGK(insertCommand, xmlReader, fe); } else { InsertNullValue(insertCommand, fe); } } // Initalize Meta Data fields with null values. foreach (FieldElement fe in metaDataFields.Fields) { if (!fe.InsertToDB || !fe.Enabled) { continue; } InsertNullValue(insertCommand, fe); } }
private bool GetReport(FieldElementSection fieldsMapping, DateTime retrievedDay, string profileID, Dictionary <string, string> headers) { Log.Write(string.Format("run GAnalytics Retriever for account {0}, for date {1}.", Instance.AccountID.ToString(), retrievedDay.ToShortDateString()), LogMessageType.Information); string url = CreateGAnalyticsUrl(profileID, fieldsMapping, retrievedDay); string fileName = WriteResultToFile(url, retrievedDay, string.Empty, false, headers); return(SaveFilePathToDB(AnalyticsServiceType, fileName, retrievedDay, _adwordsFile)); }
/// <summary> /// New function for google adwords V13 that also use the app.config. /// The function get the report name and fetch the proper report type /// section from app.config with his info and his columns. /// </summary> /// <param name="type">The report name that exist in the app.config</param> /// <returns>A report with the relevent parameters</returns> private DefinedReportJob CreateReport(string name, string[] aggregationTypes) { Hashtable fields = new Hashtable(); DefinedReportJob job = new DefinedReportJob(); try { ReportTypesElementSection rtes = (ReportTypesElementSection)ConfigurationManager.GetSection("ReportTypes"); // Scan all the reports types till we find the chosen report. foreach (ReportTypesElement rte in rtes.Fields) { if (rte.Enabled && rte.Name == name) { // Load the proper report paramters by the report name. FieldElementSection fes = (FieldElementSection)ConfigurationManager.GetSection(rte.Name); // Initalize the hash table with the fields of the the report. foreach (FieldElement fe in fes.Fields) { if (fe.Enabled) { fields.Add(fe.Key, fe.Key); } } // Add the fields report to and string array useing IDictionaryEnumerator string[] columns = new string[fields.Count]; int count = 0; IDictionaryEnumerator dic = fields.GetEnumerator(); while (dic.MoveNext()) { columns[count] = dic.Value.ToString(); count++; } // Initalize the report with his info. job.selectedReportType = rte.Type; job.name = rte.Name; //job.aggregationTypes = new String[] { rte.Aggregation }; job.aggregationTypes = aggregationTypes; job.includeZeroImpression = true; job.includeZeroImpressionSpecified = true; job.selectedColumns = columns; break; } } } catch (Exception ex) { Log.Write("Error get configuration Data for the report.", ex); } return(job); }
/*=========================*/ #endregion #region protected override Methods /*================================*/ protected override bool InitalizeServiceData() { _fieldsMapping = (FieldElementSection)ConfigurationManager.GetSection (GetConfigurationOptionsField("FieldsMapping")); // Create Authentication Token string authToken = FetchAutoToken(); _headers.Add("Authorization", "GoogleLogin auth=" + authToken); return(base.InitalizeServiceData()); }
/// <summary> /// Initalize the Insert command with null values and than Initalize /// all his fields in the CSV file. /// </summary> /// <param name="filePath">CSV file path (used for errors logging).</param> /// <param name="headersDB"> A dictionary with table Fields and there /// types of AdWords table.</param> /// <param name="commonHeaders">A dictionary of the headers that exist /// in the DB and in CSV file with header name as key and numbering as value.</param> /// <param name="headersCSV">A dictionary of the headers in the CSV file /// with header name as key and numbering as value.</param> /// <param name="insertCommand">Insert command to initalize his field.</param> /// <param name="csvTextLine"> The current text line from the /// CSV file to insert to the DB.</param> /// <returns> True for success, False for failure.</returns> private void InitalizeInsertCommandFields(FieldElementSection rawDataFields, FieldElementSection metaDataFields, string filePath, Dictionary <string, int> headersCSV, SqlCommand insertCommand, string csvTextLine) { string[] FieldsValues = csvTextLine.Split('\t'); int accountID; int dayCode; int channelID = InitalizeMandatoryFields(filePath, headersCSV, insertCommand, FieldsValues, out accountID, out dayCode); // Delete old data for the DB for the same accountID, dayCode and channelID. DeleteOldData(accountID, channelID, dayCode); InitalizeRawDataFromXml(rawDataFields, metaDataFields, insertCommand, headersCSV, FieldsValues); InitalizeMandatoryFields(filePath, headersCSV, insertCommand, FieldsValues, out accountID, out dayCode); // Initalize GK fields InitalizeParametersGK(headersCSV, insertCommand, accountID, channelID, FieldsValues); }
protected virtual void InitalizeProcessData(out FieldElementSection rawDataFields, out FieldElementSection metaDataFields, out SqlCommand insertCommand, out Dictionary <string, string> gatewayNameFields) { // Get the sections with the fields for the insert command. rawDataFields = (FieldElementSection)ConfigurationManager.GetSection (GetConfigurationOptionsField("FieldsMapping")); metaDataFields = (FieldElementSection)ConfigurationManager.GetSection (GetConfigurationOptionsField("TableMapping")); // Initalize Insert command string sqlCmd = CreateInsertCmdString(_tableName, rawDataFields, metaDataFields); insertCommand = DataManager.CreateCommand(sqlCmd, CommandType.Text); insertCommand.CommandTimeout = 120; // Initalize a Dictionary with report fields & gateway Name Fields. gatewayNameFields = new Dictionary <string, string>(); InitalizeGatewayNameMapping(gatewayNameFields, "GatewayName"); }
/// <summary> /// Initalize the row raw data fields with values from the xml. /// And initalize Meta Data fields with null values. /// </summary> /// <param name="rawDataFields">Dictionary that contain all the required raw data fields from the DB.</param> /// <param name="metaDataFields">Dictionary that contain all the required Meta data fields from the DB.</param> /// <param name="insertCommand"></param> /// <param name="xmlReader"></param> protected void InitalizeRawDataFromXml(FieldElementSection rawDataFields, FieldElementSection metaDataFields, SqlCommand insertCommand, Dictionary <string, int> headersCSV, string[] FieldsValues) { try { // Initalize the insertCommand with the values from the xmlReader. foreach (FieldElement fe in rawDataFields.Fields) { if (!fe.InsertToDB || !fe.Enabled) { continue; } string dbFieldName = fe.DBFieldName.ToLower(); if ((headersCSV.ContainsKey(dbFieldName) && !String.IsNullOrEmpty(FieldsValues[headersCSV[dbFieldName]])) && dbFieldName != "matchtype") { insertCommand.Parameters["@" + fe.DBFieldName].Value = Convert.ChangeType(FieldsValues[headersCSV[dbFieldName]], Type.GetType(_tableTypeMappings[fe.DBFieldType.ToLower()])); } else { InsertNullValue(insertCommand, fe); } } // Initalize Meta Data fields with null values. foreach (FieldElement fe in metaDataFields.Fields) { if (!fe.InsertToDB || !fe.Enabled) { continue; } InsertNullValue(insertCommand, fe); } } catch (Exception ex) { string str = ex.Message; } }
//protected virtual void InitalizeNullValues(SqlCommand insertCommand, FieldElementSection rawDataFields, FieldElementSection metaDataFields) //{ //} protected virtual void InitalizeNullValues(SqlCommand insertCommand, FieldElementSection rawDataFields, FieldElementSection metaDataFields) { // Initalize the insertCommand null values for the fields in rawDataFields. foreach (FieldElement fe in rawDataFields.Fields) { if (!fe.InsertToDB || !fe.Enabled) { continue; } // Initalize field with null value. if (fe.DBDefaultValue == null) { insertCommand.Parameters["@" + fe.DBFieldName].Value = DBNull.Value; } else { insertCommand.Parameters["@" + fe.DBFieldName].Value = Convert.ChangeType(fe.DBDefaultValue, Type.GetType(_tableTypeMappings[fe.DBFieldType.ToLower()])); } } // Initalize the insertCommand null values for the fields in metaDataFields. foreach (FieldElement fe in metaDataFields.Fields) { if (!fe.InsertToDB || !fe.Enabled) { continue; } // Initalize field with null value. if (fe.DBDefaultValue == null) { insertCommand.Parameters["@" + fe.DBFieldName].Value = DBNull.Value; } else { insertCommand.Parameters["@" + fe.DBFieldName].Value = Convert.ChangeType(fe.DBDefaultValue, Type.GetType(_tableTypeMappings[fe.DBFieldType.ToLower()])); } } }
/// <summary> /// Get all the fields from the xml row. when we get to the end of the row /// we initalzie null values and all the required meta data fields. /// </summary> /// <remarks> /// Analytics works in nodes format and not attribute format like adwords. /// That mean that each row contain nodes which are the fields of the row. /// Each node that is dimension or metric is being handled. /// </remarks> /// <param name="hasBackOffice"></param> /// <param name="rawDataFields"></param> /// <param name="metaDataFields"></param> /// <param name="insertCommand"></param> /// <param name="gatewayNameFields"></param> /// <param name="xmlReader"></param> /// <param name="retriveredDate">Required date.</param> protected override void HandleRow(bool hasBackOffice, FieldElementSection rawDataFields, FieldElementSection metaDataFields, SqlCommand insertCommand, Dictionary <string, string> gatewayNameFields, XmlTextReader xmlReader) { string nodeName = string.Empty; // Loop on all the rows in the xml report file. switch (xmlReader.NodeType) { case XmlNodeType.Element: nodeName = xmlReader.Name; //Virtual function to handle the actual node value. If some processing is needed on this //value, inherit from this class, and override the HandleBackOfficeNode function. if (!xmlReader.Name.ToLower().Contains(_rowName)) { xmlReader.Read(); HandleBackOfficeNode(nodeName, xmlReader.Value, rawDataFields, insertCommand); } break; //case XmlNodeType.Text: // break; case XmlNodeType.EndElement: // Arrived to end of row. if (xmlReader.Name.ToLower().Contains(_rowName.ToLower())) { InitalizeMetaDataParameters(insertCommand, xmlReader, hasBackOffice, gatewayNameFields); // Execute command. insertCommand.ExecuteNonQuery(); InitalizeNullValues(insertCommand, rawDataFields, metaDataFields); } break; default: break; } }
/// <summary> /// Create GAnalytics url using the dimesnions (the nodes with attribute /// IsDimension="True") and metrics in the fieldsMapping and the date retrievedDay. /// </summary> /// <param name="profileID">The required profile id to get his data from Ganalytics.</param> /// <param name="fieldsMapping">Contain a section with the metrics and dimesions to insert to the url.</param> /// <param name="retrievedDay">The date to fetch the data added to the end of the url.</param> /// <returns></returns> private string CreateGAnalyticsUrl(string profileID, FieldElementSection fieldsMapping, DateTime retrievedDay) { try { char[] charsToTrim = { ',' }; string url = @"https://www.google.com/analytics/feeds/data?ids=ga:" + profileID + @"&dimensions="; // Add dimensions' fields foreach (FieldElement fe in fieldsMapping.Fields) { if (fe.Enabled && fe.IsDimension) { url += fe.Key + ","; } } // Remove last , url = url.TrimEnd(charsToTrim); url += @"&metrics="; // Add metrics fields foreach (FieldElement fe in fieldsMapping.Fields) { if (fe.Enabled && !fe.IsDimension) { url += fe.Key + ","; } } url = url.TrimEnd(charsToTrim); url += @"&sort=ga:date&start-date=" + ConvetDateTimeToString(retrievedDay) + "&end-date=" + ConvetDateTimeToString(retrievedDay); return(url); } catch (Exception ex) { throw new Exception("Error fetch data from the configuration.", ex); } }
private bool InitalizeReportMapping(ArrayList fields) { try { // Load the proper report paramters by the report name. FieldElementSection fes = (FieldElementSection)ConfigurationManager.GetSection("PanamaDailyReport"); // Initalize the hash table with the fields of the the report. foreach (FieldElement fe in fes.Fields) { if (fe.Enabled && fe.InsertToDB) { //fields.Add(fe.Key, fe.DBFieldName); fields.Add(fe.DBFieldName.ToString().ToLower()); } } } catch (Exception ex) { Log.Write("Error get configuration Data for the report.", ex, Instance.AccountID); return(false); } return(true); }
protected override void ReadFile(string filePath, string defaultErrorSubDirPath, bool hasBackOffice, ref bool xmlFileEmpty, FieldElementSection rawDataFields, FieldElementSection metaDataFields, SqlCommand insertCommand, Dictionary <string, string> gatewayNameFields) { // Initalzie headers Dictionaries. Dictionary <string, int> headersCSV = new Dictionary <string, int>(); accountList = new Dictionary <int, List <int> >(); using (StreamReader textReader = new StreamReader(filePath, Encoding.Unicode)) { // Read the headers of the CSV file and DB fields and return // a dictionary with the common headers. ReadHeaders(headersCSV, textReader); // Read first line in the CSV file. string csvTextLine = textReader.ReadLine(); if (csvTextLine == null) { Log.Write(string.Format("The file {0} is empty or not format in unicode txt.", filePath), LogMessageType.Error); Exception ex = new Exception(string.Format("The file {0} is empty or not format in unicode txt.", filePath)); WriteErrorMesageToFile(filePath, string.Empty, ex, DefaultErrorSubDirPath); throw ex; } // Read the CSV lines and insert them to the DB. while (!textReader.EndOfStream || !string.IsNullOrEmpty(csvTextLine)) { // Contiune if we have empty line in the csv file. if (csvTextLine == null || csvTextLine == string.Empty) { continue; } try { // Initalize the insert command with values from Csv text line. // InitalizeInsertCommandFields(filePath, headersDB, commonHeaders, headersCSV, insertCommand, csvTextLine, reportType); InitalizeInsertCommandFields(rawDataFields, metaDataFields, filePath, headersCSV, insertCommand, csvTextLine); insertCommand.ExecuteNonQuery(); InitalizeNullValues(insertCommand, rawDataFields, metaDataFields); } catch (Exception ex) { WriteErrorMesageToFile(filePath, csvTextLine, ex, DefaultErrorSubDirPath); } // Read the next line in the CSV file. csvTextLine = textReader.ReadLine(); } } }
/// <summary> /// Create a string which represents insert command from the configuration. /// The command created from 2 sections: mappingSection & tableSection. /// First we add the fields names and then we add there parmeters with their field type. /// </summary> /// <param name="tableName">The table name for the insert command.</param> /// <param name="rawDataFields"> This section in the configuration contain all the /// fields we get from the xmland map each field in the xml to a field in the db.</param> /// <param name="metaDataFields"> This section in the configuration contain all the /// fields of meta data like account_id, date, gk fields and etc.</param> /// <returns>insert command string.</returns> protected virtual string CreateInsertCmdString(string tableName, FieldElementSection rawDataFields, FieldElementSection metaDataFields) { try { char[] charsToTrim = { ',' }; string sqlCmd = "INSERT INTO " + tableName + "("; // Add fields' names // ============= // Add fields' names from mapping Section foreach (FieldElement fe in rawDataFields.Fields) { if (fe.Enabled && fe.InsertToDB) { sqlCmd += " " + fe.DBFieldName + ","; } } // Add the field names from table Section foreach (FieldElement fe in metaDataFields.Fields) { if (fe.Enabled && fe.InsertToDB) { sqlCmd += " " + fe.DBFieldName + ","; } } // Remove last , sqlCmd = sqlCmd.TrimEnd(charsToTrim); sqlCmd += ") VALUES ( "; // Add fields' values and types // ============================== // Add fields' values and types from mapping Section foreach (FieldElement fe in rawDataFields.Fields) { if (fe.Enabled && fe.InsertToDB) { sqlCmd += " @" + fe.DBFieldName + ":" + fe.DBFieldType + ","; } } // Add the field values from table Section foreach (FieldElement fe in metaDataFields.Fields) { if (fe.Enabled && fe.InsertToDB) { sqlCmd += " @" + fe.DBFieldName + ":" + fe.DBFieldType + ","; } } sqlCmd = sqlCmd.TrimEnd(charsToTrim); sqlCmd += ")"; return(sqlCmd); } catch (Exception ex) { throw new Exception("Error fetch data from the configuration.", ex); } }
/// <summary> /// Hi M8, This function create a Dictionary with the fields from the required /// section in the configuration. /// </summary> /// <param name="fields">A Dictionary that contain the fields from the required /// section in the configuration.</param> /// <param name="sectionName">The section name from the configuration to load.</param> protected virtual void InitalizeGatewayNameMapping(Dictionary <string, string> fields, string sectionName) { //*************************** // ANTI-YANIV HACK ServiceInstanceInfo targetInstance = Instance; string trackerParamsRaw = string.Empty; if (sectionName == "GatewayName") { while (targetInstance != null) { trackerParamsRaw = targetInstance.Configuration.Options["TrackingParameters"]; if (string.IsNullOrEmpty(trackerParamsRaw)) { targetInstance = targetInstance.ParentInstance; } else { break; } } if (trackerParamsRaw != null) { string[] trackerParamPairs = trackerParamsRaw.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries); foreach (string trackerParamPair in trackerParamPairs) { string[] pair = trackerParamPair.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); if (pair.Length < 2) { continue; } else { fields.Add(pair[0], pair[1]); } } // If we found anything ignore the rest of this horrible function if (fields.Count >= 1) //fix by alon changed from >1 to >=1 we need at least 1 25/11 { return; } } } // ANTI-YANIV HACK //*************************** try { // Load the proper report paramters by the report name. FieldElementSection fes = (FieldElementSection)ConfigurationManager.GetSection(sectionName); // Initalize the hash table with the fields of the the report. foreach (FieldElement fe in fes.Fields) { fields.Add(fe.Key, fe.Value); } } catch (Exception ex) { throw new Exception(String.Format("Error get configuration Data from {0} section.", sectionName), ex); } }
/// <summary> /// Initalize row with raw data from the xml and meta /// data (like gk fields) and insert the row to the DB. /// </summary> /// <param name="hasBackOffice">Indicate if the account have backoffice.</param> /// <param name="rawDataFields">Dictionary that contain all the required raw data fields from the DB.</param> /// <param name="metaDataFields">Dictionary that contain all the required Meta data fields from the DB.</param> /// <param name="insertCommand"></param> /// <param name="gatewayNameFields"></param> /// <param name="xmlReader"></param> /// <param name="retriveredDate">Required date.</param> protected virtual void HandleRow(bool hasBackOffice, FieldElementSection rawDataFields, FieldElementSection metaDataFields, SqlCommand insertCommand, Dictionary <string, string> gatewayNameFields, SourceDataRowReader <RetrieverDataRow> reader) { InitalizeRawDataFromXml(rawDataFields, metaDataFields, insertCommand, reader); InitalizeMetaDataParameters(insertCommand, reader, hasBackOffice, gatewayNameFields); InsertRowToDB(insertCommand); }
// original ReadFile function protected virtual void ReadFile(string xmlPath, string defaultErrorSubDirPath, bool hasBackOffice, ref bool xmlFileEmpty, FieldElementSection rawDataFields, FieldElementSection metaDataFields, SqlCommand insertCommand, Dictionary <string, string> gatewayNameFields) { bool firstRowInXml = true; using (XmlTextReader xmlReader = new XmlTextReader(xmlPath)) { xmlReader.WhitespaceHandling = WhitespaceHandling.None; // Read root node xmlReader.Read(); xmlFileEmpty = true; // Loop on all the rows in the xml report file. while (xmlReader.Read()) { if (!GetToRowsSection(xmlReader)) { continue; } // Initalize dayCode. if (firstRowInXml) { xmlFileEmpty = false; firstRowInXml = false; // ASAF: raise log error if we have diffrent date in the file and in _requiredDay. _requiredDay = DayCode.GenerateDateTime(GetDate(xmlReader)); if (_accountID == SystemAccountID) { GetAccountID(xmlReader.GetAttribute("acctname").ToString(), out _accountID, _accountFieldName); _accountName = xmlReader.GetAttribute("acctname").ToString(); } // Delete old data in the DB for the same data we fetch the new data. DataIdentifier dataIdentifier = new DataIdentifier(_accountID, GetDayCode(_requiredDay), _channelID); _dataIdentifiers.Add(dataIdentifier); HandleDeleteDay(); InitalizeNullValues(insertCommand, rawDataFields, metaDataFields); } CheckRowData(xmlReader); try { HandleRow(hasBackOffice, rawDataFields, metaDataFields, insertCommand, gatewayNameFields, xmlReader); } catch (Exception ex) { WriteErrorMesageToFile(xmlPath, xmlReader.ReadOuterXml(), ex, defaultErrorSubDirPath); } } } }
protected virtual void HandleBackOfficeNode(string nodeName, string nodeValue, FieldElementSection rawDataFields, SqlCommand insertCommand) { try { if (nodeName == String.Empty || nodeName == null) { throw new ArgumentException("Invalid node name. Cannot be null or empty."); } FieldElement fe = rawDataFields.Fields[nodeName]; //if (fe != null) // insertCommand.Parameters["@" + fe.DBFieldName].Value = // Convert.ChangeType(nodeValue, Type.GetType(_tableTypeMappings[fe.DBFieldType.ToLower()])); if (fe == null || !fe.InsertToDB || !fe.Enabled) { return; } if (!String.IsNullOrEmpty(nodeValue)) { insertCommand.Parameters["@" + fe.DBFieldName].Value = Convert.ChangeType(nodeValue, Type.GetType(_tableTypeMappings[fe.DBFieldType.ToLower()])); // Initalize Gateway_GK if (rawDataFields.Fields[nodeName].DBFieldName.ToLower() == "gateway_id") { insertCommand.Parameters["@Gateway_GK"].Value = GkManager.GetGatewayGK(_accountID, Convert.ToInt64(nodeValue)); } } else { // Initalize field with null value. if (fe.DBDefaultValue == null) { insertCommand.Parameters["@" + fe.DBFieldName].Value = DBNull.Value; } else { insertCommand.Parameters["@" + fe.DBFieldName].Value = Convert.ChangeType(fe.DBDefaultValue, Type.GetType(_tableTypeMappings[fe.DBFieldType.ToLower()])); } } } catch (Exception ex) { string str = ex.Message; } }
/*=========================*/ #endregion #region protected override Methods /*================================*/ /// <summary> /// Main entry point of the service. /// </summary> /// <returns></returns> protected override ServiceOutcome DoWork() { FieldElementSection fieldsMapping = (FieldElementSection)ConfigurationManager.GetSection (GetConfigurationOptionsField("FieldsMapping")); string profileID = GetConfigurationOptionsField("profileID"); // Create Authentication Token string authToken = FetchAutoToken(); Dictionary <string, string> headers = new Dictionary <string, string>(); headers.Add("Authorization", "GoogleLogin auth=" + authToken); ArrayList dates = new ArrayList(); if (CheckRangeDate(ref dates)) { int i; if (dates == null || dates.Count == 0) { return(ServiceOutcome.Failure); } for (i = 0; i < dates.Count && i < _maxInstancesReRuns; ++i) { GetReport(fieldsMapping, (DateTime)dates[i], profileID, headers); } // Write to the log all the dates that din;t eun because max instances ReRuns. if (i < dates.Count) { string errorMsg = "Can't write the following dates: "; for (int j = i; j < dates.Count; ++j) { errorMsg += ((DateTime)dates[j]).ToShortDateString() + ", "; } errorMsg += " because the service exceed the max instances ReRuns."; Log.Write(errorMsg, LogMessageType.Error); } if (_errorDates.Count > 0) { for (i = 0; i < _errorDates.Count; ++i) { GetReport(fieldsMapping, (DateTime)dates[i], profileID, headers); } } } else { DateTime retrievedDay = DateTime.Now.AddDays(-1); // Check if we need to get manual date. CheckManualDate(ref retrievedDay); if (!GetReport(fieldsMapping, retrievedDay, profileID, headers)) { return(ServiceOutcome.Failure); } } return(ServiceOutcome.Success); }
protected override void HandleBackOfficeNode(string nodeName, string nodeValue, FieldElementSection rawDataFields, SqlCommand insertCommand) { //If the node name is CODE, then we need to do some processing on the value. string boValue = nodeValue; if (nodeName.ToLower() == "code") { if (nodeValue.ToLower().Contains("esgn") && nodeValue.StartsWith("5137")) { //now build the new node value. boValue = "1"; int idx = nodeValue.IndexOf("esgn"); string value = nodeValue.Substring(idx + 4); boValue += value; } else { int val = -1; if (!Int32.TryParse(nodeValue, out val)) { boValue = "-1"; } } } if (nodeName.ToLower() == "refund") { if (nodeValue.Contains(".")) { double val = Convert.ToDouble(nodeValue); int iVal = Convert.ToInt32(val); boValue = iVal.ToString(); } } base.HandleBackOfficeNode(nodeName, boValue, rawDataFields, insertCommand); }
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { //ParentWorkflow.Parameters.Add("SourceFilePath", @"c:\temp\alerts\admin\report062009Monthly.csv"); //Parse the CSV file, and create the data structure for it. if (!ParentWorkflow.Parameters.ContainsKey("SourceFilePath")) { throw new Exception("Could not find the path of the CSV file."); } string fileName = ParentWorkflow.Parameters["SourceFilePath"].ToString(); if (!File.Exists(fileName)) { throw new FileNotFoundException("Could not find the CSV file at: " + fileName); } //creating list of accounts names to be reunite StreamReader sr = File.OpenText(fileName); string line = String.Empty; int count = 1; bool month = false; //Loop on the file, and build a hash-table per account. We assume that each //account only appears ONCE!. Hashtable ht = new Hashtable(); Dictionary <string, string> aggregatedAccountsProperties = new Dictionary <string, string>(); //getting aggregation information from configuration FieldElementSection fes = (FieldElementSection)ConfigurationManager.GetSection("AggregatedAccountsProperties"); bool isAccntExist = false; while (!sr.EndOfStream) { line = sr.ReadLine(); if (count == AccountAllMeasures.DATE_RANGE_ROW) { //Based on what's written in the line, see if we're a daily report //or a monthly report. if (line.ToLower().Contains("last month")) { month = true; } ParentWorkflow.InternalParameters.Add("Monthly", month); } if (count >= AccountAllMeasures.ADWORDS_CSV_START_ROW) { //We have reached the actual data... start parsing. AccountAllMeasures aam = new AccountAllMeasures(line); //Do not add empty accounts. if (aam.AccountName == String.Empty) { continue; } if (!ParentWorkflow.InternalParameters.ContainsKey("ReportDate")) { ParentWorkflow.InternalParameters.Add("ReportDate", aam.CompareDate); } if (aam.AccountName != String.Empty) { isAccntExist = false; //object section = ConfigurationManager.GetSection("AggregatedAccountsProperties"); //if configuration hasn't been already read if (aggregatedAccountsProperties.Count == 0) { // Initalize the dictionary with the properties of the accounts. foreach (FieldElement fe in fes.Fields) { string[] parsed = fe.Value.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); foreach (string st in parsed) { aggregatedAccountsProperties.Add(st, fe.Key); } } } if (aggregatedAccountsProperties.ContainsKey(aam.AccountName)) { sumAccounts(aam, aggregatedAccountsProperties[aam.AccountName], ref isAccntExist); } else { sumAccounts(aam, aam.AccountName, ref isAccntExist); } if (!isAccntExist) { //if destination account is not in _results we'll add the account that should be aggregated with destination name if (aggregatedAccountsProperties.ContainsKey(aam.AccountName)) { aam.AccountName = aggregatedAccountsProperties[aam.AccountName]; } _results.Add(aam); ht.Add(aam.AccountName, aam); } } } count++; } sr.Close(); sr.Dispose(); if (!ParentWorkflow.InternalParameters.ContainsKey("CSVResults")) { ParentWorkflow.InternalParameters.Add("CSVResults", ht); } try { File.Delete(fileName); } catch (Exception ex) { Console.WriteLine("Could not delete file: " + fileName + ". Exception: " + ex.ToString()); throw ex; } return(ActivityExecutionStatus.Closed); }