public DataTable PullData(WebProperties WebProps, IntegrationLog Log, DataTable Items, DateTime LastSynch)
{
DataTable dt = new DataTable();
return(dt);
}
public List <ColumnProperty> GetColumns(WebProperties WebProps, IntegrationLog Log, string ListName)
{
CheckArgumentForNull(WebProps, nameof(WebProps));
CheckArgumentForNull(ListName, nameof(ListName));
const string queryTemplate = "select name from sys.columns where object_id = object_id('{0}')";
var tableName = WebProps.Properties[PropKeyTable].ToString().Replace(Apostrophe, DoubleApostrophe);
var columnsList = new List <ColumnProperty>();
using (var connection = GetConnection(WebProps.Properties))
{
connection.Open();
using (var command = new SqlCommand(string.Format(queryTemplate, tableName), connection))
using (var dataReader = command.ExecuteReader())
{
while (dataReader.Read())
{
var colProperty = new ColumnProperty();
colProperty.ColumnName = dataReader.GetString(0);
colProperty.DiplayName = dataReader.GetString(0);
colProperty.DefaultListColumn = GetDefaultColumn(ListName, dataReader.GetString(0));
columnsList.Add(colProperty);
}
}
}
return(columnsList);
}
private bool BuildWSDL(WebProperties WebProps, IntegrationLog Log)
{
try
{
Uri uri = new Uri(WebProps.Properties["WSDL"].ToString());
//byte[] byteArray = Encoding.ASCII.GetBytes(WebProps.Properties["WSDL"].ToString());
//MemoryStream stream = new MemoryStream(byteArray);
WebRequest webRequest = WebRequest.Create(uri);
System.IO.Stream stream = webRequest.GetResponse().GetResponseStream();
ServiceDescription sd = ServiceDescription.Read(stream);
string sdName = sd.Services[0].Name;
// Initialize a service description servImport
ServiceDescriptionImporter servImport = new ServiceDescriptionImporter();
servImport.AddServiceDescription(sd, String.Empty, String.Empty);
servImport.ProtocolName = "Soap";
servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
CodeNamespace nameSpace = new CodeNamespace();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(nameSpace);
ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit);
if (warnings == 0)
{
using (var stringWriter = new StringWriter(CultureInfo.CurrentCulture))
{
var prov = new CSharpCodeProvider();
prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions());
var assemblyReferences = new string[2] {
"System.Web.Services.dll", "System.Xml.dll"
};
var param = new CompilerParameters(assemblyReferences)
{
GenerateExecutable = false,
GenerateInMemory = true,
TreatWarningsAsErrors = false,
WarningLevel = 4,
};
var results = new CompilerResults(new TempFileCollection());
results = prov.CompileAssemblyFromDom(param, codeCompileUnit);
var assembly = results.CompiledAssembly;
service = assembly.GetType(sdName);
methodInfo = service.GetMethods();
}
}
return(true);
}
catch (Exception ex)
{
Log.LogMessage(ex.Message, IntegrationLogType.Error);
}
return(false);
}
public Dictionary <string, string> GetDropDownValues(WebProperties webProps, IntegrationLog log, string property,
string parentPropertyValue)
{
var dictionary = new Dictionary <string, string>();
try
{
SfService sfService = GetSfService(webProps);
if (property.Equals("Object"))
{
dictionary = sfService.GetIntegratableObjects();
}
else if (property.Equals("UserMapType"))
{
return new Dictionary <string, string> {
{ "Email", "Email" }
}
}
;
throw new Exception("Invalid property: " + property);
}
catch (Exception e)
{
log.LogMessage(e.Message, IntegrationLogType.Error);
}
return(dictionary);
}
public List <ColumnProperty> GetColumns(WebProperties webProps, IntegrationLog log, string listName)
{
var columnProperties = new List <ColumnProperty>();
try
{
O365Service o365Service = GetO365Service(webProps);
var ignoredFields = new[]
{
"AppAuthor", "AppEditor", "Attachments", "DocIcon",
"ItemChildCount", "FolderChildCount", "_UIVersionString"
};
columnProperties.AddRange(
from field in o365Service.GetListFields(webProps.Properties["List"].ToString())
let internalName = field.InternalName
where !ignoredFields.Contains(internalName) &&
!internalName.StartsWith("LinkTitle") && !internalName.EndsWith("NoMenu")
orderby field.Title
select new ColumnProperty
{
ColumnName = internalName,
DiplayName = field.Title,
type = TranslateFieldType(field.FieldTypeKind),
DefaultListColumn = GetMatchingListColumn(internalName)
});
}
catch (Exception e)
{
log.LogMessage(e.Message, IntegrationLogType.Error);
}
return(columnProperties);
}
private static void GetAuthParameters(WebProperties webProps, out string username, out SecureString password,
out string siteUrl)
{
username = webProps.Properties["Username"].ToString();
if (string.IsNullOrEmpty(username))
{
throw new Exception("Please provide the username.");
}
string pwd = webProps.Properties["Password"].ToString();
if (string.IsNullOrEmpty(pwd))
{
throw new Exception("Please provide the password.");
}
password = pwd.ToSecureString();
siteUrl = webProps.Properties["SiteUrl"].ToString();
if (string.IsNullOrEmpty(siteUrl))
{
throw new Exception("Please provide the Office 365 site url.");
}
Uri uri;
if (!Uri.TryCreate(siteUrl, UriKind.RelativeOrAbsolute, out uri))
{
throw new Exception(siteUrl + " is not a valid url.");
}
}
public bool InstallIntegration(WebProperties webProps, IntegrationLog log, out string message,
string integrationKey,
string apiUrl)
{
message = string.Empty;
try
{
O365Service o365Service = GetO365Service(webProps);
o365Service.InstallIntegration(webProps.IntegrationId, integrationKey, apiUrl, webProps.Title,
webProps.FullURL, webProps.EnabledFeatures,
(string)webProps.Properties["List"],
bool.Parse((string)webProps.Properties["AllowAddInt"]),
bool.Parse((string)webProps.Properties["AllowAddList"]),
bool.Parse((string)webProps.Properties["AllowDeleteInt"]));
return(true);
}
catch (Exception e)
{
message = e.Message;
}
return(false);
}
public bool TestConnection(WebProperties webProps, IntegrationLog log, out string message)
{
message = string.Empty;
try
{
O365Service o365Service = GetO365Service(webProps);
if (!o365Service.EnsureEPMLiveAppInstalled())
{
log.LogMessage(
"Please make sure that you have installed the EPM Live app in your Office 365 environment.",
IntegrationLogType.Error);
return(false);
}
return(true);
}
catch (Exception e)
{
message = e.Message;
log.LogMessage(message, IntegrationLogType.Error);
return(false);
}
}
private static void GetAuthParameters(WebProperties webProps, out string username, out string password,
out string securityToken, out bool isSandbox)
{
username = webProps.Properties["Username"].ToString();
if (string.IsNullOrEmpty(username))
{
throw new Exception("Please provide the username.");
}
password = webProps.Properties["Password"].ToString();
if (string.IsNullOrEmpty(password))
{
throw new Exception("Please provide the password.");
}
securityToken = webProps.Properties["SecurityToken"].ToString();
if (string.IsNullOrEmpty(securityToken))
{
throw new Exception("Please provide the security token.");
}
try
{
isSandbox = bool.Parse(webProps.Properties["Sandbox"].ToString());
}
catch
{
isSandbox = false;
}
}
public TransactionTable UpdateItems(WebProperties WebProps, DataTable Items, IntegrationLog Log)
{
CheckArgumentForNull(WebProps, nameof(WebProps));
CheckArgumentForNull(Items, nameof(Items));
CheckArgumentForNull(Log, nameof(Log));
const string queryTemplate = "SELECT * FROM {0} WHERE {1}=@id";
var tableName = WebProps.Properties[PropKeyTable];
var idColumn = WebProps.Properties[PropKeyIdColumn];
var trans = new TransactionTable();
using (var connection = GetConnection(WebProps.Properties))
{
connection.Open();
foreach (DataRow drItem in Items.Rows)
{
var currentId = drItem[ColNameId].ToString();
var spId = drItem[ColNameSpid].ToString();
try
{
if (currentId == string.Empty)
{
trans.AddRow(spId, InsertRow(WebProps, drItem, Log, connection), TransactionType.INSERT);
}
else
{
var dataSet = new DataSet();
using (var command = new SqlCommand(string.Format(queryTemplate, tableName, idColumn), connection))
{
command.Parameters.AddWithValue("@id", currentId);
using (var dataAdapter = new SqlDataAdapter(command))
{
dataAdapter.Fill(dataSet);
}
}
if (dataSet.Tables.Count > 0 && dataSet.Tables[0].Rows.Count > 0)
{
trans.AddRow(spId, UpdateRow(WebProps, drItem, Log, connection), TransactionType.UPDATE);
}
else
{
trans.AddRow(spId, InsertRow(WebProps, drItem, Log, connection), TransactionType.INSERT);
}
}
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
Log.LogMessage(ex.Message, IntegrationLogType.Error);
trans.AddRow(spId, currentId, TransactionType.FAILED);
}
}
}
return(trans);
}
public void Initialize()
{
_shimsContext = ShimsContext.Create();
_testEntity = new Integrator();
_privateObject = new PrivateObject(_testEntity);
_privateType = new PrivateType(typeof(Integrator));
_actualLogMessage = new List <string>();
_integrationLog = new ShimIntegrationLog()
{
LogMessageStringIntegrationLogType = (log, level) => _actualLogMessage.Add(log)
};
_properties = new Hashtable()
{
{ "AllowDeleteInt", "true" },
{ "Username", DummyUsername },
{ "Password", DummyPassword },
{ "SecurityToken", DummySecurityToken }
};
_webProperties = new WebProperties()
{
Properties = _properties
};
ShimWebClient.AllInstances.UploadValuesStringStringNameValueCollection =
(_, address, method, data) => null;
ShimSfMedadataService.ConstructorStringStringStringStringBoolean =
(_, username, password, token, namespaceApp, sandbox) => { };
}
public TransactionTable UpdateItems(WebProperties WebProps, DataTable Items, IntegrationLog Log)
{
TransactionTable trans = new TransactionTable();
if (BuildWSDL(WebProps, Log))
{
MethodInfo Method = null;
foreach (MethodInfo t in methodInfo)
{
if (t.Name == WebProps.Properties["WSDLFunction"].ToString())
{
Method = t;
param = t.GetParameters();
break;
}
}
if (Method != null)
{
foreach (DataRow drItem in Items.Rows)
{
try
{
Hashtable hshProps = GetItemHash(WebProps, drItem);
object[] param1 = new object[param.Length];
int i = 0;
foreach (var p in param)
{
param1[i++] = Convert.ChangeType(hshProps[p.Name], p.ParameterType);
}
Object obj = Activator.CreateInstance(service);
Object response = Method.Invoke(obj, param1);
try
{
if (WebProps.Properties["LogInfo"].ToString() == "True")
{
Log.LogMessage("WSDL Response: " + response.ToString(), IntegrationLogType.Information);
}
}
catch { }
}
catch (Exception ex)
{
Log.LogMessage("Error sending item (" + drItem["SPID"].ToString() + "): " + ex.Message, IntegrationLogType.Error);
}
}
}
else
{
Log.LogMessage("Could not find method", IntegrationLogType.Error);
}
}
return(trans);
}
private Hashtable GetItemHash(WebProperties WebProps, DataRow drItem)
{
Hashtable hshProps = new Hashtable();
string wsdlmap = WebProps.Properties["WSDLMap"].ToString();
if (wsdlmap != "")
{
string[] sWSDLProps = wsdlmap.Replace("\r\n", "\n").Split('\n');
foreach (string sWSDLProp in sWSDLProps)
{
string wprop = sWSDLProp.Substring(0, sWSDLProp.IndexOf("="));
string wval = sWSDLProp.Substring(sWSDLProp.IndexOf("=") + 1);
if (wval.StartsWith("*"))//Array of Fields
{
string newVal = "<Items><Item><Fields>";
wval = wval.Substring(1);
string[] sFieldList = wval.Split(',');
foreach (string sField in sFieldList)
{
try
{
if (drItem.Table.Columns.Contains(sField))
{
newVal += "<Field Name=\"" + sField + "\"><![CDATA[" + drItem[sField].ToString() + "]]></Field>";
}
//hshProps.Add(sField, drItem[sField].ToString());
}
catch { }
}
newVal = newVal + "</Fields></Item></Items>";
hshProps.Add(wprop, newVal);
}
else//Field
{
foreach (Match match in Regex.Matches(wval, @"\[\w*\]"))
{
try
{
string sfield = match.Value.Trim(']').Trim('[');
wval = wval.Replace(match.Value, drItem[sfield].ToString());
}
catch { }
}
try
{
hshProps.Add(wprop, wval);
}
catch { }
}
}
}
return(hshProps);
}
// Public Methods (9)
public TransactionTable DeleteItems(WebProperties webProps, DataTable items, IntegrationLog log)
{
var transactionTable = new TransactionTable();
try
{
if (!bool.Parse((string)webProps.Properties["AllowDeleteInt"]))
{
throw new Exception("Office 365 delete is not allowed.");
}
O365Service o365Service = GetO365Service(webProps);
List <string> ids;
Dictionary <string, string> idMap = BuildIdMap(items, out ids);
int index = 0;
foreach (
O365Result result in
o365Service.DeleteListItemsById(ids.ToArray(), (string)webProps.Properties["List"]))
{
string o365Id = result.ItemId.ToString();
string spid;
try
{
spid = idMap[o365Id];
}
catch
{
spid = items.Rows[index]["SPID"].ToString();
}
if (result.Success)
{
transactionTable.AddRow(spid, o365Id, TransactionType.DELETE);
}
else
{
transactionTable.AddRow(spid, o365Id, TransactionType.FAILED);
log.LogMessage(string.Format(
"Could not delete record with Office 365 ID: {0}, SharePoint ID: {1}. Message: {2}",
o365Id, spid, result.Error), IntegrationLogType.Warning);
}
index++;
}
}
catch (Exception e)
{
log.LogMessage(e.Message, IntegrationLogType.Error);
}
return(transactionTable);
}
private O365Service GetO365Service(WebProperties webProps)
{
string username;
SecureString password;
string siteUrl;
GetAuthParameters(webProps, out username, out password, out siteUrl);
return(new O365Service(username, password, siteUrl));
}
private void PostAuthenticateRquest(object sender, EventArgs e)
{
HttpContext ctx = HttpContext.Current;
WebProperties webProperties = (WebProperties)ctx.Items[Constants.HttpRequestPropertiesKey];
if (webProperties == null)
{
return;
}
if ((ctx.User is ClaimsPrincipal) == false)
{
return;
}
ClaimsPrincipal claimsPrincipal = (ClaimsPrincipal)ctx.User;
if (claimsPrincipal.Identity == null)
{
return;
}
if (claimsPrincipal.Identity.IsAuthenticated == false)
{
return;
}
webProperties.Request.IsAuthenticated = true;
webProperties.Request.User = new UserDetails
{
Name = claimsPrincipal.Identity.Name,
};
ClaimsIdentity claimsIdentity = claimsPrincipal?.Identity as ClaimsIdentity;
if (claimsIdentity == null)
{
return;
}
List <KeyValuePair <string, string> > claims = DataParser.ToDictionary(claimsIdentity);
webProperties.Request.Properties.Claims = claims;
UserDetails user = KissLogConfiguration.Options.ApplyGetUser(webProperties.Request.Properties);
if (user != null)
{
user.Name = user.Name ?? claimsIdentity.Name;
}
webProperties.Request.User = user;
}
private static SfService GetSfService(WebProperties webProps)
{
string username;
string password;
string securityToken;
bool isSandbox;
GetAuthParameters(webProps, out username, out password, out securityToken, out isSandbox);
return(new SfService(username, password, securityToken, isSandbox));
}
public string FormatFlush(WebProperties webProperties)
{
string request = FormatBeginRequest(webProperties.Request);
string response = FormatEndRequest(webProperties.Request, webProperties.Response);
StringBuilder sb = new StringBuilder();
sb.AppendLine(request);
sb.Append(response);
return(sb.ToString());
}
public TransactionTable UpdateItems(WebProperties webProps, DataTable items, IntegrationLog log)
{
var transactionTable = new TransactionTable();
try
{
O365Service o365Service = GetO365Service(webProps);
List <string> ids;
Dictionary <string, string> idMap = BuildIdMap(items, out ids);
int index = 0;
foreach (
O365Result result in
o365Service.UpsertItems((string)webProps.Properties["List"], webProps.IntegrationId, items))
{
string o365Id = result.ItemId.ToString();
string spId;
try
{
spId = idMap[o365Id];
}
catch
{
spId = items.Rows[index]["SPID"].ToString();
}
if (result.Success)
{
transactionTable.AddRow(spId, o365Id, result.TransactionType);
}
else
{
transactionTable.AddRow(spId, o365Id, TransactionType.FAILED);
log.LogMessage(string.Format(
"Could not insert / update record with Office 365 ID: {0}, SharePoint ID: {1}. Message: {2}",
o365Id, spId, result.Error), IntegrationLogType.Warning);
}
index++;
}
}
catch (Exception e)
{
log.LogMessage(e.Message, IntegrationLogType.Error);
}
return(transactionTable);
}
private static ArgsResult CreateArgs(Logger[] loggers)
{
Logger defaultLogger = loggers.FirstOrDefault(p => p.CategoryName == Logger.DefaultCategoryName) ?? loggers.First();
LoggerDataContainer dataContainer = defaultLogger.DataContainer;
WebProperties webProperties = dataContainer.WebProperties;
string errorMessage = dataContainer.Exceptions.LastOrDefault()?.ExceptionMessage;
List <LogMessagesGroup> logMessages = new List <LogMessagesGroup>();
List <CapturedException> exceptions = new List <CapturedException>();
List <KeyValuePair <string, object> > customProperties = new List <KeyValuePair <string, object> >();
foreach (Logger logger in loggers)
{
logMessages.Add(new LogMessagesGroup
{
CategoryName = logger.CategoryName,
Messages = logger.DataContainer.LogMessages.ToList()
});
exceptions.AddRange(logger.DataContainer.Exceptions);
var properties = GetCustomProperties(logger);
customProperties.AddRange(properties);
}
exceptions = exceptions.Distinct(new CapturedExceptionComparer()).ToList();
if (defaultLogger.IsCreatedByHttpRequest() == false && exceptions.Any())
{
webProperties.Response.HttpStatusCode = System.Net.HttpStatusCode.InternalServerError;
}
webProperties.Response.EndDateTime = DateTime.UtcNow;
List <LoggerFile> files = dataContainer.LoggerFiles.GetFiles().ToList();
FlushLogArgs args = new FlushLogArgs
{
IsCreatedByHttpRequest = defaultLogger.IsCreatedByHttpRequest(),
WebProperties = webProperties,
MessagesGroups = logMessages,
CapturedExceptions = exceptions,
CustomProperties = customProperties
};
args.Files = files;
return(new ArgsResult
{
Args = args,
Files = files
});
}
private WebProperties CreateTestWebProperties()
{
var webProperties = new WebProperties();
webProperties.Properties = new Hashtable()
{
[PropKeyTable] = TableName,
[PropKeyIdColumn] = ColNameId
};
return(webProperties);
}
public DataTable GetItem(WebProperties WebProps, IntegrationLog Log, string ItemID, DataTable Items)
{
CheckArgumentForNull(WebProps, nameof(WebProps));
CheckArgumentForNull(ItemID, nameof(ItemID));
CheckArgumentForNull(Items, nameof(Items));
var tableName = WebProps.Properties[PropKeyTable];
var idColumn = WebProps.Properties[PropKeyIdColumn];
const string queryTemplate = "SELECT * FROM {0} WHERE {1} = '{2}'";
using (var connection = GetConnection(WebProps.Properties))
{
connection.Open();
var dataSet = new DataSet();
using (var command = new SqlCommand(string.Format(queryTemplate, tableName, idColumn, ItemID), connection))
using (var dataAdapter = new SqlDataAdapter(command))
{
dataAdapter.Fill(dataSet);
}
if (dataSet.Tables.Count > 0 && dataSet.Tables[0].Rows.Count > 0)
{
var dataRow = dataSet.Tables[0].Rows[0];
var valuesArray = new ArrayList();
valuesArray.Add(ItemID);
foreach (DataColumn dataColumn in Items.Columns)
{
if (dataColumn.ColumnName != ColNameId)
{
if (dataRow[dataColumn.ColumnName] != null)
{
valuesArray.Add(dataRow[dataColumn.ColumnName].ToString());
}
else
{
valuesArray.Add(string.Empty);
}
}
}
Items.Rows.Add(valuesArray.OfType <string>().ToArray());
}
}
return(Items);
}
public DataTable PullData(WebProperties WebProps, IntegrationLog Log, DataTable Items, DateTime LastSynch)
{
CheckArgumentForNull(WebProps, nameof(WebProps));
CheckArgumentForNull(Items, nameof(Items));
var dataSet = new DataSet();
using (var connection = GetConnection(WebProps.Properties))
{
connection.Open();
var colsBuilder = new StringBuilder(WebProps.Properties[PropKeyIdColumn].ToString());
var where = WebProps.Properties.ContainsKey(PropKeyWhere)
? WebProps.Properties[PropKeyWhere].ToString()
: string.Empty;
foreach (DataColumn dataColumn in Items.Columns)
{
if (dataColumn.ColumnName != ColNameId)
{
colsBuilder.Append($",{dataColumn.ColumnName}");
}
}
var query = $"SELECT {colsBuilder} FROM {WebProps.Properties[PropKeyTable]}";
if (where != string.Empty)
{
query = $"{query} Where {where.Replace(Apostrophe, DoubleApostrophe)}";
}
using (var command = new SqlCommand(query, connection))
using (var dataAdapter = new SqlDataAdapter(command))
{
dataAdapter.Fill(dataSet);
}
}
if (dataSet.Tables.Count == 0)
{
throw new InvalidOperationException("No tables returned from query");
}
var idColumn = WebProps.Properties[PropKeyIdColumn].ToString();
dataSet.Tables[0].Columns[idColumn].ColumnName = ColNameId;
return(dataSet.Tables[0]);
}
public bool TestConnection(WebProperties WebProps, IntegrationLog Log, out string Message)
{
try
{
Message = "";
SqlConnection cn = GetConnection(WebProps.Properties);
cn.Open();
cn.Close();
return(true);
}
catch (Exception ex) {
Message = "Error: " + ex.Message;
return(false);
}
}
public List <ColumnProperty> GetColumns(WebProperties WebProps, IntegrationLog Log, string ListName)
{
List <ColumnProperty> lstCols = new List <ColumnProperty>();
string[] cols = WebProps.Properties["Fields"].ToString().Split(',');
foreach (string col in cols)
{
ColumnProperty prop = new ColumnProperty();
prop.ColumnName = col;
prop.DiplayName = col;
lstCols.Add(prop);
}
return(lstCols);
}
public DataTable PullData(WebProperties webProps, IntegrationLog log, DataTable items, DateTime lastSynch)
{
try
{
SfService sfService = GetSfService(webProps);
sfService.GetObjectItems((string)webProps.Properties["Object"], items, lastSynch);
}
catch (Exception e)
{
log.LogMessage("Scheduled Pull. " + e.Message, e.Message.StartsWith("No records found")
? IntegrationLogType.Warning
: IntegrationLogType.Error);
}
return(items);
}
public DataTable GetItem(WebProperties webProps, IntegrationLog log, string itemId, DataTable items)
{
try
{
SfService sfService = GetSfService(webProps);
sfService.GetObjectItemsById((string)webProps.Properties["Object"], itemId, items);
}
catch (Exception e)
{
log.LogMessage(e.Message, e.Message.StartsWith("No records found")
? IntegrationLogType.Warning
: IntegrationLogType.Error);
}
return(items);
}
private string InsertRow(WebProperties WebProps, DataRow Item, IntegrationLog Log, SqlConnection cn)
{
string paramnames = "";
string paramvalues = "";
ArrayList arrparams = new ArrayList();
foreach (DataColumn dc in Item.Table.Columns)
{
if (dc.ColumnName != "ID" && dc.ColumnName != "SPID")
{
paramnames += dc.ColumnName + ",";
paramvalues += "@" + dc.ColumnName + ",";
if (Item[dc.ColumnName].ToString() == "")
{
arrparams.Add(new SqlParameter("@" + dc.ColumnName, DBNull.Value));
}
else
{
arrparams.Add(new SqlParameter("@" + dc.ColumnName, Item[dc.ColumnName].ToString()));
}
}
}
try
{
if (WebProps.Properties["SPColumn"].ToString() != "")
{
paramnames += WebProps.Properties["SPColumn"] + ",";
paramvalues += "@" + WebProps.Properties["SPColumn"] + ",";
arrparams.Add(new SqlParameter("@" + WebProps.Properties["SPColumn"], Item["SPID"].ToString()));
}
}
catch { }
string sql = "INSERT INTO " + WebProps.Properties["Table"] + "(" + paramnames.Trim(',') + ") OUTPUT Inserted." + WebProps.Properties["IDColumn"] + " VALUES (" + paramvalues.Trim(',') + ")";
object result;
using (var command = new SqlCommand(sql, cn))
{
command.Parameters.AddRange(arrparams.ToArray(typeof(SqlParameter)));
result = command.ExecuteScalar();
}
return(result?.ToString());
}
public bool RemoveIntegration(WebProperties webProps, IntegrationLog log, out string message,
string integrationKey)
{
message = string.Empty;
try
{
SfService sfService = GetSfService(webProps);
sfService.UninstallIntegration(integrationKey, webProps.Properties["Object"].ToString());
}
catch (Exception e)
{
message = e.Message;
}
return(true);
}
public Dictionary <String, String> GetDropDownValues(WebProperties WebProps, IntegrationLog log, string Property, string ParentPropertyValue)
{
Dictionary <string, string> props = new Dictionary <string, string>();
switch (Property)
{
case "UserMapType":
props.Add("Email", "Email Address");
props.Add("Username", "Username");
props.Add("SPID", "SharePoint User ID");
break;
case "AvailableSynchOptions":
props.Add("LI", "LI");
try
{
if (WebProps.Properties["WSDL"].ToString().Length > 0)
{
props.Add("LO", "LO");
props.Add("TI", "TI");
}
}
catch { }
break;
case "WSDLFunction":
if (BuildWSDL(WebProps, log))
{
foreach (MethodInfo t in methodInfo)
{
if (t.Name == "Discover")
{
break;
}
props.Add(t.Name, t.Name);
}
}
else
{
}
break;
}
return(props);
}
