public void update(DDPVersion ddpVersion)
{
var xx = context.DDPVersions.Where(d => d.Id == ddpVersion.Id).SingleOrDefault();
xx.published_at = ddpVersion.published_at;
context.SubmitChanges();
}
public DateTime Import(Stream stream, DDPVersion ddpversion)
{
XmlDocument ddpxml = new XmlDocument();
ddpxml.Load(stream);
return(Import(ddpxml, ddpversion));
}
/// <summary>
/// Importa un archivo DDP en formato XML a la base de datos
/// </summary>
/// <param name="fileName">Nombre del archivo en disco</param>
public void Import(string fileName, DDPVersion ddpVersion)
{
if (File.Exists(fileName) == false)
{
throw new FileNotFoundException(string.Format("File {0} not exists", fileName));
}
Import(File.Open(fileName, FileMode.Open), ddpVersion);
}
public DDPVersion GetRegularDDPVersion(string strRegularVersion)
{
DDPVersion ddpVersion = context.DDPVersions
.Where(d => d.regularVer == strRegularVersion)
.OrderByDescending(d => d.published_at)
.OrderByDescending(d => d.received_at)
.FirstOrDefault();
return(ddpVersion);
}
public DDPVersion GetDDPVersion(string strDDPVersion)
{
string[] parts = strDDPVersion.Split(':');
if (parts.Length != 2)
{
return(null);
}
DDPVersion ddpVersion = context.DDPVersions
.Where(d => d.regularVer == parts[0] && d.inmediateVer == parts[1])
.FirstOrDefault();
return(ddpVersion);
}
static public DDPVersion InsertCompleteDDP(string version, DateTime publishDate, byte[] file)
{
var ddpVersion = new DDPVersion();
using (var ddpvda = new DDPVersionDataAccess())
{
ddpVersion.published_at = publishDate;
ddpVersion.received_at = DateTime.UtcNow;
ddpVersion.regularVer = version.Split(':')[0];
ddpVersion.inmediateVer = version.Split(':')[1];
ddpVersion.DDPFile = file;
ddpvda.InsertCompleteDDP(ddpVersion);
return(ddpVersion);
}
}
public List <StandingOrder> GetOrdersForPosition(ShipPosition pos, DDPVersion ddpVersion)
{
DataLoadOptions options = new DataLoadOptions();
options.LoadWith <StandingOrder>(s => s.Place);
options.LoadWith <Place>(p => p.ContractingGoverment);
context.LoadOptions = options;
return(context.ExecuteQuery <StandingOrder>(
"SELECT s.Id, s.PlaceId FROM StandingOrder as s INNER JOIN Place on Place.Id = s.PlaceId" + Environment.NewLine +
"INNER JOIN ContractingGoverment on Place.ContractingGovermentId = ContractingGoverment.Id" + Environment.NewLine +
"INNER JOIN DDPVersion on (DDPVersion.Id = ContractingGoverment.DDPVersionId" + Environment.NewLine +
"AND DDPVersion.Id = {0})" + Environment.NewLine +
"WHERE (geography::STGeomFromWKB(Place.Area, 4326).STIntersects(" + Environment.NewLine +
"geography::STGeomFromWKB((SELECT Position FROM ShipPosition WHERE ShipPosition.Id = {1}),4326))) != 0", ddpVersion.Id, pos.Id).ToList());
}
public void ProcessPendingUpdates()
{
DDPImportHelper helper = new DDPImportHelper();
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.RequiresNew, TimeSpan.FromMinutes(10)))
{
try
{
var ddpvermgr = new DDPVersionManager();
var pendings = PendingUpdateManager.GetPendingUpdates();
foreach (var pending in pendings)
{
DDPVersion ver = null;
if (pending.type == 0)
{
ver = ddpvermgr.GetInmediateDDPVersion(pending.targetVersion);
}
else
{
ver = ddpvermgr.GetRegularDDPVersion(pending.targetVersion);
}
if (ver != null)
{
log.Info(string.Format("ProcessPendingUpdates: version {0} already exists skping ...", pending.targetVersion));
continue;
}
helper.UpdateIncrementalOrRegular(pending);
}
using (var d = new PendingUpdatesDataAccess())
{
d.Remove(pendings);
}
}
catch (Exception ex)
{
log.Error("ProcessPendingUpdates: error!", ex);
}
ts.Complete();
}
}
public ActionResult GridData(int page, int rows, string[] _search, string sidx, string sord, int?ddpid)
{
string[] ReqParams = { "Name", "DataCenterId", "LRITId", "PlaceStringId", "PlaceName", "AreaType", "PlaceId" };
List <string> columns = new List <string>();
List <string> querys = new List <string>();
//Vectores Apareados SearchQuery, Columns
for (int i = 0; i < ReqParams.Count(); i++)
{
var tempValue = Request.Params[ReqParams[i]];
if (tempValue != null)
{
columns.Add(ReqParams[i]);
querys.Add(tempValue);
}
}
var ddpda = new DDPVersionDataAccess(context);
var ddp = new DDPVersion();
if (ddpid == null)
{
ddpid = ddpda.TodaysDDP().Id;
}
var ddpdata = ddpda.GetAllFromVersion((int)ddpid);
var model = from entity in ddpdata.OrderBy(sidx + " " + sord)
select new
{
Name = entity.Name,
DataCenterId = entity.DataCenterId,
LRITId = entity.LRITId,
PlaceStringId = entity.PlaceStringId,
PlaceName = entity.PlaceName,
AreaType = entity.AreaType,
PlaceId = entity.PlaceId.ToString(),
};
return(Json(model.ToJqGridData(page, rows, null, querys.ToArray(), columns.ToArray())));
}
/// <summary>
/// Importa un archivo DDP en formato XML a la base de datos
/// </summary>
/// <param name="stream">Stream de memoria del archivo</param>
public DateTime Import(XmlDocument ddpxml, DDPVersion ddpVersion)
{
DateTime pubDate = DateTime.UtcNow;
DBDataContext context = null;
try
{
context = new DBDataContext(Config.ConnectionString);
//---------------------------------------------------
XmlNamespaceManager nsmanager = new XmlNamespaceManager(ddpxml.NameTable);
nsmanager.AddNamespace("lr", "http://gisis.imo.org/XML/LRIT/ddp/2008");
//---------------------------------------------------
//Hack-o-mati: Asociation of contracting goverment
Dictionary <ContractingGoverment, ContractingConfig> goverments = new Dictionary <ContractingGoverment, ContractingConfig>();
//Just for return, do not use here.
pubDate = DateTime.Parse(ddpxml.SelectSingleNode("/lr:DataDistributionPlan", nsmanager).Attributes["regularVersionImplementationAt"].Value);
readCGS("/lr:DataDistributionPlan/lr:ContractingGovernment", ref goverments, ref ddpxml, ref nsmanager);
readCGS("/lr:DataDistributionPlan/lr:Territory", ref goverments, ref ddpxml, ref nsmanager);
var cgda = new ContractingGovermentDataAccess(context);
var pda = new PlaceDataAccess(context);
var soda = new StandingOrderDataAccess(context);
var ssda = new SARServiceDataAccess(context);
//var exda = new ExclusionDataAccess(context);
//cgda.DropAll();
foreach (KeyValuePair <ContractingGoverment, ContractingConfig> kv in goverments)
{
kv.Key.DDPVersionId = ddpVersion.Id;
int gId = cgda.Create(kv.Key);
foreach (Place p in kv.Value.places)
{
p.ContractingGovermentId = gId;
}
foreach (SARService ss in kv.Value.sarservice)
{
ss.ContractingGovermentId = gId;
}
//foreach (Exclusion excl in kv.Value.exclusions)
// excl.ContractingGoverment = gId;
log.Debug(string.Format("{2}: Key:{0}, Value{1}", kv.Key.Name, kv.Value.places.Count, kv.Key.Id));
pda.Create(kv.Value.places.ToArray());
//exda.Create(kv.Value.exclusions.ToArray());
ssda.Create(kv.Value.sarservice.ToArray());
//Places with ids
List <Place> places = pda.GetAll(ddpVersion.regularVer + ":" + ddpVersion.inmediateVer);
//Standing orders
string path = string.Format("/lr:DataDistributionPlan/lr:CoastalStateStandingOrders/lr:StandingOrder[@contractingGovernmentID='{0}']", kv.Key.LRITId);
XmlNode standingOrder = ddpxml.SelectSingleNode(path, nsmanager);
if (standingOrder != null && !String.IsNullOrEmpty(standingOrder.InnerText))
{
foreach (string area in standingOrder.InnerText.Split(' '))
{
int id = getPlaceId(places, area);
if (id == -1)
{
continue;
}
StandingOrder so = new StandingOrder();
so.PlaceId = id;
kv.Value.standingOrders.Add(so);
}
}
//ES ACA
soda.Create(kv.Value.standingOrders.ToArray());
}
}
catch (Exception ex)
{
if (context != null)
{
context.Dispose();
}
throw new Exception("Unable to Import DDP File", ex);
}
finally
{
if (context != null)
{
context.Dispose();
}
}
return(pubDate);
}
public IQueryable <DDPData> GetAllFromVersion(DDPVersion ddp)
{
string ddpver = ddp.regularVer + ":" + ddp.inmediateVer;
return(context.DDPDatas.Where(d => d.DDPVersion == ddpver));
}
public void InsertCompleteDDP(DDPVersion ddpVersion)
{
context.DDPVersions.InsertOnSubmit(ddpVersion);
context.SubmitChanges();
}
/// <summary>
/// Verifica si un contracting goverment esta titulado para recibir una posicion de un barco
/// </summary>
/// <param name="goverment">Contracting goverment</param>
/// <param name="position">Posicion del barco</param>
/// <returns>Verdadero si esta titulado, Falso si no esta titulado</returns>
public bool IsEntitled(ContractingGoverment goverment, ShipPosition position, DDPVersion ddpVersion, bool verifyWatersOf)
{
return(IsEntitled(goverment.Id, position.Id, ddpVersion.Id, verifyWatersOf));
}
