private static void ArchiveRouts(Linq.Entities spedc, Linq2SQL.SHRARCHIVE sqledc, int archivalDelay, Action <ProgressChangedEventArgs> reportProgress, Action <string> trace)
{
int _year = 365;
reportProgress(new ProgressChangedEventArgs(1, "Starting archive the lists: Route, SecurityEscortCatalog"));
//Route
trace("Loading the List Route at ArchiveRouts");
List <Linq.Route> _Route2BeDeleted = spedc.Route.ToList <Linq.Route>().Where <Linq.Route>(x => x.Shipping.Count == 0 && x.Created.IsLatter(new TimeSpan(_year, 0, 0, 0).Days + archivalDelay)).ToList <Linq.Route>();
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} Route entries to be deleted.", _Route2BeDeleted.Count)));
spedc.Route.Delete <Linq.Route, Linq2SQL.History>
(_Route2BeDeleted, null, x => sqledc.Route.GetAt <Linq2SQL.Route>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
//SecurityEscortCatalog
trace("Loading the List Route at ArchiveRouts");
List <Linq.SecurityEscortCatalog> _SecurityEscortCatalog2BeDeleted =
spedc.SecurityEscortRoute.ToList <Linq.SecurityEscortCatalog>().Where <Linq.SecurityEscortCatalog>(x => x.Shipping.Count == 0 && x.Created.IsLatter(new TimeSpan(_year, 0, 0, 0).Days + archivalDelay)).ToList <Linq.SecurityEscortCatalog>();
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} Route entries to be deleted.", _SecurityEscortCatalog2BeDeleted.Count)));
spedc.SecurityEscortRoute.Delete <Linq.SecurityEscortCatalog, Linq2SQL.History>
(_SecurityEscortCatalog2BeDeleted, null, x => sqledc.SecurityEscortRoute.GetAt <Linq2SQL.SecurityEscortRoute>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
trace("SubmitChanges for the lists: Route, SecurityEscortCatalog have been archived.");
CAS.SharePoint.Client.SP2SQLInteroperability.Extensions.SubmitChanges(spedc, sqledc, (x, y) => reportProgress(y));
reportProgress(new ProgressChangedEventArgs(1, "The lists: Route, SecurityEscortCatalog have been archived."));
}
private static bool DoDriversTeam(Linq.Entities spedc, Linq2SQL.SHRARCHIVE sqledc, Action <ProgressChangedEventArgs> reportProgress, Action <string> trace)
{
bool _breakingIssueEncountered = false;
trace("Entering DoDriversTeam");
List <Linq.Shipping> _ShippingShippingAll = spedc.Shipping.ToList <Linq.Shipping>();
List <Linq.ShippingDriversTeam> _ShippingDriversTeamAll = spedc.DriversTeam.ToList <Linq.ShippingDriversTeam>();
List <Linq.ShippingDriversTeam> _ShippingDriversTeam2BeDeleted = _ShippingDriversTeamAll.Where <Linq.ShippingDriversTeam>(x => x.DriverTitle == null).ToList <Linq.ShippingDriversTeam>();
try
{
_ShippingDriversTeam2BeDeleted.AddRange(_ShippingDriversTeamAll.Where <Linq.ShippingDriversTeam>(x => x.ShippingIndex == null));
}
catch (Exception ex)
{
_ShippingDriversTeamAll = null;
reportProgress(new ProgressChangedEventArgs(1, String.Format("DoDriversTeam - Shipping lookup test aborter by the exception: {0}.", ex.Message)));
}
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} ShippingDriversTeam entries to be deleted because they have empty lookup on Shipping or Driver.", _ShippingDriversTeam2BeDeleted.Count())));
spedc.DriversTeam.Delete <Linq.ShippingDriversTeam, Linq2SQL.History>
(_ShippingDriversTeam2BeDeleted, null, x => sqledc.DriversTeam.GetAt <Linq2SQL.DriversTeam>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, "Starting SubmitChanges."));
CAS.SharePoint.Client.SP2SQLInteroperability.Extensions.SubmitChanges(spedc, sqledc, (x, y) => reportProgress(y));
trace("Successfully finished cleanup of the Drivers Team list.");
reportProgress(new ProgressChangedEventArgs(1, String.Format("Finished consistency check of list Drivers Team with result {0}.", _breakingIssueEncountered ? "Failed" : "Success")));
return(_breakingIssueEncountered);
}
private static bool DoShippingPoint(Linq.Entities spedc, Linq2SQL.SHRARCHIVE sqledc, Action <ProgressChangedEventArgs> reportProgress, Action <string> trace)
{
trace("Entering DoShippingPoint");
IEnumerable <Linq.ShippingPoint> _ShippingPointAllCandidates = spedc.ShippingPoint.ToList <Linq.ShippingPoint>().Where <Linq.ShippingPoint>(x => x.WarehouseTitle == null);
if (_ShippingPointAllCandidates.Count() == 0)
{
trace("Finished DoShippingPoint - there is no shipping point entries to be deleted.");
return(false);
}
reportProgress(new ProgressChangedEventArgs(1, String.Format("ShippingPoint processing. There are {0} candidate entries to be deleted.", _ShippingPointAllCandidates.Count())));
List <Linq.TimeSlotTimeSlot> _TimeSlotAll = spedc.TimeSlot.ToList <Linq.TimeSlotTimeSlot>();
List <Linq.ShippingPoint> _ShippingPoint2BeDeleted = new List <Linq.ShippingPoint>();
foreach (Linq.ShippingPoint _item in _ShippingPointAllCandidates)
{
if (!_TimeSlotAll.Where <Linq.TimeSlotTimeSlot>(x => x.TimeSlot2ShippingPointLookup == _item).Any <Linq.TimeSlotTimeSlot>())
{
_ShippingPoint2BeDeleted.Add(_item);
}
}
if (_ShippingPoint2BeDeleted.Count() == 0)
{
trace("Finished DoShippingPoint - there is no shipping point entries to be deleted.");
return(false);
}
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} ShippingPoint entries to be deleted.", _ShippingPoint2BeDeleted.Count())));
List <Linq.ScheduleTemplate> _ScheduleTemplateAll = spedc.ScheduleTemplate.ToList <Linq.ScheduleTemplate>();
List <Linq.ScheduleTemplate> _ScheduleTemplate2BeDeleted = new List <Linq.ScheduleTemplate>();
foreach (Linq.ShippingPoint _item in _ShippingPoint2BeDeleted)
{
_ScheduleTemplate2BeDeleted.AddRange(_ScheduleTemplateAll.Where(z => z.ShippingPointLookupTitle == _item));
}
List <Linq.TimeSlotsTemplate> _TimeSlotsTemplateAll = spedc.TimeSlotsTemplate.ToList <Linq.TimeSlotsTemplate>();
List <Linq.TimeSlotsTemplate> _TimeSlotsTemplate22BeDeleted = new List <Linq.TimeSlotsTemplate>();
foreach (Linq.ScheduleTemplate _item in _ScheduleTemplate2BeDeleted)
{
_TimeSlotsTemplate22BeDeleted.AddRange(_TimeSlotsTemplateAll.Where(z => z.ScheduleTemplateTitle == _item));
}
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} TimeSlotsTemplate entries to be deleted.", _TimeSlotsTemplate22BeDeleted.Count())));
spedc.TimeSlotsTemplate.Delete <Linq.TimeSlotsTemplate, Linq2SQL.History>
(_TimeSlotsTemplate22BeDeleted, null, x => sqledc.TimeSlotsTemplate.GetAt <Linq2SQL.TimeSlotsTemplate>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} ScheduleTemplate entries to be deleted.", _ScheduleTemplate2BeDeleted.Count())));
spedc.ScheduleTemplate.Delete <Linq.ScheduleTemplate, Linq2SQL.History>
(_ScheduleTemplate2BeDeleted, null, x => sqledc.ScheduleTemplate.GetAt <Linq2SQL.ScheduleTemplate>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} ShippingPoint entries to be deleted.", _ShippingPoint2BeDeleted.Count())));
spedc.ShippingPoint.Delete <Linq.ShippingPoint, Linq2SQL.History>
(_ShippingPoint2BeDeleted, null, x => sqledc.ShippingPoint.GetAt <Linq2SQL.ShippingPoint>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, "Starting SubmitChanges."));
CAS.SharePoint.Client.SP2SQLInteroperability.Extensions.SubmitChanges(spedc, sqledc, (x, y) => reportProgress(y));
trace("Finished DoShippingPoint - cleanup of the following list TimeSlotsTemplate, ScheduleTemplate, ShippingPoint");
return(false);
}
private static void ArchiveShipping(Linq.Entities spedc, Linq2SQL.SHRARCHIVE sqledc, int archivalDelay, Action <ProgressChangedEventArgs> reportProgress, Action <string> trace)
{
reportProgress(new ProgressChangedEventArgs(1, "Starting archive the lists: TimeSlot, AlarmsAndEvents, LoadDescription, DriversTeam, Shipping"));
trace("Starting GoShipping");
List <Linq.Shipping> _Shipping2Delete = spedc.Shipping.ToList <Linq.Shipping>().Where <Linq.Shipping>(x => (x.ShippingState == Linq.ShippingState.Completed ||
x.ShippingState == Linq.ShippingState.Canceled) &&
x.EndTime.IsLatter(archivalDelay)).ToList <Linq.Shipping>();
trace(String.Format("List of Shipping loaded and contains {0} items.", _Shipping2Delete.Count));
List <Linq.TimeSlotTimeSlot> _TimeSlot2Delete = new List <Linq.TimeSlotTimeSlot>();
trace(String.Format("List of TimeSlotTimeSlot loaded and contains {0} items.", _Shipping2Delete.Count));
List <Linq.AlarmsAndEvents> _AlarmsAndEvents2Delete = new List <Linq.AlarmsAndEvents>();
trace(String.Format("List of AlarmsAndEvents loaded and contains {0} items.", _Shipping2Delete.Count));
List <Linq.LoadDescription> _LoadDescription2Delete = new List <Linq.LoadDescription>();
trace(String.Format("List of LoadDescription loaded and contains {0} items.", _Shipping2Delete.Count));
List <Linq.ShippingDriversTeam> _ShippingDriversTeam2Delete = new List <Linq.ShippingDriversTeam>();
trace(String.Format("List of ShippingDriversTeam loaded and contains {0} items.", _Shipping2Delete.Count));
//TODO http://casas:11227/sites/awt/_layouts/listform.aspx?PageType=4&ListId={72C511B5-8B63-4DFA-AD34-133A97EBA469}&ID=4568&ContentTypeID=0x01005D39260836CE498D8E0D443AD5CAD3AC00456AB372ACF9DA41B8AE870CD1954927
//TODO workaround to avoid usage of the reverse lookup for doubled type definition.
List <Linq.TimeSlotTimeSlot> _TimeSlotTimeSlotAll = spedc.TimeSlot.ToList <Linq.TimeSlotTimeSlot>();;
foreach (Linq.Shipping _shipping in _Shipping2Delete)
{
_TimeSlot2Delete.AddRange(_TimeSlotTimeSlotAll.Where <Linq.TimeSlotTimeSlot>(x => x.TimeSlot2ShippingIndex == _shipping));
_AlarmsAndEvents2Delete.AddRange(_shipping.AlarmsAndEvents);
_LoadDescription2Delete.AddRange(_shipping.LoadDescription);
_ShippingDriversTeam2Delete.AddRange(_shipping.ShippingDriversTeam);
}
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} TimeSlot entries to be deleted.", _TimeSlot2Delete.Count)));
spedc.TimeSlot.Delete <Linq.TimeSlotTimeSlot, Linq2SQL.History>
(_TimeSlot2Delete, null, x => null, (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} AlarmsAndEvents entries to be deleted.", _AlarmsAndEvents2Delete.Count)));
spedc.AlarmsAndEvents.Delete <Linq.AlarmsAndEvents, Linq2SQL.History>
(_AlarmsAndEvents2Delete, null, x => null, (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} LoadDescription entries to be deleted.", _LoadDescription2Delete.Count)));
spedc.LoadDescription.Delete <Linq.LoadDescription, Linq2SQL.History>
(_LoadDescription2Delete, null, x => sqledc.LoadDescription.GetAt <Linq2SQL.LoadDescription>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} DriversTeam entries to be deleted.", _ShippingDriversTeam2Delete.Count)));
spedc.DriversTeam.Delete <Linq.ShippingDriversTeam, Linq2SQL.History>
(_ShippingDriversTeam2Delete, null, x => sqledc.DriversTeam.GetAt <Linq2SQL.DriversTeam>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} Shipping entries to be deleted.", _Shipping2Delete.Count)));
spedc.Shipping.Delete <Linq.Shipping, Linq2SQL.History>
(_Shipping2Delete, null, x => sqledc.Shipping.GetAt <Linq2SQL.Shipping>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
trace("SubmitChanges for the lists: Truck, Trailer, Driver have been archived.");
CAS.SharePoint.Client.SP2SQLInteroperability.Extensions.SubmitChanges(spedc, sqledc, (x, y) => reportProgress(y));
reportProgress(new ProgressChangedEventArgs(1, "The lists: TimeSlot, AlarmsAndEvents, LoadDescription, DriversTeam, Shipping have been archived."));
}
/// <summary>
/// Does the archiving of the Shepherd content.
/// </summary>
/// <param name="URL">The requested URL.</param>
/// <param name="sqlConnectionString">The SQL connection string.</param>
/// <param name="archivalDelay">The archival delay.</param>
/// <param name="rowLimit">The row limit.</param>
/// <param name="reportProgress">An action to trace progress in a log stream.</param>
/// <param name="trace">An action to trace progress in a log stream.</param>
public static void DoArchivingContent(string URL, string sqlConnectionString, int archivalDelay, int rowLimit, Action <ProgressChangedEventArgs> reportProgress, Action <String> trace)
{
reportProgress(new ProgressChangedEventArgs(1, String.Format("Starting DoArchivingContent URL: {0}, connection string: {1}, ArchivalDelay: {2}, RowLimit: {3}", URL, sqlConnectionString, archivalDelay, rowLimit)));
trace("Establishing connection with the SP site and SQL database to execute ArchiveShipping.");
using (Linq2SQL.SHRARCHIVE _sqledc = Linq2SQL.SHRARCHIVE.Connect2SQL(sqlConnectionString, y => trace(y)))
{
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
_spedc.RowLimit = rowLimit;
ArchiveShipping(_spedc, _sqledc, archivalDelay, reportProgress, trace);
}
}
trace("Establishing connection with the SP site and SQL database to execute ArchiveDictionaries .");
using (Linq2SQL.SHRARCHIVE _sqledc = Linq2SQL.SHRARCHIVE.Connect2SQL(sqlConnectionString, y => trace(y)))
{
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
_spedc.RowLimit = rowLimit;
ArchiveDictionaries(_spedc, _sqledc, archivalDelay, reportProgress, trace);
}
}
trace("Establishing connection with the SP site and SQL database to execute ArchiveRouts.");
using (Linq2SQL.SHRARCHIVE _sqledc = Linq2SQL.SHRARCHIVE.Connect2SQL(sqlConnectionString, y => trace(y)))
{
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
_spedc.RowLimit = rowLimit;
ArchiveRouts(_spedc, _sqledc, archivalDelay, reportProgress, trace);
}
}
trace("Establishing connection with the SP site and SQL database to execute ArchiveBusinessDescription.");
using (Linq2SQL.SHRARCHIVE _sqledc = Linq2SQL.SHRARCHIVE.Connect2SQL(sqlConnectionString, y => trace(y)))
{
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
_spedc.RowLimit = rowLimit;
ArchiveBusinessDescription(_spedc, _sqledc, archivalDelay, reportProgress, trace);
}
}
trace("Establishing connection with the SP site and SQL database to execute ArchiveCarrierPerformanceReport.");
using (Linq2SQL.SHRARCHIVE _sqledc = Linq2SQL.SHRARCHIVE.Connect2SQL(sqlConnectionString, y => trace(y)))
{
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
_spedc.RowLimit = rowLimit;
ArchiveCarrierPerformanceReport(_spedc, _sqledc, archivalDelay, reportProgress, trace);
}
}
//Business Description
reportProgress(new ProgressChangedEventArgs(1, "Updating Activities Logs"));
using (Linq2SQL.SHRARCHIVE _sqledc = Linq2SQL.SHRARCHIVE.Connect2SQL(sqlConnectionString, y => trace(y)))
ArchivingOperationLogs.UpdateActivitiesLogs <Linq2SQL.ArchivingOperationLogs>(_sqledc, ArchivingOperationLogs.OperationName.Archiving, reportProgress);
reportProgress(new ProgressChangedEventArgs(1, "Finished DoArchivingContent"));
}
private static void ArchiveCarrierPerformanceReport(Linq.Entities spedc, Linq2SQL.SHRARCHIVE sqledc, int archivalDelay, Action <ProgressChangedEventArgs> reportProgress, Action <string> trace)
{
//CarrierPerformanceReport
trace("Loading the List CarrierPerformanceReport at ArchiveCarrierPerformanceReport");
List <Linq.CarrierPerformanceReport> _CarrierPerformanceReport2BeDeleted =
spedc.CarrierPerformanceReport.ToList <Linq.CarrierPerformanceReport>().Where <Linq.CarrierPerformanceReport>(x => x.Created.IsLatter(archivalDelay)).ToList <Linq.CarrierPerformanceReport>();
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} CarrierPerformanceReport entries to be deleted.", _CarrierPerformanceReport2BeDeleted.Count)));
spedc.CarrierPerformanceReport.Delete <Linq.CarrierPerformanceReport, Linq2SQL.History>
(_CarrierPerformanceReport2BeDeleted, null, x => sqledc.CarrierPerformanceReport.GetAt <Linq2SQL.CarrierPerformanceReport>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
trace("SubmitChanges for the list: CarrierPerformanceReport have been archived.");
CAS.SharePoint.Client.SP2SQLInteroperability.Extensions.SubmitChanges(spedc, sqledc, (x, y) => reportProgress(y));
reportProgress(new ProgressChangedEventArgs(1, "The list: CarrierPerformanceReport have been archived."));
}
private static void ArchiveBusinessDescription(Linq.Entities spedc, Linq2SQL.SHRARCHIVE sqledc, int archivalDelay, Action <ProgressChangedEventArgs> reportProgress, Action <string> trace)
{
//BusienssDescription
trace("Loading the List BusienssDescription at ArchiveBusinessDescription");
List <Linq.BusienssDescription> _BusinessDescription2BeDeleted =
spedc.BusinessDescription.ToList <Linq.BusienssDescription>().Where <Linq.BusienssDescription>(x => x.Route.Count == 0 && x.SecurityEscortCatalog.Count == 0).ToList <Linq.BusienssDescription>();
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} BusienssDescription entries to be deleted.", _BusinessDescription2BeDeleted.Count)));
spedc.BusinessDescription.Delete <Linq.BusienssDescription, Linq2SQL.History>
(_BusinessDescription2BeDeleted, null, x => sqledc.BusinessDescription.GetAt <Linq2SQL.BusinessDescription>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
trace("SubmitChanges for the list: BusienssDescription have been archived.");
CAS.SharePoint.Client.SP2SQLInteroperability.Extensions.SubmitChanges(spedc, sqledc, (x, y) => reportProgress(y));
reportProgress(new ProgressChangedEventArgs(1, "The list: BusienssDescription have been archived."));
}
/// <summary>
/// Connects the clint to the SQL database.
/// </summary>
/// <param name="connectionString">The connection string.</param>
/// <param name="progressChanged">The progress changed.</param>
/// <returns>Instance of the <see cref="SHRARCHIVE"/>.</returns>
internal static SHRARCHIVE Connect2SQL(string connectionString, Action <string> progressChanged)
{
progressChanged(String.Format("Attempt to connect to SQL at: {0}", connectionString));
System.Data.IDbConnection _connection = new SqlConnection(connectionString);
SHRARCHIVE _entities = new SHRARCHIVE(_connection);
if (_entities.DatabaseExists())
{
progressChanged("The specified database exists.");
}
else
{
progressChanged("The specified database does not exist.");
}
return(_entities);
}
/// <summary>
/// Runs the synchronization of the SharePoint and SQL.
/// </summary>
/// <param name="URL">The requested URL.</param>
/// <param name="sqlConnectionString">The SQL connection string.</param>
/// <param name="reportProgress">An action to trace progress in a log stream.</param>
/// <param name="trace">An action to trace progress in a log stream.</param>
public static void DoSynchronizationContent(string URL, string sqlConnectionString, Action <ProgressChangedEventArgs> reportProgress, Action <String> trace)
{
reportProgress(new ProgressChangedEventArgs(1, String.Format("Starting DoSynchronizationContent URL: {0}, connection string: {1}", URL, sqlConnectionString)));
trace("Establishing connection with the SP site and SQL database.");
using (Linq.Entities _edc = new Linq.Entities(trace, URL))
{
using (Linq2SQL.SHRARCHIVE _sqledc = Linq2SQL.SHRARCHIVE.Connect2SQL(sqlConnectionString, y => trace(y)))
{
Synchronizer.Synchronize <Linq2SQL.Commodity, Linq.Commodity>(_sqledc.Commodity, _edc.Commodity, (x, y) => reportProgress(y), Linq.Commodity.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Warehouse, Linq.Warehouse>(_sqledc.Warehouse, _edc.Warehouse, (x, y) => reportProgress(y), Linq.Warehouse.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Partner, Linq.Partner>(_sqledc.Partner, _edc.Partner, (x, y) => reportProgress(y), Linq.Partner.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Currency, Linq.Currency>(_sqledc.Currency, _edc.Currency, (x, y) => reportProgress(y), Linq.Currency.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.FreightPayer, Linq.FreightPayer>(_sqledc.FreightPayer, _edc.FreightPayer, (x, y) => reportProgress(y), Linq.FreightPayer.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.BusinessDescription, Linq.BusienssDescription>(_sqledc.BusinessDescription, _edc.BusinessDescription, (x, y) => reportProgress(y), Linq.BusienssDescription.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.SecurityEscortRoute, Linq.SecurityEscortCatalog>(_sqledc.SecurityEscortRoute, _edc.SecurityEscortRoute, (x, y) => reportProgress(y), Linq.SecurityEscortCatalog.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.SealProtocolLibrary, Linq.SealProtocol>(_sqledc.SealProtocolLibrary, _edc.SealProtocolLibrary, (x, y) => reportProgress(y), Linq.SealProtocol.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Country, Linq.CountryType>(_sqledc.Country, _edc.Country, (x, y) => reportProgress(y), Linq.CountryType.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.City, Linq.CityType>(_sqledc.City, _edc.City, (x, y) => reportProgress(y), Linq.CityType.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.EscortPOLibrary, Linq.EscortPO>(_sqledc.EscortPOLibrary, _edc.EscortPOLibrary, (x, y) => reportProgress(y), Linq.EscortPO.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.FreightPOLibrary, Linq.FreightPO>(_sqledc.FreightPOLibrary, _edc.FreightPOLibrary, (x, y) => reportProgress(y), Linq.FreightPO.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Carrier, Linq.CarrierType>(_sqledc.Carrier, _edc.Carrier, (x, y) => reportProgress(y), Linq.CarrierType.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.SAPDestinationPlant, Linq.SAPDestinationPlant>(_sqledc.SAPDestinationPlant, _edc.SAPDestinationPlant, (x, y) => reportProgress(y), Linq.SAPDestinationPlant.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.ShipmentType, Linq.ShipmentType>(_sqledc.ShipmentType, _edc.ShipmentType, (x, y) => reportProgress(y), Linq.ShipmentType.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.TransportUnitType, Linq.TranspotUnit>(_sqledc.TransportUnitType, _edc.TransportUnitType, (x, y) => reportProgress(y), Linq.TranspotUnit.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Route, Linq.Route>(_sqledc.Route, _edc.Route, (x, y) => reportProgress(y), Linq.Route.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Truck, Linq.Truck>(_sqledc.Truck, _edc.Truck, (x, y) => reportProgress(y), Linq.Truck.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Trailer, Linq.Trailer>(_sqledc.Trailer, _edc.Trailer, (x, y) => reportProgress(y), Linq.Trailer.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Shipping, Linq.Shipping>(_sqledc.Shipping, _edc.Shipping, (x, y) => reportProgress(y), Linq.Shipping.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.CarrierPerformanceReport, Linq.CarrierPerformanceReport>(_sqledc.CarrierPerformanceReport, _edc.CarrierPerformanceReport, (x, y) => reportProgress(y), Linq.CarrierPerformanceReport.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Market, Linq.Market>(_sqledc.Market, _edc.Market, (x, y) => reportProgress(y), Linq.Market.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.DestinationMarket, Linq.DestinationMarket>(_sqledc.DestinationMarket, _edc.DestinationMarket, (x, y) => reportProgress(y), Linq.DestinationMarket.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.Driver, Linq.Driver>(_sqledc.Driver, _edc.Driver, (x, y) => reportProgress(y), Linq.Driver.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.DriversTeam, Linq.ShippingDriversTeam>(_sqledc.DriversTeam, _edc.DriversTeam, (x, y) => reportProgress(y), Linq.ShippingDriversTeam.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.LoadDescription, Linq.LoadDescription>(_sqledc.LoadDescription, _edc.LoadDescription, (x, y) => reportProgress(y), Linq.LoadDescription.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.ShippingPoint, Linq.ShippingPoint>(_sqledc.ShippingPoint, _edc.ShippingPoint, (x, y) => reportProgress(y), Linq.ShippingPoint.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.ScheduleTemplate, Linq.ScheduleTemplate>(_sqledc.ScheduleTemplate, _edc.ScheduleTemplate, (x, y) => reportProgress(y), Linq.ScheduleTemplate.GetMappings(), false);
Synchronizer.Synchronize <Linq2SQL.TimeSlotsTemplate, Linq.TimeSlotsTemplate>(_sqledc.TimeSlotsTemplate, _edc.TimeSlotsTemplate, (x, y) => reportProgress(y), Linq.TimeSlotsTemplate.GetMappings(), false); //TODO MP
}
using (Linq2SQL.SHRARCHIVE _sqledc = Linq2SQL.SHRARCHIVE.Connect2SQL(sqlConnectionString, y => trace(y)))
CAS.SharePoint.Client.Link2SQL.ArchivingOperationLogs.UpdateActivitiesLogs <Linq2SQL.ArchivingOperationLogs>(_sqledc, CAS.SharePoint.Client.Link2SQL.ArchivingOperationLogs.OperationName.Synchronization, reportProgress);
reportProgress(new ProgressChangedEventArgs(1, "Finished DoSynchronizationContent"));
}
}
/// <summary>
/// Does the cleanup of the lists <see cref="Linq.ScheduleTemplate"/>, <see cref="Linq.TimeSlotsTemplate"/>, <see cref="Linq.TimeSlotTimeSlot"/>.
/// </summary>
/// <param name="spedc">The spedc.</param>
/// <param name="sqledc">The sqledc.</param>
/// <param name="reportProgress">The report progress.</param>
/// <param name="trace">The trace.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private static bool DoTimeSlotsTemplate(Linq.Entities spedc, Linq2SQL.SHRARCHIVE sqledc, Action <ProgressChangedEventArgs> reportProgress, Action <String> trace)
{
trace("Entering DoTimeSlotsTemplate");
bool _ret = false;
reportProgress(new ProgressChangedEventArgs(1, "Starting ScheduleTemplate and TimeSlotsTemplate lists processing."));
IEnumerable <Linq.ScheduleTemplate> _ScheduleTemplate2BeDeleted = spedc.ScheduleTemplate.ToList <Linq.ScheduleTemplate>().Where <Linq.ScheduleTemplate>(x => x.ShippingPointLookupTitle == null);
List <Linq.TimeSlotsTemplate> _TimeSlotsTemplateAll = spedc.TimeSlotsTemplate.ToList <Linq.TimeSlotsTemplate>();
List <Linq.TimeSlotsTemplate> _TimeSlotsTemplate2BeDeleted = new List <Linq.TimeSlotsTemplate>();
foreach (Linq.ScheduleTemplate _item in _ScheduleTemplate2BeDeleted)
{
_TimeSlotsTemplate2BeDeleted.AddRange(_TimeSlotsTemplateAll.Where <Linq.TimeSlotsTemplate>(x => x.ScheduleTemplateTitle == _item));
}
_TimeSlotsTemplate2BeDeleted.AddRange(_TimeSlotsTemplateAll.Where <Linq.TimeSlotsTemplate>(x => x.ScheduleTemplateTitle == null));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} TimeSlotsTemplate entries to be deleted.", _TimeSlotsTemplate2BeDeleted.Count)));
spedc.TimeSlotsTemplate.Delete <Linq.TimeSlotsTemplate, Linq2SQL.History>
(_TimeSlotsTemplate2BeDeleted, null, x => sqledc.TimeSlotsTemplate.GetAt <Linq2SQL.TimeSlotsTemplate>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} ScheduleTemplate entries to be deleted.", _ScheduleTemplate2BeDeleted.Count())));
spedc.ScheduleTemplate.Delete <Linq.ScheduleTemplate, Linq2SQL.History>
(_ScheduleTemplate2BeDeleted, null, x => sqledc.ScheduleTemplate.GetAt <Linq2SQL.ScheduleTemplate>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
//TimeSlotTimeSlot
reportProgress(new ProgressChangedEventArgs(1, "TimeSlot processing."));
List <Linq.TimeSlotTimeSlot> _TimeSlotAll = spedc.TimeSlot.ToList <Linq.TimeSlotTimeSlot>().Where <Linq.TimeSlotTimeSlot>(x => x.StartTime.Value < DateTime.Now).ToList <Linq.TimeSlotTimeSlot>();
List <Linq.TimeSlotTimeSlot> _TimeSlot3BeDeleted = (from _tsx in _TimeSlotAll
let _notUsed = _tsx.TimeSlot2ShippingIndex != null && (_tsx.TimeSlot2ShippingIndex.ShippingState == Linq.ShippingState.Canceled ||
_tsx.TimeSlot2ShippingIndex.ShippingState == Linq.ShippingState.Completed)
where _notUsed && _tsx.StartTime.Value < DateTime.Now
select _tsx).ToList <Linq.TimeSlotTimeSlot>();
_TimeSlot3BeDeleted.AddRange(_TimeSlotAll.Where <Linq.TimeSlotTimeSlot>(x => x.TimeSlot2ShippingIndex == null));
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} Time Slot entries to be deleted.", _TimeSlot3BeDeleted.Count())));
spedc.TimeSlot.Delete <Linq.TimeSlotTimeSlot, Linq2SQL.History>
(_TimeSlot3BeDeleted, null, x => null, (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
reportProgress(new ProgressChangedEventArgs(1, "Starting SubmitChanges."));
CAS.SharePoint.Client.SP2SQLInteroperability.Extensions.SubmitChanges(spedc, sqledc, (x, y) => reportProgress(y));
trace("Successfully finished cleanup of the following lists ScheduleTemplate, TimeSlotsTemplateTimeSlotsTemplate, TimeSlotTimeSlot");
return(_ret);
}
/// <summary>
/// Does the content cleanup.
/// </summary>
/// <param name="URL">The requested URL.</param>
/// <param name="sqlConnectionString">The SQL connection string.</param>
/// <param name="reportProgress">An action to report the progress.</param>
/// <param name="trace">An action to trace progress in a log stream.</param>
/// <exception cref="System.ArgumentException">
/// Cannot connect to SQL database.;SQLConnectionString
/// </exception>
/// <exception cref="System.ApplicationException">DoCleanupContent has encountered breaking inconsistency - review the log and remove problems to pass to next phase.</exception>
public static void DoCleanupContent(string URL, string sqlConnectionString, Action <ProgressChangedEventArgs> reportProgress, Action <String> trace)
{
bool _breakingIssueEncountered = false;
reportProgress(new ProgressChangedEventArgs(1, String.Format("Starting DoCleanupContent and establishing connection with the site {0}.", URL)));
reportProgress(new ProgressChangedEventArgs(1, String.Format("Connection string {0}", sqlConnectionString)));
System.Data.IDbConnection _connection = new SqlConnection(sqlConnectionString);
using (Linq2SQL.SHRARCHIVE _sqledc = new Linq2SQL.SHRARCHIVE(_connection))
{
if (!_sqledc.DatabaseExists())
{
throw new ArgumentException("Cannot connect to SQL database.", "SQLConnectionString");
}
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
//Warehouse
//Partner
_breakingIssueEncountered |= DoTimeSlotsTemplate(_spedc, _sqledc, reportProgress, trace);
_breakingIssueEncountered |= DoShippingPoint(_spedc, _sqledc, reportProgress, trace);
}
}
using (Linq2SQL.SHRARCHIVE _sqledc = new Linq2SQL.SHRARCHIVE(_connection))
{
if (!_sqledc.DatabaseExists())
{
throw new ArgumentException("Cannot connect to SQL database.", "SQLConnectionString");
}
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
_breakingIssueEncountered |= DoLoadDescription(_spedc, reportProgress, trace);
}
}
using (Linq2SQL.SHRARCHIVE _sqledc = new Linq2SQL.SHRARCHIVE(_connection))
{
if (!_sqledc.DatabaseExists())
{
throw new ArgumentException("Cannot connect to SQL database.", "SQLConnectionString");
}
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
_breakingIssueEncountered |= DoDriversTeam(_spedc, _sqledc, reportProgress, trace);
}
}
using (Linq2SQL.SHRARCHIVE _sqledc = new Linq2SQL.SHRARCHIVE(_connection))
{
if (!_sqledc.DatabaseExists())
{
throw new ArgumentException("Cannot connect to SQL database.", "SQLConnectionString");
}
using (Linq.Entities _spedc = new Linq.Entities(trace, URL))
{
_breakingIssueEncountered |= DoDriver(_spedc, reportProgress, trace);
_breakingIssueEncountered |= DoTruck(_spedc, reportProgress, trace);
_breakingIssueEncountered |= DoDestinationMarket(_spedc, reportProgress, trace);
_breakingIssueEncountered |= DoCarrierPerformanceReport(_spedc, reportProgress, trace);
_breakingIssueEncountered |= DoRoute(_spedc, reportProgress, trace);
_breakingIssueEncountered |= DoCity(_spedc, reportProgress, trace);
_breakingIssueEncountered |= DoSecurityEscortRoute(_spedc, reportProgress, trace);
}
}
using (Linq2SQL.SHRARCHIVE _sqledc = new Linq2SQL.SHRARCHIVE(_connection))
CAS.SharePoint.Client.Link2SQL.ArchivingOperationLogs.UpdateActivitiesLogs <Linq2SQL.ArchivingOperationLogs>(_sqledc, CAS.SharePoint.Client.Link2SQL.ArchivingOperationLogs.OperationName.Cleanup, reportProgress);
reportProgress(new ProgressChangedEventArgs(1, "Finished DoCleanupContent"));
if (_breakingIssueEncountered)
{
throw new ApplicationException("DoCleanupContent has encountered breaking inconsistency - review the log and remove problems to pass to next phase.");
}
}
/// <summary>
/// Archives the dictionaries.
/// </summary>
/// <param name="spedc">The <see cref="Linq.Entities"/> representing SharePoint application content database</param>
/// <param name="sqledc">The <see cref="Linq2SQL.SHRARCHIVE"/> representing the SQL database containing backup of SharePoint content.</param>
/// <param name="archivalDelay">The archival delay.</param>
/// <param name="reportProgress">The report progress.</param>
/// <param name="trace">The trace.</param>
private static void ArchiveDictionaries(Linq.Entities spedc, Linq2SQL.SHRARCHIVE sqledc, int archivalDelay, Action <ProgressChangedEventArgs> reportProgress, Action <string> trace)
{
reportProgress(new ProgressChangedEventArgs(1, "Starting archive the lists: Truck, Trailer, Driver"));
//Truck
List <Linq.Truck> _Truck2MarketDeleted = spedc.Truck.ToList <Linq.Truck>().Where <Linq.Truck>(x => x.ToBeDeleted.GetValueOrDefault(false)).ToList <Linq.Truck>();
trace(String.Format("List of Truck loaded and contains {0} items.", _Truck2MarketDeleted.Count));
List <Linq.Truck> _Truck2BeDeleted = new List <Linq.Truck>();
foreach (Linq.Truck _TruckItem in _Truck2MarketDeleted)
{
if (_TruckItem.Shipping.Count == 0 && _TruckItem.Shipping0.Count == 0)
{
_Truck2BeDeleted.Add(_TruckItem);
}
}
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} Truck entries to be deleted.", _Truck2BeDeleted.Count)));
spedc.Truck.Delete <Linq.Truck, Linq2SQL.History>
(_Truck2BeDeleted, null, x => sqledc.Truck.GetAt <Linq2SQL.Truck>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
_Truck2MarketDeleted = null;
_Truck2BeDeleted = null;
//Trailer
List <Linq.Trailer> _Trailer2MarketDeleted = spedc.Trailer.ToList <Linq.Trailer>().Where <Linq.Trailer>(x => x.ToBeDeleted.GetValueOrDefault(false)).ToList <Linq.Trailer>();
trace(String.Format("List of Trailer loaded and contains {0} items.", _Trailer2MarketDeleted.Count));
List <Linq.Trailer> _Trailer2BeDeleted = new List <Linq.Trailer>();
foreach (Linq.Trailer _TrailerItem in _Trailer2MarketDeleted)
{
if (_TrailerItem.Shipping.Count == 0)
{
_Trailer2BeDeleted.Add(_TrailerItem);
}
}
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} Trailer entries to be deleted.", _Trailer2BeDeleted.Count)));
spedc.Trailer.Delete <Linq.Trailer, Linq2SQL.History>
(_Trailer2BeDeleted, null, x => sqledc.Trailer.GetAt <Linq2SQL.Trailer>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
_Trailer2MarketDeleted = null;
_Trailer2BeDeleted = null;
//Driver
List <Linq.Driver> _DriverMarketDeleted = spedc.Driver.ToList <Linq.Driver>().Where <Linq.Driver>(x => x.ToBeDeleted.GetValueOrDefault(false)).ToList <Linq.Driver>();
trace(String.Format("List of Driver loaded and contains {0} items.", _DriverMarketDeleted.Count));
List <Linq.Driver> _Driver2BeDeleted = new List <Linq.Driver>();
foreach (Linq.Driver _DriverItem in _DriverMarketDeleted)
{
if (_DriverItem.ShippingDriversTeam.Count == 0)
{
_Driver2BeDeleted.Add(_DriverItem);
}
}
reportProgress(new ProgressChangedEventArgs(1, String.Format("There are {0} Driver entries to be deleted.", _Driver2BeDeleted.Count)));
spedc.Driver.Delete <Linq.Driver, Linq2SQL.History>
(_Driver2BeDeleted, null, x => sqledc.Driver.GetAt <Linq2SQL.Driver>(x), (id, listName) => sqledc.ArchivingLogs.AddLog(id, listName, Extensions.UserName()),
x => sqledc.History.AddHistoryEntry(x));
trace("SubmitChanges for the lists: Truck, Trailer, Driver have been archived.");
CAS.SharePoint.Client.SP2SQLInteroperability.Extensions.SubmitChanges(spedc, sqledc, (x, y) => reportProgress(y));
reportProgress(new ProgressChangedEventArgs(1, "The lists: Truck, Trailer, Driver have been archived."));
}
