/// <summary>
/// Creates a new instance of MessageResult
/// </summary>
/// <param name="result">Result</param>
/// <param name="callId">CallId</param>
/// <returns>returns a new instance of MessageResult</returns>
public static MessageResult CreateInstance(MethodResult result, string callId)
{
MessageResult msg = new MessageResult();
msg.result = result;
msg.callId = callId;
return msg;
}
public MethodParamPair(
MethodParamResult method,
Interfaces.IEventInput input, int nextMethod)
{
_result = MethodResult.None;
_method = method;
_params = input;
_exitPaths = new Dictionary<MethodResult, int>();
_exitPaths[MethodResult.Success] = nextMethod;
}
public MethodParamPair(
MethodParamResult method,
Interfaces.IEventInput input,
Collections.ExitPathGroup _paths)
{
_result = MethodResult.None;
_method = method;
_params = input;
_exitPaths = _paths;
}
private async Task <MethodResult <List <FortData> > > GetAllForts()
{
MethodResult <List <MapCell> > mapCellResponse = await GetMapObjects();
if (!mapCellResponse.Success)
{
return(new MethodResult <List <FortData> >
{
Data = new List <FortData>(),
Message = mapCellResponse.Message,
Success = mapCellResponse.Success
});
}
return(new MethodResult <List <FortData> >
{
Data = mapCellResponse.Data.SelectMany(x => x.Forts).ToList(),
Success = mapCellResponse.Success,
Message = mapCellResponse.Message
});
}
private async void TransferToolStripMenuItem_Click(object sender, EventArgs e)
{
DialogResult result = MessageBox.Show(String.Format("Are you sure you want to transfer {0} pokemon?", fastObjectListViewPokemon.SelectedObjects.Count), "Confirmation", MessageBoxButtons.YesNo);
if (result != DialogResult.Yes)
{
return;
}
contextMenuStripPokemonDetails.Enabled = false;
MethodResult managerResult = await _manager.TransferPokemon(fastObjectListViewPokemon.SelectedObjects.Cast <PokemonData>());
DisplayDetails();
contextMenuStripPokemonDetails.Enabled = true;
fastObjectListViewPokemon.SetObjects(_manager.Pokemon);
MessageBox.Show("Finished transferring pokemon");
}
public MethodResult <Asset> AddAsset(string serialNumber, string name, string description, int customerId)
{
var existingAsset = _assetRepository.GetBySerialNumberForCustomer(serialNumber, customerId);
if (existingAsset != null)
{
return(MethodResult <Asset> .CreateFaultedResult("The asset is already created."));
}
var newAsset = new Asset
{
SerialNumber = serialNumber,
Name = name,
Description = description,
CustomerId = customerId
};
_assetRepository.Add(newAsset);
return(new MethodResult <Asset>(newAsset));
}
public ActionResult Vacuum()
{
Database db = new Database(ConfigurationManager.AppSettings["dbPath"]);
if (db.IsDataBaseExist())
{
MethodResult res = db.Vacuum();
if (res.isSuccess)
{
return(Content("<div class='text-success'>Выполнено успешно!</div>"));
}
else
{
return(Content("<div class='text-danger'>Ошибки:</div> " + res.Message));
}
}
else
{
return(Content("База данных не обнаружена " + db.GetFilePath));
}
}
public static MethodResult sendSMSEventInviteViaTextLocal(string countryCode, string contactNumber, string hostname, string eventName)
{
Boolean smsInviteEnabled = Boolean.Parse(ConfigurationManager.AppSettings["SMSInviteEnabled"].ToString());
MethodResult mr = new MethodResult();
if (!smsInviteEnabled)
{
mr.Status = false;
mr.Message = "Sms Invite is Disabled in Web API.";
return(mr);
}
String textLocalMessage = ConfigurationManager.AppSettings["TextLocalSMSEventInviteTemplate1"].ToString();
if (hostname.Length > 20)
{
hostname = hostname.Substring(0, 20);
}
textLocalMessage = textLocalMessage.Replace("$hostName$", hostname);
textLocalMessage = textLocalMessage.Replace("$eventName$", eventName);
return(sendSMSViaTextLocalGeneric(countryCode, contactNumber, textLocalMessage));
}
public static async Task <MethodResult <T> > TryAsync <T>(
Func <Task <MethodResult <T> > > function,
int numOfTry)
{
var counter = 0;
while (true)
{
try {
return(await function());
}
catch (Exception e) {
counter++;
if (counter >= numOfTry)
{
return(MethodResult <T> .Fail(new ExceptionError(e,
moreDetails : new { numOfTry })));
}
}
}
}
public IActionResult UpdateStatus([FromBody] StatusModel model)
{
MethodResult result = new MethodResult()
{
IsSuccessful = true
};
if (model.Running)
{
result = _insepectionService.Inspect();
if (result.IsSuccessful)
{
_worker.Start();
}
}
else
{
_worker.Stop();
}
return(Ok(result));
}
public void GetReplicationDataInvalidDateTest()
{
//create a new instance of the method input class found in ConnectorApi.Actions
//Assign the MethodInput name to the Name of the method to be executed
MethodInput methodInput = new MethodInput {
Name = "GetReplicationData"
};
//set the object name by adding the property to the input
methodInput.Input.Properties.Add("ObjectName", "SalesOrders");
//set the Last date of syncronization by adding the property to the input
methodInput.Input.Properties.Add("LastSyncDate", InvalidPropertyValue);
//execute the selected method
MethodResult result = _rsSourceConnector.ExecuteMethod(methodInput);
Assert.IsFalse(result.Success);
Assert.IsNotNull(result.ErrorInfo);
}
private List <PokemonData> GetPokemonBelowCPIVAmount(IGrouping <PokemonId, PokemonData> pokemon, int minCp, double percent)
{
List <PokemonData> toTransfer = new List <PokemonData>();
foreach (PokemonData pData in pokemon)
{
MethodResult <double> perfectResult = CalculateIVPerfection(pData);
if (!perfectResult.Success)
{
continue;
}
if (perfectResult.Data >= 0 && perfectResult.Data < percent && pData.Cp < minCp)
{
toTransfer.Add(pData);
}
}
return(toTransfer);
}
public JsonResult CanReceiveProductGifts(int destinationID)
{
try
{
var source = SessionHelper.CurrentEntity;
var destination = entityRepository.GetById(destinationID);
MethodResult result = giftService.CanReceiveProductGifts(source, destination);
if (result.IsError)
{
return(JsonData(new { result = false, error = result.Errors[0] }));
}
return(JsonData(new { result = true, error = "" }));
}
catch (Exception e)
{
return(JsonError("Undefined error!"));
}
}
internal static async Task <MethodResult> VerifyTask(Model account, HttpClient client)
{
var methodResult = new MethodResult();
try
{
var keyValuePairArray = new KeyValuePair <string, string>[3]
{
new KeyValuePair <string, string>("csrfmiddlewaretoken", account.Csrf),
new KeyValuePair <string, string>("username", account.Username),
new KeyValuePair <string, string>("password", account.Password)
};
if (!client.DefaultRequestHeaders.Contains("Referer"))
{
client.DefaultRequestHeaders.Add("Referer", Activated);
}
using (
var httpResponseMessage =
await client.PostAsync(Activated, new FormUrlEncodedContent(keyValuePairArray)))
{
if (httpResponseMessage.IsSuccessStatusCode)
{
methodResult.Value = await httpResponseMessage.Content.ReadAsStringAsync();
methodResult.Success = true;
}
else
{
methodResult.Error = new Exception("Failed to re-verify");
}
}
}
catch (Exception ex)
{
methodResult.Error = ex;
methodResult.Success = false;
}
return(methodResult);
}
internal static async Task <MethodResult> SubmitTosTask(Model account, HttpClient client)
{
var methodResult = new MethodResult();
try
{
var keyValuePairArray = new KeyValuePair <string, string>[2]
{
new KeyValuePair <string, string>("csrfmiddlewaretoken", account.Csrf),
new KeyValuePair <string, string>("go_terms", "on")
};
using (
var httpResponseMessage =
await client.PostAsync(GoSettings, new FormUrlEncodedContent(keyValuePairArray)))
{
if (httpResponseMessage.IsSuccessStatusCode)
{
var result = await httpResponseMessage.Content.ReadAsStringAsync();
methodResult.Value = result;
if (!result.ToLower().Contains("id_go_terms"))
{
methodResult.Success = true;
}
else
{
methodResult.Error = new Exception("Failed to submit terms of service");
}
}
}
}
catch (Exception ex)
{
methodResult.Error = ex;
methodResult.Success = false;
}
return(methodResult);
}
private void DownloadButton_Click(object sender, EventArgs e)
{
Dac dac = new Dac();
DataTable userDataTable = dac.ExecuteDataTable("SELECT * FROM User").Result;
decimal progress = 0;
foreach (DataRow dr in userDataTable.Rows)
{
IUser user = TwitterEngine.User.FindUserFromUserName((string)dr["UserName"]).Result;
if (user == null)
{
continue;
}
progress++;
ProgressbarDescriptionLabel.Text = user.Name;
ProgressBar.Value = (int)((progress / userDataTable.Rows.Count) * 100);
MethodResult <int> result = DbHelper.SaveTweetList(user.GetUserTimeline((int)TweetCountNumericUpDown.Value).ToList <ITweet>());
if (result.IsSuccessful)
{
//ProgressbarDescriptionLabel.Text = user.Name + " : " + result.Result.ToString() + " Tweets Saved :-)";
ResultsTextBox.Text += Environment.NewLine + user.Name + " : " + result.Result.ToString() + " Tweets Saved :-)";
//MessageBox.Show(user.Name + " : " + result.Result.ToString() + " Tweets Saved :-)", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
ProgressbarDescriptionLabel.Text = user.Name + " : " + "Save Error :-(";
ResultsTextBox.Text += Environment.NewLine + user.Name + " : " + "Save Error :-(";
ProgressBar.Value = 0;
MessageBox.Show(user.Name + " : " + "Save Error :-(" + Environment.NewLine + result.Exception.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
ProgressbarDescriptionLabel.Text = "Finished";
ResultsTextBox.Text += Environment.NewLine + "Finished";
ProgressBar.Value = 100;
}
private async Task <MethodResult> EvolveFilteredPokemon()
{
MethodResult <List <PokemonData> > response = await GetPokemonToEvolve();
if (response.Data.Count == 0)
{
return(new MethodResult());
}
LogCaller(new LoggerEventArgs(String.Format("{0} pokemon to evolve", response.Data.Count), LoggerTypes.Info));
if (response.Data.Count < UserSettings.MinPokemonBeforeEvolve)
{
LogCaller(new LoggerEventArgs(String.Format("Not enough pokemon to evolve. {0} of {1} evolvable pokemon", response.Data.Count, UserSettings.MinPokemonBeforeEvolve), LoggerTypes.Info));
return(new MethodResult
{
Message = "Success",
Success = true
});
}
if (UserSettings.UseLuckyEgg)
{
MethodResult result = await UseLuckyEgg();
if (!result.Success)
{
LogCaller(new LoggerEventArgs("Failed to use lucky egg. Possibly already active. Continuing evolving", LoggerTypes.Info));
}
}
await EvolvePokemon(response.Data);
return(new MethodResult
{
Success = true,
Message = "Success"
});
}
public async Task <MethodResult> AcLogin()
{
LogCaller(new LoggerEventArgs("Attempting to login ...", LoggerTypes.Debug));
AccountState = AccountState.Conecting;
MethodResult result = null;
result = await _client.DoLogin(this);
LogCaller(new LoggerEventArgs(result.Message, LoggerTypes.Debug));
if (!result.Success)
{
LogCaller(new LoggerEventArgs(result.Message, LoggerTypes.FatalError));
if (AccountState == AccountState.Conecting || AccountState == AccountState.Good)
{
AccountState = AccountState.Unknown;
}
Stop();
}
else
{
if (AccountState == AccountState.Conecting)
{
AccountState = AccountState.Good;
}
// This is part of the login process
if (UserSettings.ClaimLevelUpRewards)
{
await ClaimLevelUpRewards(Level);
}
}
if (CurrentProxy != null)
{
ProxyHandler.ResetFailCounter(CurrentProxy);
}
return(result);
}
public async Task <MethodResult> GetPlayer(bool nobuddy = true, bool noinbox = true)
{
try
{
if (!_client.LoggedIn)
{
MethodResult result = await AcLogin();
if (!result.Success)
{
return(result);
}
}
var response = await _client.ClientSession.RpcClient.SendRemoteProcedureCallAsync(new Request {
RequestType = RequestType.GetPlayer,
RequestMessage = new GetPlayerMessage {
PlayerLocale = new GetPlayerMessage.Types.PlayerLocale {
Country = UserSettings.PlayerLocale.Country,
Language = UserSettings.PlayerLocale.Language,
Timezone = UserSettings.PlayerLocale.Timezone
}
}.ToByteString()
}, true, nobuddy, noinbox);
var parsedResponse = GetPlayerResponse.Parser.ParseFrom(response);
return(new MethodResult
{
Success = true
});
}
catch (Exception ex)
{
LogCaller(new LoggerEventArgs("Failed to get level up rewards", LoggerTypes.Exception, ex));
return(new MethodResult());
}
}
/// <returns>Virtual path to the file with extension</returns>
public MethodResult <string> UploadImage(HttpPostedFileBase file, UploadLocationEnum location, bool enableSizeValidation = true)
{
MethodResult <string> result = MethodResult <string> .Success;
if (file == null || file.ContentLength == 0)
{
throw new UserReadableException("File is empty or does not exist");
}
var tempPath = Path.GetTempFileName();
file.SaveAs(tempPath);
Image img = Image.FromFile(tempPath);
if (enableSizeValidation)
{
result.Merge(checkIfImageIsCorrect(img));
}
if (result.IsError)
{
return(result);
}
var fileName = GetUniqueFilePath(location, ".png");
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
var imageFile = File.Create(fileName);
img.Save(imageFile, ImageFormat.Png);
img.Dispose();
File.Delete(tempPath);
imageFile.Close();
result.ReturnValue = "\\" + fileName.Replace(HttpContext.Current.Request.ServerVariables["APPL_PHYSICAL_PATH"], string.Empty);
return(result);
}
public static async Task <MethodResult <BaseSettings> > Load(this ISettings settings, string moduleName)
{
var methodResult = new MethodResult <BaseSettings> {
MethodName = "SettingExtension.Load"
};
;
try
{
var content = await GetFileContent($"{settings.PluginSettingsBaseDirectory}/{moduleName}.json");
var loadedSettings = JsonConvert.DeserializeObject <BaseSettings>(content);
settings.Enabled = loadedSettings.Enabled;
}
catch (Exception e)
{
methodResult.Error = e;
methodResult.Success = false;
}
return(methodResult);
}
public MethodResult <int> NewUser(string username, string email, string password, HashSet <Role> roles)
{
using (var context = new SecurityContext())
{
var repo = new UserRepository(context);
User user = repo.Find(x => x.Username == username, null).FirstOrDefault();
if (user == null)
{
HashSet <Role> _roles = new HashSet <Role>();
foreach (var ro in roles)
{
var _role = repo.GetRole(ro.RoleTitle);
if (_role == null)
{
_role = new Role()
{
RoleTitle = ro.RoleTitle
};
}
_roles.Add(_role);
}
user = new User(username, email, _roles);
user.Password = Infrastructure.Utilites.Security.CalculateHash(password, user.Username);
repo.Add(user);
}
else
{
throw new ArgumentException("Пользователь с таки именем существует", "User");
}
repo.Save();
var result = new MethodResult <int>(0);
return(result);
}
}
public void GetReplicationDataInvalidObjectTest()
{
//create a new instance of the method input class found in ConnectorApi.Actions
//Assign the MethodInput name to the Name of the method to be executed
MethodInput methodInput = new MethodInput {
Name = "GetReplicationData"
};
//set the object name by adding the property to the input
methodInput.Input.Properties.Add("ObjectName", InvalidPropertyValue);
//set the Last date of syncronization by adding the property to the input
methodInput.Input.Properties.Add("LastSyncDate", DateTime.Now.AddYears(-5));
//execute the selected method
MethodResult methodResult = _rsSourceConnector.ExecuteMethod(methodInput);
//Note: this will show it was not a success and set the error info rather than throwing an exception
Assert.IsFalse(methodResult.Success);
Assert.IsNotNull(methodResult.ErrorInfo);
}
private MethodResult mysqldump(string databaseName, string destinationSqlScriptFile)
{
var result = new MethodResult();
var Location = Path.Combine(ImportHelper.GetRegistryKeyValue(MYSQL51_REGISTRY_KEY, "Location"), "bin", "mysqldump.exe");
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.FileName = String.Format("\"{0}\"", Location);
startInfo.Arguments = String.Format("--host={0} --user={1} --password={2} --routines --triggers --events --add-drop-table --dump-date --opt --no-create-db --set-charset --database {3} -r \"{4}\"",
Settings.Default.mysqlHost,
Settings.Default.mysqlUser,
Settings.Default.mysqlPassword,
databaseName,
destinationSqlScriptFile);
startInfo.CreateNoWindow = true;
startInfo.UseShellExecute = false;
startInfo.RedirectStandardError = true;
startInfo.RedirectStandardOutput = false;
startInfo.WindowStyle = ProcessWindowStyle.Hidden;
using (var execute = Process.Start(startInfo))
{
execute.WaitForExit();
if (execute.ExitCode != 0)
{
result.Status = false;
result.Msg = execute.StandardError.ReadToEnd();
}
else
{
result.Status = true;
}
}
return(result);
}
/// <summary>
/// Uninitializes a single test case.
/// </summary>
public virtual void TestUninitialize(MethodResult result)
{
this.TestUninitialize();
BundleBuilder.CleanupByUninstalling();
PackageBuilder.CleanupByUninstalling();
MSIExec.UninstallAllInstalledProducts();
MsiVerifier.Reset();
this.ResetRegistry();
this.ResetDirectory();
if (this.cleanArtifacts)
{
foreach (FileSystemInfo artifact in this.TestArtifacts)
{
if (artifact.Exists)
{
try
{
DirectoryInfo dir = artifact as DirectoryInfo;
if (null != dir)
{
dir.Delete(true);
}
else
{
artifact.Delete();
}
}
catch
{
Debug.WriteLine(String.Format("Failed to delete '{0}'.", artifact.FullName));
}
}
}
}
}
/// <summary>
/// Administratively adds a user.
/// </summary>
/// <param name="toAdd">The user to add.</param>
/// <param name="userUnits">The users units.</param>
/// <returns>MethodResult indicating success.</returns>
public MethodResult AdministrativelyAddUser(User toAdd, IReadOnlyList <Guid> userUnits)
{
var password = PasswordGenerator.GeneratePw();
var result = Factory.GetControllerInstance <IClipperDatabase>().AddUser(toAdd.MailAddress, toAdd.UserName,
password, toAdd.Role, toAdd.PrincipalUnitId,
userUnits[0], true, true);
MethodResult innerResult = result;
if (result.IsSucceeded())
{
if (userUnits.Count > 1)
{
innerResult = DatabaseAdapterFactory.GetControllerInstance <IClipperDatabase>()
.SetUserOrganizationalUnits(result.Result, userUnits.Skip(1));
}
QuerySendMailAsync(toAdd, ClipperTexts.AccountCreatedMailSubject,
string.Format(ClipperTexts.AccountCreatedMailBody, toAdd.UserName, password));
}
return(innerResult);
}
public static MethodResult <List <TResult> > SelectResults <TSource, TResult>(
this IEnumerable <TSource> @this,
Func <TSource, MethodResult <TResult> > function)
{
var thisList = @this.ToList();
var selectedResult = new List <TResult>(thisList.Count);
foreach (var item in thisList)
{
var result = function(item);
if (!result.IsSuccess)
{
result.Detail.AddDetail(new { thisObj = thisList, targetItem = item });
return(MethodResult <List <TResult> > .Fail(result.Detail));
}
selectedResult.Add(result.Value);
}
return(MethodResult <List <TResult> > .Ok(selectedResult));
}
public MethodResult Delete(int organisationPKId)
{
var methodResult = new MethodResult();
try
{
var organisation = _context.OrgList.Find(organisationPKId);
if (organisation != null)
{
_context.OrgList.Remove(organisation);
_context.SaveChanges();
}
methodResult.SuccessFaliure = Enums.MethodResultOutcome.Success;
methodResult.Message = "Organisation deleted successfully";
}
catch (Exception e)
{
methodResult.SuccessFaliure = Enums.MethodResultOutcome.Failure;
methodResult.Message = "Error ocurred while deleting organisation, please retry";
}
return(methodResult);
}
public override void After(MethodInfo methodUnderTest, MethodResult result)
{
// remove logs when test passed and another favour of test doesn't fail previously (used in case of Theory tests).
if (PerTestLogger.ShouldEnablePerTestLog() && result is PassedResult && !failedMethods.Contains(methodUnderTest))
{
var fileToDelete = Path.Combine(PerTestLogger.TestsDirName, PerTestLogger.GenerateTestFileName(methodUnderTest));
if (File.Exists(fileToDelete))
{
IOExtensions.DeleteFile(fileToDelete);
var parentDir = Directory.GetParent(fileToDelete);
if (!parentDir.EnumerateFileSystemInfos().Any())
{
IOExtensions.DeleteDirectory(parentDir.FullName);
}
}
}
if (result is FailedResult)
{
failedMethods.Add(methodUnderTest);
}
}
private async Task <MethodResult> SetPlayerAvatar()
{
var avatar = new PlayerAvatar();
if (!_client.LoggedIn)
{
MethodResult result = await AcLogin();
if (!result.Success)
{
return(result);
}
}
var response = await _client.ClientSession.RpcClient.SendRemoteProcedureCallAsync(new Request
{
RequestType = RequestType.SetAvatar,
RequestMessage = new SetAvatarMessage
{
PlayerAvatar = avatar
}.ToByteString()
}, true, true, true);
if (response == null)
{
return(new MethodResult());
}
SetAvatarResponse setAvatarResponse = null;
setAvatarResponse = SetAvatarResponse.Parser.ParseFrom(response);
LogCaller(new LoggerEventArgs("Avatar set to defaults", LoggerTypes.Success));
return(new MethodResult
{
Success = true
});
}
public MethodResult <OrderResult> MakeANewOrder(OrderRequest order)
{
RateLimit();
var request = new RestRequest("/orders", Method.POST);
request.AddJsonBody(GdaxOrderRequest.ConvertFrom(order, _currencyMapper));
AddAuthenticationHeader(request);
var client = new RestClient(baseUrl);
//client.Proxy = new WebProxy("127.0.0.1", 8888); for fiddler trace
var response = client.Execute <GdaxOrderResponse>(request);
if (response.IsSuccessful)
{
var result = new OrderResult();
return(new MethodResult <OrderResult>()
{
IsSuccessful = true,
Data = response.Data.Convert()
});
}
return(MethodResult <OrderResult> .Failed(response.ErrorMessage));
}
// This other Percent gives different IV % for the same IVs depending of the pokemon level.
public MethodResult <double> CalculateIVPerfectionUsingMaxCP(PokemonData pokemon)
{
MethodResult <PokemonSettings> settingResult = GetPokemonSetting(pokemon.PokemonId);
if (!settingResult.Success)
{
return(new MethodResult <double>
{
Data = -1,
Message = settingResult.Message
});
}
/*
* if (Math.Abs(pokemon.CpMultiplier + pokemon.AdditionalCpMultiplier) <= 0)
* {
* double perfection = (double)(pokemon.IndividualAttack * 2 + pokemon.IndividualDefense + pokemon.IndividualStamina) / (4.0 * 15.0) * 100.0;
*
* return new MethodResult<double>
* {
* Data = perfection,
* Message = "Success",
* Success = true
* };
* }*/
double maxCp = CalculateMaxCpMultiplier(pokemon);
double minCp = CalculateMinCpMultiplier(pokemon);
double curCp = CalculateCpMultiplier(pokemon);
double perfectPercent = (curCp - minCp) / (maxCp - minCp) * 100.0;
return(new MethodResult <double>
{
Data = perfectPercent,
Message = "Success",
Success = true
});
}
public static async Task <MethodResult <List <TResult> > > SelectResultsAsync <TSource, TResult>(
this Task <IEnumerable <TSource> > @this,
Func <TSource, TResult> function)
{
var thisList = (await @this).ToList();
var selectedResult = new List <TResult>(thisList.Count);
foreach (var item in thisList)
{
try {
var result = function(item);
selectedResult.Add(result);
}
catch (Exception e) {
return(MethodResult <List <TResult> > .Fail(new ExceptionError(e,
moreDetails : new { thisObj = thisList, targetItem = item })));
}
}
return(MethodResult <List <TResult> > .Ok(selectedResult));
}
public static void WriteDependencies(string signatureName, List<string> dependencies, StreamWriter writer, MethodResult methods, MethodResult members, string currentPath)
{
var dependenciesList = dependencies.ToArray().ToList();
if (members != null)
dependenciesList.AddRange(members.dependencies);
if (methods != null)
dependenciesList.AddRange(methods.dependencies);
foreach (var dep in dependenciesList.Distinct().Where(d => d != signatureName))
{
WriteDependency(writer, currentPath, dep);
}
}
/// <summary>
/// This method will execute a Method returning a result.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public MethodResult ExecuteMethod(MethodInput input)
{
MethodResult methodResult;
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point is written during garbage collection.
using (new LogMethodExecution(Globals.ConnectorName, "Execute Method"))
{
//Construct a new instance of the method handler
//passing along the current instance of the data access object
MethodHandler methodHandler = new MethodHandler(_dataAccess);
try
{
//Use the name stored in the method
//input to determine the correct method to execute
switch (input.Name.ToLower())
{
case "getobjectdefinition":
methodResult = methodHandler.GetObjectDefinition(input);
break;
case "createorupdateobjectforreplication":
methodResult = methodHandler.CreateOrUpdateObjectForReplication(input);
break;
case "getlastreplicationsyncdate":
methodResult = methodHandler.GetLastReplicationSyncDate(input);
break;
default:
string message = string.Format(ErrorCodes.UnknownMethod.Description, input.Name);
throw new InvalidExecuteMethodException(ErrorCodes.UnknownMethod.Number, message);
}
LogMethodResult(methodResult);
}
//Here we throw the Fatal Error Exception which is used to notify upper layers that
//an error has occured in the Connector and will be unable to recover from it
catch (FatalErrorException)
{
throw;
}
catch (Exception exception)
{
//Log any other exceptions that occur during method execution
//and store them in the MethodResult.ErrorInfo
methodResult = new MethodResult {Success = false};
//Create the error info using the exception message
methodResult.ErrorInfo = new ErrorResult
{
Description = exception.Message,
Detail = exception.StackTrace,
Number = ErrorCodes.MethodError.Number
};
LogMethodResult(methodResult);
}
}
return methodResult;
}
/// <summary>
/// Method to correctly log the result of the method
/// </summary>
/// <param name="methodResult">Method Result to log</param>
private void LogMethodResult(MethodResult methodResult)
{
string message;
//Connector Api severity enumertion to define the level for logging
Logger.Severity severity;
//check if the result of the method was a success
if (methodResult.Success)
{
//create a message to log in the event of a success
message = "Method Executed Successfully";
severity = Logger.Severity.Debug;
}
else
{
//create a message to log in the event of an error
var errorInfo = methodResult.ErrorInfo;
message = string.Format("An Error has occured in {0}: {2}Error Number:{1}{2}Error Description:{3}{2}Error Detail:{4}", Globals.ConnectorName, errorInfo.Number, Environment.NewLine, errorInfo.Description, errorInfo.Detail);
severity = Logger.Severity.Error;
}
//log the result severity, the name of the connector, and the created message
Logger.Write(severity, Globals.ConnectorName, message);
}
/// <summary>
/// Get a specific Object's definition, this includes any attributes and
/// supporting object properties.
/// In this case retrieve the table definition along with any columns and
/// the definition of each.
/// </summary>
/// <param name="methodInput">Method Input which includes an 'ObjectName'
/// property to determine the object to retrieve the definition.</param>
/// <returns>Method Result, which will either include error information or the
/// Object Definition of the 'ObjectName' specified in the
/// MethodInput properties.</returns>
public MethodResult GetObjectDefinition(MethodInput methodInput)
{
//Create a new instance of the method result to fill with
//meta data information
MethodResult result = null;
//Create a new instance of the metadata access class and pass the
//data access instance along with it
OleDbMetadataAccess metadataAccess = new OleDbMetadataAccess(_dataAccess);
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point
// is written during garbage collection.
using (new LogMethodExecution(
Globals.ConnectorName, "GetObjectDefinition"))
{
//Get the name of the object in the input properties.
string objectName =
GetPropertyValueName("ObjectName", methodInput.Input.Properties);
//Use the metadata access to get the
//definitions for each of the columns in the table.
DataTable tableColumnDefinitions =
metadataAccess.GetColumnDefinitions(objectName);
//Using the meta data access get the definition for the
//table indexes (primary and foreign keys)
DataTable tableIndexDefinition =
metadataAccess.GetTableIndexInformation(objectName);
//Check that both sets of data have been returned
//from the meta data access layer
if ((tableColumnDefinitions != null
&& tableColumnDefinitions.Rows.Count != 0) &&
(tableIndexDefinition != null
&& tableIndexDefinition.Rows.Count != 0))
{
//Create a new replication service object
RSObjectDefinition rsObjectDefinition = new RSObjectDefinition()
{
Name = objectName,
RSPropertyDefinitions = new List<RSPropertyDefinition>()
};
//If this is the change history table set the hidden attribute.
//Note: this is how to prevent an object from being replicated.
rsObjectDefinition.Hidden = objectName == Globals.ChangeHistoryTableName;
List<string> tablePrimaryKeys =
GetTablePrimaryKeys(rsObjectDefinition.Name, metadataAccess);
//Parse each column returned from the column definitions.
//For each column, add a new replication service property definition
//to the newly created replication service object definition.
foreach (DataRow columnDefinition in tableColumnDefinitions.Rows)
{
//Process the column definition and set it to the
//resplication service property definition.
RSPropertyDefinition rsPropertyDefinition =
ProcessColumnDefinition(columnDefinition);
//Check if this is the default last modified column and
//set the object property.
if (rsPropertyDefinition.Name == LastModifiedFieldName)
{
rsObjectDefinition.ModificationDateFullName =
rsPropertyDefinition.Name;
}
//Check if the property is a primary key value.
rsPropertyDefinition.InPrimaryKey =
tablePrimaryKeys.Contains(rsPropertyDefinition.Name);
//Add the property definition to the object definition.
rsObjectDefinition.RSPropertyDefinitions.Add(rsPropertyDefinition);
}
//Convert the replication service object definition to a Data Entity.
//Set the result return value to the
//replication service object definition.
//Set the result Success to true.
result = new MethodResult
{ Success = true, Return = rsObjectDefinition.ToDataEntity() };
}
else
{
//Set the proper error information in the method result in the
//event of a null table or column definitions.
result = SetErrorMethodResult(
ErrorCodes.NoObjectsFound.Number,
ErrorCodes.NoObjectsFound.Description);
}
}
//Return the method result.
return result;
}
/// <summary>
/// Get a specific Object's definition, this includes any attributes and supporting object properties.
/// In this case retrieve the table definition along with any columns and the definition of each.
/// </summary>
/// <param name="methodInput">Method Input which includes an 'ObjectName'
/// property to determine the object to retrieve the definition for.</param>
/// <returns>Method Result which will either include error information or the
/// Object Definition of the 'ObjectName' specified in the MethodInput properties</returns>
public MethodResult GetObjectDefinition(MethodInput methodInput)
{
//Create a new instance of the method result to
//fill with meta data information
MethodResult result = new MethodResult();
//create a new instance of the metadata access class and
//pass the data access instance allong with it
OleDbMetadataAccess metadataAccess = new OleDbMetadataAccess(_dataAccess);
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point
//is written during garbage collection.
using (new LogMethodExecution(
Globals.ConnectorName, "GetObjectDefinitionMethod"))
{
//get the name of the object in the input properties
string objectName = GetPropertyValue(
"ObjectName", methodInput.Input.Properties);
//using the meta data access get the definitions
//for each of the columns in the table
DataTable tableColumnDefinitions =
metadataAccess.GetColumnDefinitions(objectName);
//using the meta data access get the definition for
//the table indexes (primary and foreign keys)
DataTable tableIndexDefinition =
metadataAccess.GetTableIndexInformation(objectName);
//check that both sets of data have been
//returned from the meta data access layer
if ((tableColumnDefinitions != null
&& tableColumnDefinitions.Rows.Count != 0)
&& (tableIndexDefinition != null
&& tableIndexDefinition.Rows.Count != 0))
{
//create a new replication service object
RSObjectDefinition rsObjectDefinition = new RSObjectDefinition()
{
Name = objectName,
RSPropertyDefinitions = new List<RSPropertyDefinition>()
};
List<string> tablePrimaryKeys =
GetTablePrimaryKeys(rsObjectDefinition.Name, metadataAccess);
//parse through each column return from the column definitions and
//add a new replication service property definition to the newly created
//replication service object definition for each column in the table
foreach (DataRow columnDefinition in tableColumnDefinitions.Rows)
{
//process the column definition and set it
//to the resplication service property definition
RSPropertyDefinition rsPropertyDefinition =
ProcessColumnDefinition(columnDefinition);
//check if this is the default last
//modified column and set the object property
if (rsPropertyDefinition.Name == LastModifiedFieldName)
{
rsObjectDefinition.ModificationDateFullName =
rsPropertyDefinition.Name;
}
//check if the property is a primary key value
rsPropertyDefinition.InPrimaryKey =
tablePrimaryKeys.Contains(rsPropertyDefinition.Name);
//add the property definition to the object definition
rsObjectDefinition.RSPropertyDefinitions.Add(rsPropertyDefinition);
}
//Convert the replication service object definition to a Data Entity
//set the result return value to the replication service object defintion
//set the result success to true
result = new MethodResult { Success = true, Return = rsObjectDefinition.ToDataEntity() };
}
else
{
result = new MethodResult { Success = false, ErrorInfo = new ErrorResult { Description = ErrorCodes.ObjectNotFound.Description, Number = ErrorCodes.ObjectNotFound.Number } };
}
}
//return the method result
return result;
}
/// <summary>
/// Get the list of 'Object' names or in this case
/// table names from the data source
/// include the primary key or identifyer in the each of the objects
/// </summary>
/// <returns>MethodResult to be return in a readable state</returns>
public MethodResult GetObjectDefinitionList()
{
//Create a new instance of the method result to fill with
//meta data information
MethodResult result = new MethodResult();
// Create a new instance of the metadata access class and pass
// the data access instance along with it
OleDbMetadataAccess metadataAccess =
new OleDbMetadataAccess(_dataAccess);
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point
// is written during garbage collection.
using (new LogMethodExecution(
Globals.ConnectorName, "GetObjectDefinitionList"))
{
//Get a list of indexes for each table
DataTable tableList = metadataAccess.GetTableList();
//check that valid data has been return from the schema
if (tableList != null && tableList.Rows.Count != 0)
{
//Create a list of generic Data Entities
//***This is a Key piece of the replication process***
//This is where the table list will be stored in a
//generic fashion and return in the result.
List<DataEntity> dataEntityList = new List<DataEntity>();
//Parse the list of rows that contain the table
//information and stuff them into generic data entities.
//Add them to the list that will be returned in the result.
foreach (DataRow tableRow in tableList.Rows)
{
var tableName = tableRow["TABLE_NAME"].ToString();
var dataEntity = new DataEntity("Object");
dataEntity.Properties.Add("Name", tableName);
dataEntity.Properties.Add(
"PrimaryKeyName", PrimaryKeyFieldName);
dataEntity.Properties.Add(
"Description", GetTableDescription(tableName));
//Check if the table has the ModifiedOn column
dataEntity.Properties.Add(
"ModificationDateFullName",
CheckForLastModifiedColumnName(
tableName, metadataAccess)
? LastModifiedFieldName : string.Empty);
dataEntity.Properties.Add("Hidden", tableName == Globals.ChangeHistoryTableName);
dataEntityList.Add(dataEntity);
}
//Set the success of the result to true since the
//list of entities has been filled.
result.Success = true;
//Create a new instance of the return result set
//with the name of the returned items.
result.Return = new DataEntity("ObjectList");
//Add the entity list to the result.
result.Return.Properties.Add("Result", dataEntityList);
}
else
{
//Set the proper error information in the event that
//incorrect schema information is returned from the database.
result = SetErrorMethodResult(
ErrorCodes.GetObjectList.Number, ErrorCodes.GetObjectList.Description);
}
}
//Return the method result containing the object definition list.
return result;
}
/// <summary>
/// This is the method to get data for replication
/// for an individual object. Rows will be returned as they are read.
/// </summary>
/// <param name="methodInput"></param>
/// <returns></returns>
public MethodResult GetReplicationData(MethodInput methodInput)
{
MethodResult result = null;
using (new LogMethodExecution(
Globals.ConnectorName, "GetReplicationData"))
{
//Get the name of the object in the input properties.
string objectName = GetPropertyValueName(
"ObjectName",methodInput.Input.Properties);
//Get the last sychronization date from the input properties
DateTime lastSyncDate = GetLastSyncDate(methodInput.Input.Properties);
OleDbMetadataAccess metadataAccess = new OleDbMetadataAccess(_dataAccess);
bool hasLastModified = CheckForLastModifiedColumnName(objectName, metadataAccess);
try
{
//Passes control of the lower level method in the data access layer
//to the calling method.This passes the IEnumerable object
//(filled with data rows) out to the calling methodin conjunction
//with the yield statement at the lower level, is looking for the
//foreach loop else control is passed out to the calling method.
//Here, the attempt to get an entity is performed (by calling the
//empty foreach loop) in order to check for errors - else the top
//level has control and exceptions get passed directly up. Here we assume
//that no error on retrieving row 1 means we are safe to pass control
//back to the calling method and skip the error checking
//that is forced on the first entity.
IEnumerable<DataEntity> replicationData =
_dataAccess.GetReplicationDataRetrieve(
objectName, lastSyncDate, hasLastModified);
//Force a check for errors. The previous method call
//will not be performed until it is requested for use here.
foreach (var dataEntity in replicationData)
{
break;
}
//Create a new method result
result = new MethodResult();
//Indicate that the result is a success
result.Success = true;
//Set the result return to a new data entity
//which MUST be named "ReplicationQueryData"
result.Return = new DataEntity("ReplicationQueryData");
//Add the yielded replication data to the return properties in the result
//Note: the property name MUST be labeled as 'EntityData'
result.Return.Properties.Add("EntityData", replicationData);
}
catch (Exception exception)
{
//Be sure to log any errors and add them to the
//error information for the method result
Logger.Write(
Logger.Severity.Error, Globals.ConnectorName, exception.Message);
result = SetErrorMethodResult(
ErrorCodes.GetData.Number, ErrorCodes.GetData.Description);
}
}
//Return the method result containing the replication data
return result;
}
private void PostExecute(IAsyncResult syncResult)
{
_result = _method.EndInvoke(syncResult);
if (PostExecuteHandler != null)
PostExecuteHandler(sender, this, _result);
}
/// <summary>
/// This method defines the process for tracking changes to data.
/// This particular example shows one way how this operation may work.
/// Note: A seperate method will create triggers for each table that will fill this table with deletions.
/// Note: If the data-source already has a process for tracking changes, this
/// method will only need to return a positive success in the method result
/// </summary>
/// <returns></returns>
public MethodResult InitReplication()
{
MethodResult methodResult = null;
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point
// is written during garbage collection.
using (new LogMethodExecution(
Globals.ConnectorName, "InitReplication"))
{
//First retrieve the object definition of the
//default table that is used for replication.
MethodInput objectDefinitionInput = new MethodInput();
objectDefinitionInput.Input.Properties.Add(
"ObjectName", "ScribeChangeHistory");
MethodResult objectDefinitionResult =
GetObjectDefinition(objectDefinitionInput);
//If the replication table already exist then our work
//here is done. No other action is required.
if (objectDefinitionResult.Success == false)
{
//Use the Sribe-provided local data storage
//to retrieve and read the sql scripts contents.
LocalDataStorage localDataStorage = new LocalDataStorage();
string query =
localDataStorage.ReadData(ChangeHistoryFileName);
//Throw an error message if the file was not found
if (string.IsNullOrWhiteSpace(query))
{
throw new InvalidExecuteOperationException(string.Format("Unable to locate file: {0}", ChangeHistoryFileName));
}
//Execute the query to create the change history table.
_dataAccess.ExecuteNonQuery(query);
}
//If there were no errors in processing, then
//set the Success for the method result to true.
methodResult = new MethodResult { Success = true };
}
return methodResult;
}
/// <summary>
/// This method determines whether or not an object from the source has changed.
/// If the object does not exist it will be created.
/// If the object has changed it will be deleted and the new one will be created.
/// If no changes are detected then it will be noted and no further action is needed.
/// </summary>
/// <param name="methodInput"></param>
/// <returns></returns>
public MethodResult CreateOrUpdateObjectForReplication(MethodInput methodInput)
{
MethodResult methodResult = new MethodResult();
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point
//is written during garbage collection.
using (new LogMethodExecution(
Globals.ConnectorName, "CreateOrUpdateObjectForReplication"))
{
string tableName = GetPropertyValue("Name", methodInput.Input.Properties);
//get the list of the columns to be created
List<DataEntity> newColumns =
methodInput.Input.Children["RSPropertyDefinitions"];
//add the default columns to the new ones from the input
newColumns.AddRange(CreateDefaultColumns());
//get the definition of the existing table
MethodResult currentTableDefinition =
GetObjectDefinition(new MethodInput
{
Input =
{
Properties = new EntityProperties
{
{"ObjectName", tableName}
}
}
});
bool changeDetected = true;
//check if the table was returned from GetObjectDefinition method
if (currentTableDefinition != null && currentTableDefinition.Success)
{
//look for any changes in the table schema by
//comparing the properties
//of the existing object against the those
//found in the method input
changeDetected = CheckForSchemaChanges(newColumns,
currentTableDefinition.Return.Children[
"RSPropertyDefinitions"]);
//if a change is decteded drop the table
if (changeDetected)
{
string query = string.Format("DROP TABLE [{0}]", tableName);
_dataAccess.ExecuteNonQuery(query);
}
}
//Ff a change is detected create the table
if (changeDetected)
{
_dataAccess.CreateTable(tableName, newColumns);
}
//Set the method result object
methodResult = new MethodResult { Success = true, Return = new DataEntity() };
//add a property called 'SchemaChanged' to the return properties
//this is how ScribeOnline will determine whether or not a replication
//is required when this method has completed
//Note: this MUST be labeled 'SchemaChanged'
methodResult.Return.Properties.Add("SchemaChanged", changeDetected);
}
return methodResult;
}
/// <summary>
/// In the event of an error we want to package it up nicely within the Method Result Error Infor property,
/// as well as Log the occurence
/// </summary>
/// <param name="errorCode">Int value for the error code</param>
/// <param name="errorDescription">Text value fo the description of the error</param>
/// <returns>Method Result object containing with the error information property populated</returns>
private MethodResult SetErrorMethodResult(int errorCode, string errorDescription)
{
//create a new instance of the Method Result object from the Connector Api packaging up the error code and description
MethodResult result = new MethodResult
{
Success = false,
ErrorInfo =
new ErrorResult { Number = errorCode, Description = errorDescription }
};
//Use the Connector Api Logger to log the error event, include the severity level, connector name as well as the description
Logger.Write(Logger.Severity.Error, Globals.ConnectorName, result.ErrorInfo.Description);
//send back the method result object that was created
return result;
}
public void MethodExecuted(object sender, MethodParamPair method, MethodResult result)
{
_next = method.NextMethod;
Execute(sender);
}
/// <summary>
/// This method creates an object used to
/// track changes for future replications.
/// In this case, a delete trigger is added to a specified table.
/// Note: If the data-source already has a process for tracking changes, this
/// method will only need to return a positive success in the method result
/// </summary>
/// <param name="methodInput">Method input used for the replication object.
/// This is the name of the table that we need to extract.
/// methodInput.Input.properties["ObjectName"]
/// </param>
/// <returns></returns>
public MethodResult InitReplicationObject(MethodInput methodInput)
{
MethodResult methodResult = null;
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point
// is written during garbage collection.
using (new LogMethodExecution(
Globals.ConnectorName, "InitReplication"))
{
//First ensure the change history table exists
MethodResult initReplicationResult = InitReplication();
//If the replication table already exist then
//our work here is done and no other action is required
if (initReplicationResult.Success)
{
string tableName =
GetPropertyValueName("EntityName", methodInput.Input.Properties);
string triggerName =
string.Format("{0}_Deleted_TRG", tableName);
if (CheckForTrigger(triggerName, tableName) == false)
{
//Use the ConnectorApi provided local data storage to retrieve
//and read the sql scripts contents
LocalDataStorage localDataStorage = new LocalDataStorage();
string deleteTriggerString =
localDataStorage.ReadData(TriggerFileName);
if (string.IsNullOrWhiteSpace(deleteTriggerString))
{
throw new InvalidExecuteOperationException(string.Format("Unable to locate file: {0}", TriggerFileName));
}
string query = string.Format(deleteTriggerString, tableName);
//Execute the query to create the change history table.
_dataAccess.ExecuteNonQuery(query);
}
//If there were no errors in processing then
//just set the Success for the method result to true.
methodResult = new MethodResult { Success = true };
}
else
{
methodResult = SetErrorMethodResult(ErrorCodes.InitReplication.Number,
ErrorCodes.InitReplication.Description);
}
}
return methodResult;
}
/// <summary>
/// Retrieve all IDs for entities that have changed since last syncronization.
/// </summary>
/// <param name="methodInput"></param>
/// <returns></returns>
public MethodResult GetChangeHistoryData(MethodInput methodInput)
{
MethodResult result = null;
using (new LogMethodExecution(Globals.ConnectorName, "GetChangeHistory"))
{
//Check for the last sync date property
if (methodInput.Input.Properties.ContainsKey("LastSyncDate") == false)
{
throw new ArgumentNullException("LastSyncDate", InputPropertyNotFound);
}
//Retrieve the last date of syncronization from the method input.
DateTime lastSyncDate = GetLastSyncDate(methodInput.Input.Properties);
//Retrieve the name of the table from the method input.
string tableName = GetPropertyValueName(
"ObjectName", methodInput.Input.Properties);
string query = string.Format(
"SELECT Id FROM ScribeChangeHistory WHERE ModifiedOn > convert(datetime,'{0}') AND TableName ='{1}'",
lastSyncDate.ToString("s"), tableName);
//Execute the query.
DataTable records = _dataAccess.Execute(query);
result = new MethodResult();
if (records != null && records.Rows.Count > 0)
{
List<DataEntity> entityList = new List<DataEntity>();
//Parse each row and add the records to the entity properties.
foreach (DataRow row in records.Rows)
{
//Create a new entity for each ID returned.
DataEntity entity = new DataEntity {ObjectDefinitionFullName = tableName};
//This the key name MUST be 'ChangeHistoryId'.
//The value MUST be the primary key value of the row that has been deleted
entity.Properties.Add("ChangeHistoryId", row["Id"]);
//Add the entity to the list.
entityList.Add(entity);
}
//Set the result return the the created data entity.
result.Return = new DataEntity("ChangeHistoryData");
result.Return.Properties.Add("EntityData", entityList);
}
else
{
//Even if no data is being returned
//make sure that the return has a value.
result.Return = new DataEntity();
result.Return.Properties.Add("EntityData", null);
}
result.Success = true;
}
return result;
}
/// <summary>
/// Retrieve the last date the specified table was syncronized
/// MethodInput.Input.Property.Keys
/// "ObjectName": Name of the table
/// "ModificationDateFullName": Name of the column that stored the last date of syncronization
/// </summary>
/// <param name="methodInput">Container for the methods input properties</param>
/// <returns>MethodResult</returns>
public MethodResult GetLastReplicationSyncDate(MethodInput methodInput)
{
MethodResult methodResult = new MethodResult();
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point is written during garbage collection.
using (new LogMethodExecution(
Globals.ConnectorName, "GetLastReplicationSyncDate"))
{
//get the name of the table from the method input
string tableName = GetPropertyValue(
"ObjectName", methodInput.Input.Properties);
string modifiedOnColumn = GetPropertyValue(
"ModificationDateFullName",
methodInput.Input.Properties);
DateTime lastSyncDate;
try
{
//verify that the column name for the lasty sync date is specified
if (string.IsNullOrWhiteSpace(modifiedOnColumn) == false)
{
string query = string.Format(
"SELECT TOP 1 [{0}] FROM [{1}] ORDER BY [{0}] DESC", modifiedOnColumn, tableName);
//execute the query
DataTable lastSyncDateTable = _dataAccess.Execute(query);
if (lastSyncDateTable.Rows.Count != 0)
{
lastSyncDate = Convert.ToDateTime(
lastSyncDateTable.Rows[0][modifiedOnColumn]);
}
//If no records are found in the table then set the last sync date to the min value
else
{
lastSyncDate = DateTime.MinValue;
}
}
//If no last sync date column is specified set the last sync date to the min value
else
{
lastSyncDate = DateTime.MinValue;
}
//create a new method result
methodResult = new MethodResult { Success = true, Return = new DataEntity("ReturnValue") };
//add the LastSyncDate to the return properties
methodResult.Return.Properties.Add("LastSyncDate", lastSyncDate);
//put the last sync date in the debug log
Logger.Write(Logger.Severity.Debug, Globals.ConnectorName,
"LastSyncDate: " + lastSyncDate + Environment.NewLine);
}
//catch an errors comming from the database
//All other erros will be caught on a higher level and thrown
//As an InvalidExecuteMethodException from the connector interface
catch (OleDbException oleDbException)
{
//in the event of a database error create a
//new method result and set the succes to false
methodResult = new MethodResult { Success = false };
//create the new error info and set the number
//to the code from the connection
methodResult.ErrorInfo = new ErrorResult { Number = oleDbException.ErrorCode };
//create the description for the error
methodResult.ErrorInfo.Description =
oleDbException.Message;
methodResult.ErrorInfo.Detail =
oleDbException.ToString();
}
}
return methodResult;
}
