public void UpdateTaxonInformation()
 {
     HarvestManager.UpdateTaxonInformation(GetContext());
 }
 public void CheckSpeciesObservations()
 {
     HarvestManager.CheckSpeciesObservations(GetContext());
 }
        public void CheckDifference()
        {
            Dictionary <String, WebSpeciesObservationField> mapping;
            DocumentFilterResponse documentFilterResponse;
            ElasticsearchSpeciesObservationProxy elasticsearch;
            Int32        index;
            List <Int64> speciesObservationAdd, speciesObservationDelete,
                         speciesObservationIds, speciesObservationDifferenceIds;
            List <WebSpeciesObservation>    speciesObservations;
            SpeciesObservationElasticsearch speciesObservationElasticsearch;
            StringBuilder filter;

            speciesObservationAdd    = new List <Int64>();
            speciesObservationDelete = new List <Int64>();
            HarvestManager.GetSpeciesObservationDifference(GetContext(), speciesObservationAdd, speciesObservationDelete);

            if (speciesObservationAdd.IsNotEmpty())
            {
                speciesObservationElasticsearch = WebSpeciesObservationServiceData.SpeciesObservationManager.GetSpeciesObservationElasticsearch(GetContext());
                elasticsearch = new ElasticsearchSpeciesObservationProxy(speciesObservationElasticsearch.CurrentIndexName);
                mapping       = WebSpeciesObservationServiceData.SpeciesObservationManager.GetMapping(GetContext(), elasticsearch);

                filter = new StringBuilder();
                filter.Append("{");
                filter.Append(" \"size\": " + speciesObservationAdd.Count);
                filter.Append(", \"_source\" : {\"include\": [\"Occurrence_OccurrenceID\", \"DarwinCore_Id\"]}");
                filter.Append(", \"filter\": { \"terms\": { \"DarwinCore_Id\":[");
                filter.Append(speciesObservationAdd[0].WebToString());
                for (index = 1; index < speciesObservationAdd.Count; index++)
                {
                    filter.Append(", " + speciesObservationAdd[index].WebToString());
                }

                filter.Append("]}}}");
                documentFilterResponse = elasticsearch.GetSpeciesObservations(filter.ToString());
                if (documentFilterResponse.TimedOut)
                {
                    throw new Exception("Method UpdateSpeciesObservationsElasticsearch() timed out!");
                }

                speciesObservations = WebSpeciesObservationServiceData.SpeciesObservationManager.GetSpeciesObservations(documentFilterResponse.DocumentsJson,
                                                                                                                        mapping);
                if (speciesObservations.IsNotEmpty())
                {
                    speciesObservationIds = new List <Int64>();
                    foreach (WebSpeciesObservation speciesObservationDeleteTemp in speciesObservations)
                    {
                        speciesObservationIds.Add(speciesObservationDeleteTemp.Fields.GetField(SpeciesObservationClassId.DarwinCore, SpeciesObservationPropertyId.Id).Value.WebParseInt64());
                    }

                    speciesObservationDifferenceIds = new List <Int64>();
                    foreach (Int64 speciesObservationId in speciesObservationAdd)
                    {
                        if (!(speciesObservationIds.Contains(speciesObservationId)))
                        {
                            speciesObservationDifferenceIds.Add(speciesObservationId);
                            Debug.WriteLine("Missing species observation id = " + speciesObservationId);
                        }
                    }
                }
            }
        }
 public void UpdateProjectParameterInformation()
 {
     HarvestManager.UpdateProjectParameterInformation(new ArtportalenServer(), GetContext());
 }
 public void DeleteUnnecessaryChanges()
 {
     HarvestManager.DeleteUnnecessaryChanges(GetContext());
 }
        public void DeleteDifference()
        {
            Dictionary <String, WebSpeciesObservationField> mapping;
            DocumentFilterResponse documentFilterResponse;
            ElasticsearchSpeciesObservationProxy elasticsearch;
            Int32        index;
            List <Int64> speciesObservationAdd, speciesObservationDelete, speciesObservationIds;
            List <WebSpeciesObservation>    speciesObservations;
            SpeciesObservationElasticsearch speciesObservationElasticsearch;
            StringBuilder filter;

            speciesObservationAdd    = new List <Int64>();
            speciesObservationDelete = new List <Int64>();
            HarvestManager.GetSpeciesObservationDifference(GetContext(), speciesObservationAdd, speciesObservationDelete);
            speciesObservationElasticsearch = WebSpeciesObservationServiceData.SpeciesObservationManager.GetSpeciesObservationElasticsearch(GetContext());
            elasticsearch = new ElasticsearchSpeciesObservationProxy(speciesObservationElasticsearch.CurrentIndexName);
            mapping       = WebSpeciesObservationServiceData.SpeciesObservationManager.GetMapping(GetContext(), elasticsearch);

            while (speciesObservationDelete.IsNotEmpty())
            {
                speciesObservationIds = new List <Int64>();
                while (speciesObservationDelete.IsNotEmpty())
                {
                    speciesObservationIds.Add(speciesObservationDelete[0]);
                    speciesObservationDelete.RemoveAt(0);
                    if (speciesObservationIds.Count >= 10000)
                    {
                        break;
                    }
                }

                filter = new StringBuilder();
                filter.Append("{");
                filter.Append(" \"size\": " + speciesObservationIds.Count);
                filter.Append(", \"_source\" : {\"include\": [\"Occurrence_OccurrenceID\", \"DarwinCore_Id\", \"DarwinCore_DataProviderId\", \"Occurrence_CatalogNumber\"]}");
                filter.Append(", \"filter\": { \"terms\": { \"DarwinCore_Id\":[");
                filter.Append(speciesObservationIds[0].WebToString());
                for (index = 1; index < speciesObservationIds.Count; index++)
                {
                    filter.Append(", " + speciesObservationIds[index].WebToString());
                }

                filter.Append("]}}}");
                documentFilterResponse = elasticsearch.GetSpeciesObservations(filter.ToString());
                if (documentFilterResponse.TimedOut)
                {
                    throw new Exception("Method UpdateSpeciesObservationsElasticsearch() timed out!");
                }

                speciesObservations = WebSpeciesObservationServiceData.SpeciesObservationManager.GetSpeciesObservations(documentFilterResponse.DocumentsJson,
                                                                                                                        mapping);
                if (speciesObservations.IsNotEmpty())
                {
                    DataTable deletedSpeciesObservationTable = new DataTable();
                    deletedSpeciesObservationTable.TableName = "DeletedSpeciesObservation";
                    deletedSpeciesObservationTable.Columns.Add("id", typeof(Int64));
                    deletedSpeciesObservationTable.Columns.Add("dataProviderId", typeof(Int32));
                    deletedSpeciesObservationTable.Columns.Add("catalogNumber", typeof(String));
                    deletedSpeciesObservationTable.Columns.Add("occuranceId", typeof(String));

                    foreach (WebSpeciesObservation speciesObservation in speciesObservations)
                    {
                        DataRow speciesObservationRow = deletedSpeciesObservationTable.NewRow();
                        speciesObservationRow[0] = speciesObservation.Fields.GetField(SpeciesObservationClassId.DarwinCore, SpeciesObservationPropertyId.Id).Value.WebParseInt64();
                        speciesObservationRow[1] = speciesObservation.Fields.GetField("DarwinCore", "DataProviderId").Value.WebParseInt32();
                        speciesObservationRow[2] = speciesObservation.Fields.GetField(SpeciesObservationClassId.Occurrence, SpeciesObservationPropertyId.CatalogNumber).Value;
                        speciesObservationRow[3] = speciesObservation.Fields.GetField(SpeciesObservationClassId.Occurrence, SpeciesObservationPropertyId.OccurrenceID).Value;
                        deletedSpeciesObservationTable.Rows.Add(speciesObservationRow);
                    }

                    GetContext().GetSpeciesObservationDatabase().AddTableData(GetContext(), deletedSpeciesObservationTable);
                }
            }
        }
        ////void IConnectorServer.CreateSpeciesObservations(WebServiceContext context, List<HarvestSpeciesObservation> speciesObservations, WebSpeciesObservationDataProvider dataProvider, out int noOfCreated, out int noOfErrors)
        ////{
        ////    throw new NotImplementedException();
        ////    //   CreateSpeciesObservations(context, speciesObservations, dataProvider, out noOfCreated, out noOfErrors);
        ////}
        ///// <summary>
        ///// Insert all new (created) observations into a DataTable
        ///// First check the observation
        ///// If ok, add it to SpeciesObservationTable and DarwinCoreTable
        ///// If there are errors add the observation to speciesObservationErrorFieldTable
        ///// </summary>
        ///// <param name="context">Web service request context.</param>
        ///// <param name="speciesObservations">Created species observations.</param>
        ///// <param name="dataProvider">Species observation data source.</param>
        ///// <param name="noOfCreated">Created </param>
        ///// <param name="noOfErrors">Errors </param>
        ////public static void CreateSpeciesObservations(WebServiceContext context,
        ////                                              List<HarvestSpeciesObservation> speciesObservations,
        ////                                              WebSpeciesObservationDataProvider dataProvider,
        ////                                              out int noOfCreated, out int noOfErrors)
        ////{
        ////    noOfCreated = 0;
        ////    noOfErrors = 0;
        ////    if (speciesObservations.IsNotEmpty())
        ////    {
        ////        DataTable darwinCoreTable = HarvestManager.GetDarwinCoreTable(CREATE);

        ////        DataTable speciesObservationFieldTable = HarvestManager.GetSpeciesObservationFieldTable(CREATE);
        ////        DataTable speciesObservationErrorFieldTable = HarvestManager.GetSpeciesObservationErrorFieldTable();

        ////        // Save all species observations into tables.
        ////        foreach (HarvestSpeciesObservation speciesObservation in speciesObservations)
        ////        {
        ////            string catalogNumber;
        ////            Dictionary<SpeciesObservationPropertyId, string> errors;
        ////            if (HarvestManager.CheckSpeciesObservation(speciesObservation, context, out errors, out catalogNumber))
        ////            {
        ////              //  HarvestManager.SpeciesObservationId++;
        ////                HarvestManager.AddToTempSpeciesObservation(speciesObservation,
        ////                                            darwinCoreTable,
        ////                                            speciesObservationFieldTable,
        ////                                            HarvestManager.SpeciesObservationId,
        ////                                            dataProvider,
        ////                                            catalogNumber);
        ////                noOfCreated++;
        ////            }
        ////            else
        ////            {
        ////                HarvestManager.CreateSpeciesObservationError(speciesObservation,
        ////                                              speciesObservationErrorFieldTable,
        ////                                              dataProvider,
        ////                                              errors,
        ////                                              CREATE);
        ////                noOfErrors++;
        ////            }
        ////        }

        ////        // Save tables to database.
        ////        context.GetSpeciesObservationDatabase().AddTableData(speciesObservationFieldTable);
        ////        context.GetSpeciesObservationDatabase().AddTableData(darwinCoreTable);
        ////        if (noOfErrors > 0)
        ////            context.GetSpeciesObservationDatabase().AddTableData(speciesObservationErrorFieldTable);
        ////    }

        ////}

        /// <summary>
        /// Insert all changed (updated) observations into a DataTable
        /// First check the observation
        /// If ok, add it to SpeciesObservationUpdateTable and DarwinCoreUpdateTable
        /// If there are errors add the observation to speciesObservationErrorFieldTable.
        /// </summary>
        /// <param name="context">Web service request context.</param>
        /// <param name="speciesObservations">Updated species observations.</param>
        /// <param name="dataProvider">The dataProvider.</param>
        /// <param name="noOfUpdated">No of updated species observations.</param>
        /// <param name="noOfUpdatedErrors">No of updating errors.</param>
        public static void UpdateSpeciesObservations(WebServiceContext context,
                                                     List <HarvestSpeciesObservation> speciesObservations,
                                                     WebSpeciesObservationDataProvider dataProvider,
                                                     out int noOfUpdated,
                                                     out int noOfUpdatedErrors)
        {
            noOfUpdated       = 0;
            noOfUpdatedErrors = 0;

            if (!speciesObservations.IsNotEmpty())
            {
                return;
            }

            DataTable darwinCoreTable = HarvestManager.GetDarwinCoreTable(HarvestManager.UPDATE);
            DataTable speciesObservationFieldTable      = HarvestManager.GetSpeciesObservationFieldTable(HarvestManager.UPDATE);
            DataTable speciesObservationErrorFieldTable = HarvestManager.GetSpeciesObservationErrorFieldTable();

            // Save all species observations into tables.
            foreach (HarvestSpeciesObservation speciesObservation in speciesObservations)
            {
                string  catalogNumber;
                Boolean someError = true;
                Dictionary <SpeciesObservationPropertyId, string> errors;
                if (HarvestManager.CheckSpeciesObservation(speciesObservation, context, out errors, out catalogNumber))
                {
                    try
                    {
                        HarvestManager.AddToTempSpeciesObservation(speciesObservation,
                                                                   darwinCoreTable,
                                                                   speciesObservationFieldTable,
                                                                   -1,
                                                                   dataProvider,
                                                                   catalogNumber);
                        noOfUpdated++;
                        someError = false;
                    }
                    catch (Exception ex)
                    {
                        var prop = (SpeciesObservationPropertyId)Enum.Parse(typeof(SpeciesObservationPropertyId), ex.Message);
                        if (prop.IsNotNull())
                        {
                            errors.Add(prop, ex.InnerException.Message);
                        }
                        else
                        {
                            errors.Add(SpeciesObservationPropertyId.Id, ex.InnerException.ToString());
                        }
                    }
                }

                if (someError)
                {
                    HarvestManager.CreateSpeciesObservationError(speciesObservation,
                                                                 speciesObservationErrorFieldTable,
                                                                 dataProvider,
                                                                 errors,
                                                                 HarvestManager.UPDATE);
                    noOfUpdatedErrors++;
                }
            }

            // Save tables to database.
            context.GetSpeciesObservationDatabase().AddTableData(speciesObservationFieldTable);
            context.GetSpeciesObservationDatabase().AddTableData(darwinCoreTable);
            if (noOfUpdatedErrors > 0)
            {
                context.GetSpeciesObservationDatabase().AddTableData(speciesObservationErrorFieldTable);
            }
        }
        public void GetSpeciesObservationSynchronization()
        {
            var sightingIds = GetContext().GetSpeciesObservationDatabase().GetAllSourceSpeciesObservationIdsForInsert((int)SpeciesObservationDataProviderId.SpeciesGateway);
            var totalCount  = sightingIds.Count;
            var pageSize    = 10000;
            var pageCount   = totalCount / pageSize + 1;

            var  stopwatchM    = Stopwatch.StartNew();
            long stopwatchPrev = 0;

            var context   = GetContext();
            var connector = new ArtportalenConnector();
            var webDarwinCoreFieldDescriptions = WebServiceData.MetadataManager.GetSpeciesObservationFieldDescriptionsExtended(context, true);

            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", 0, "webDarwinCoreFieldDescriptions.");

            // Get provider information
            var dataProvider = connector.GetSpeciesObservationDataProvider(context);

            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", 0, "GetSpeciesObservationDataProvider.");
            var providerName   = dataProvider.Name;
            var dataProviderId = dataProvider.Id;

            var mappings = HarvestManager.CreateMappingList(webDarwinCoreFieldDescriptions, dataProviderId);

            //if (context.ClientToken.UserName != ApplicationIdentifier.SpeciesObservationHarvestService.ToString())
            //{
            //    WebServiceData.AuthorizationManager.CheckAuthorization(context, AuthorityIdentifier.WebServiceAdministrator);
            //}

            for (var currentPage = 0; currentPage < pageCount; currentPage++)
            {
                var start = currentPage * pageSize + (currentPage == 0 ? 0 : 1);

                if ((start + pageSize) > totalCount)
                {
                    pageSize = totalCount - start;
                }

                //Har byggt hela skördningen här och lämnat HarvestManager orörd!!

                try
                {
                    // Make sure the temp tables in db are empty
                    context.GetSpeciesObservationDatabase().EmptyTempTables();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", 0, "Empty Temp tables before reading.");

                    // Ready with provider information
                    context.GetSpeciesObservationDatabase().Log(context, providerName, LogType.Information, string.Format("Start {0}, start:{1} pageSize:{2}", providerName, start, pageSize), String.Empty);

                    connector.GetSpeciesObservationChange(sightingIds.GetRange(start, pageSize), mappings, context, new ConnectorServer());

                    //Add the deleted observations in the last loop
                    if ((currentPage + 1) == pageCount)
                    {
                        context.GetSpeciesObservationDatabase().AddTempDeleteSpeciesObservation(dataProviderId);
                        context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - DELETE", stopwatchM.ElapsedMilliseconds, " AddTempDeleteSpeciesObservation: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    }

                    // Log latest changed date (at data source), of modified information of harvested observations
                    context.GetSpeciesObservationDatabase().SetDataProviderLatestChangedDate(dataProvider.Id);

                    context.GetSpeciesObservationDatabase().UpdateTempObservationId();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - Check", stopwatchM.ElapsedMilliseconds, " UpdateTempObservationId: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().CheckTaxonIdOnTemp();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - Check", stopwatchM.ElapsedMilliseconds, " CheckTaxonIdOnTemp: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().CreatePointGoogleMercatorInTemp();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - Calculate", stopwatchM.ElapsedMilliseconds, " CreatePointGoogleMercatorInTemp: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().UpdateAccuracyAndDisturbanceRadius();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - Calculate", stopwatchM.ElapsedMilliseconds, " UpdateAccuracyAndDisturbanceRadius: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().MergeTempUpdateToPosition();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - POSITION", stopwatchM.ElapsedMilliseconds, " MergeTempUpdateToPosition: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().UpdateSpeciesObservationChange();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - CREATE & UPDATE", stopwatchM.ElapsedMilliseconds, " UpdateSpeciesObservationChange: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().MergeTempUpdateToDarwinCoreObservation();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - CREATE & UPDATE", stopwatchM.ElapsedMilliseconds, " MergeTempUpdateToDarwinCoreObservation: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().MergeTempUpdateToSpeciesObservationField();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - CREATE & UPDATE", stopwatchM.ElapsedMilliseconds, " MergeTempUpdateToSpeciesObservationField: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().CopyDeleteToSpeciesObservation();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - DELETE", stopwatchM.ElapsedMilliseconds, " CopyDeleteToSpeciesObservation: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().UpdateStatistics();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", stopwatchM.ElapsedMilliseconds, " UpdateStatistics:" + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().EmptyTempTables();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", stopwatchM.ElapsedMilliseconds, " EmptyTempTables: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().CleanLogUpdateError();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", stopwatchM.ElapsedMilliseconds, " CleanLogUpdateError: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    context.GetSpeciesObservationDatabase().CleanLogUpdateErrorDuplicates();
                    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", stopwatchM.ElapsedMilliseconds, " CleanLogUpdateErrorDuplicates: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    stopwatchPrev = stopwatchM.ElapsedMilliseconds;

                    //if (SpeciesObservationConfiguration.IsElasticsearchUsed)
                    //{
                    //  HarvestManager.UpdateSpeciesObservationsElasticsearchCurrentIndex(context);
                    //    context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", stopwatchM.ElapsedMilliseconds, " UpdateSpeciesObservationsElasticsearchCurrentIndex: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
                    //}

                    stopwatchM.Stop();
                }
                catch (Exception exception)
                {
                    WebServiceData.LogManager.LogError(context, exception);
                }
                finally
                {
                    try
                    {
                        // Clean up.
                        using (SpeciesObservationHarvestServer database = (SpeciesObservationHarvestServer)(WebServiceData.DatabaseManager.GetDatabase(context)))
                        {
                            database.EmptyTempTables();
                        }
                    }
                    catch (Exception)
                    {
                    }
                }
            }

            context.GetSpeciesObservationDatabase().CleanLogUpdateError();
            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", stopwatchM.ElapsedMilliseconds, " CleanLogUpdateError: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;

            context.GetSpeciesObservationDatabase().CleanLogUpdateErrorDuplicates();
            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", stopwatchM.ElapsedMilliseconds, " CleanLogUpdateErrorDuplicates: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev));
        }
Пример #9
0
        public void GetSpeciesObservationChange()
        {
            Int64 maxReturnedChanges = 100000;
            var   changedFrom        = new DateTime(2014, 7, 1);
            //// var changedFrom = new DateTime(1987, 7, 1);
            ////var changedTo = new DateTime(2015, 10, 29);
            var changedTo = new DateTime(2014, 9, 29);

            var kulConnector = new KulConnector();
            List <WebSpeciesObservationFieldDescriptionExtended> webDarwinCoreFieldDescriptions = WebServiceData.MetadataManager.GetSpeciesObservationFieldDescriptionsExtended(GetContext(), true);

            WebServiceContext context = GetContext();

            // Read meta data for current job
            var harvestJobManager = new HarvestJobManager(context);
            var harvestJob        = harvestJobManager.GetHarvestJob();

            WebSpeciesObservationDataProvider dataProvider = kulConnector.GetSpeciesObservationDataProvider(context);
            var dataProviderId = new List <int>()
            {
                dataProvider.Id
            };

            var mappings = HarvestManager.CreateMappingList(webDarwinCoreFieldDescriptions, dataProvider.Id);


            // Log data provider harvest status

            /*
             * context.GetSpeciesObservationDatabase().EmptyTempTables();
             * context.GetSpeciesObservationDatabase().CleanLogUpdateError();
             * context.GetSpeciesObservationDatabase().CleanLogUpdateErrorDuplicates();
             */

            context.GetSpeciesObservationDatabase().SetHarvestJobStatistics(dataProviderId, harvestJob.JobStatus, changedFrom);

            //// Stopwatch stopwatch1 = Stopwatch.StartNew();
            while (changedFrom < changedTo)
            {
                //// stopwatch1.Reset();
                //// stopwatch1 = Stopwatch.StartNew();
                kulConnector.GetSpeciesObservationChange(changedFrom, true, changedFrom.AddMonths(1), true, 0, false, maxReturnedChanges, mappings, GetContext(), new ConnectorServer());
                changedFrom = changedFrom.AddMonths(1);
                //// Debug.WriteLine("Harvest and fix: " + DateTime.Now.ToLongTimeString() + " - Time: " + stopwatch1.ElapsedMilliseconds);
            }


            // Log latest changed date (at data source), of modified information of harvested observations
            context.GetSpeciesObservationDatabase().SetDataProviderLatestChangedDate(dataProvider.Id);

            Stopwatch stopwatchM = Stopwatch.StartNew();
            string    logMessage = String.Empty;

            long stopwatchPrev = 0;

            context.GetSpeciesObservationDatabase().UpdateTempObservationId();
            logMessage   += " ID: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;

            context.GetSpeciesObservationDatabase().CheckTaxonIdOnTemp();
            logMessage   += ", TAXON: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;

            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - Check", stopwatchM.ElapsedMilliseconds, logMessage);
            logMessage = String.Empty;

            context.GetSpeciesObservationDatabase().CreatePointGoogleMercatorInTemp();
            logMessage   += " POINT: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;
            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - Calculate", stopwatchM.ElapsedMilliseconds, logMessage);
            logMessage = String.Empty;

            context.GetSpeciesObservationDatabase().UpdateAccuracyAndDisturbanceRadius();
            logMessage   += " ACCURACY_AND_DISTURBANCE_RADIUS: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;
            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - Calculate", stopwatchM.ElapsedMilliseconds, logMessage);
            logMessage = String.Empty;

            context.GetSpeciesObservationDatabase().MergeTempUpdateToPosition();
            logMessage   += " POSITION: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;
            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - POSITION", stopwatchM.ElapsedMilliseconds, logMessage);
            logMessage = String.Empty;

            context.GetSpeciesObservationDatabase().UpdateSpeciesObservationChange();
            logMessage   += " SOC: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;

            context.GetSpeciesObservationDatabase().MergeTempUpdateToDarwinCoreObservation();
            logMessage   += " DCO: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;

            context.GetSpeciesObservationDatabase().MergeTempUpdateToSpeciesObservationField();
            logMessage   += ", SOF: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;

            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - CREATE & UPDATE", stopwatchM.ElapsedMilliseconds, logMessage);
            logMessage = String.Empty;

            context.GetSpeciesObservationDatabase().CopyDeleteToSpeciesObservation();
            logMessage   += " SO: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;
            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest SP - DELETE", stopwatchM.ElapsedMilliseconds, logMessage);
            logMessage = String.Empty;

            context.GetSpeciesObservationDatabase().UpdateStatistics();
            logMessage   += ", DPS:" + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);
            stopwatchPrev = stopwatchM.ElapsedMilliseconds;

            context.GetSpeciesObservationDatabase().EmptyTempTables();
            logMessage += ", Empty: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);

            context.GetSpeciesObservationDatabase().CleanLogUpdateError();
            context.GetSpeciesObservationDatabase().CleanLogUpdateErrorDuplicates();
            logMessage += ", LUE: " + (stopwatchM.ElapsedMilliseconds - stopwatchPrev);

            stopwatchM.Stop();
            context.GetSpeciesObservationDatabase().LogHarvestMove(context, "Harvest DB - OPERATIONS", stopwatchM.ElapsedMilliseconds, logMessage);

            // Log data provider harvest status
            context.GetSpeciesObservationDatabase().SetHarvestJobStatistics(dataProviderId, HarvestStatusEnum.Done, changedFrom);
        }