Narvaling
/
OliviaAddInPro
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

integracion con cambios debelop

Gerardo/Compilacion.net
Gerardo 2023-01-16 10:29:41 +01:00
parent 6ed9074bf8 407d06bf00
commit 114abcccc2
18 changed files with 520 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Button/ButtonLimp.cs
View File

@ -29,8 +29,7 @@ namespace OliviaAddInPro
if (OliviaGlob.TipoView == TiposEjecucion.Ninguno) if (OliviaGlob.TipoView == TiposEjecucion.Ninguno)
{ {
///Comprueba que existe la red navegable configurada ///Comprueba que existe la red navegable configurada
if (!OliviaGlob.CompruebaNwYCampos()) if (!OliviaGlob.CompruebaNwYCampos())
{ {
HelperGlobal.ponMsg("No se encuentra red navegable, cambie Configuración: " + HelperGdb.OutStr, HelperGlobal.ponMsg("No se encuentra red navegable, cambie Configuración: " + HelperGdb.OutStr,

217
Helper/HelperGdb.cs
View File

@ -13,6 +13,7 @@ using ArcGIS.Core.Data;
using ArcGIS.Desktop.Mapping; using ArcGIS.Desktop.Mapping;
using ArcGIS.Core.Internal.CIM; using ArcGIS.Core.Internal.CIM;
using ArcGIS.Desktop.Internal.Layouts.Utilities; using ArcGIS.Desktop.Internal.Layouts.Utilities;
using ArcGIS.Desktop.Core.Geoprocessing; using ArcGIS.Desktop.Core.Geoprocessing;
using ArcGIS.Desktop.Framework.Threading.Tasks; using ArcGIS.Desktop.Framework.Threading.Tasks;
using ArcGIS.Desktop.Editing; using ArcGIS.Desktop.Editing;
@ -25,6 +26,7 @@ using ArcGIS.Core.Data.DDL;
using ArcGIS.Core.CIM; using ArcGIS.Core.CIM;
using System.Threading; using System.Threading;
using ArcGIS.Core.Data.Exceptions; using ArcGIS.Core.Data.Exceptions;
using Microsoft.Win32;
namespace OliviaAddInPro.Helper namespace OliviaAddInPro.Helper
{ {
@ -434,44 +436,123 @@ namespace OliviaAddInPro.Helper
} }
//Dado un path de una feature class devuelve la ftclass abierta directamente,
//o null si ha habido algún problema o no lo ha encontrado
public static FeatureClass GetFtClass(string pathFtClss)
{
FeatureClass ftclss = null;
if (string.IsNullOrEmpty(pathFtClss))
return null;
Geodatabase gdb = GetGdb(pathFtClss).Result;
ReiniciaOutStr();
if (gdb != null)
{
ftclss = GetFtClass(System.IO.Path.GetFileNameWithoutExtension(pathFtClss), gdb).Result;
}
else //mira a ver si es shapefile
{
ftclss = GetFtClassFromShp(pathFtClss).Result;
}
Free(gdb);
return ftclss;
}
//Dado un path de una feature class devuelve la ftclass abierta directamente, //Dado un path de una feature class devuelve la ftclass abierta directamente,
//o null si ha habido algún problema o no lo ha encontrado //o null si ha habido algún problema o no lo ha encontrado
public static FeatureClass GetFtClassSync(string pathFtClss) public static FeatureClass GetFtClassSync(string pathFtClss)
{ {
FeatureClass ftclss = null; FeatureClass ftclss = null;
FeatureDataset dtset = null;
if (string.IsNullOrEmpty(pathFtClss)) if (string.IsNullOrEmpty(pathFtClss))
return null; return null;
Geodatabase gdb = GetGdbSync(pathFtClss); Geodatabase gdb = GetGdbSync(pathFtClss);
ReiniciaOutStr(); ReiniciaOutStr();
if (gdb != null) if (gdb != null)
{ {
ftclss = GetFtClassSync(System.IO.Path.GetFileNameWithoutExtension(pathFtClss), gdb); string dtsetName = new DirectoryInfo(System.IO.Path.GetDirectoryName(pathFtClss)).Name;
try
{
dtset = gdb.OpenDataset<FeatureDataset>(dtsetName);
}
catch (Exception ex)
{
HelperGdb.OutStr = "Error al abrir Dataset " + dtsetName + ": " + ex.Message;
dtset= null;
}
string ftclassName = System.IO.Path.GetFileNameWithoutExtension(pathFtClss);
if (dtset != null)
{
try
{
ftclss = dtset.OpenDataset<FeatureClass>(ftclassName);
}
catch (Exception ex)
{
ftclss = null;
}
}
else
{
try
{
ftclss = gdb.OpenDataset<FeatureClass>(ftclassName);
}
catch (Exception ex)
{
ftclss = null;
}
}
if(ftclss==null)
HelperGdb.OutStr = "Error al abrir Feature Class " + ftclassName;
} }
else //mira a ver si es shapefile else //mira a ver si es shapefile
{ {
ftclss = GetFtClassFromShpSync(pathFtClss); ftclss = GetFtClassFromShpSync(pathFtClss).Result;
} }
Free(gdb); Free(gdb);
Free(dtset);
return ftclss;
}
//Dado un path de una feature class devuelve la ftclass abierta directamente,
//o null si ha habido algún problema o no lo ha encontrado
public static FeatureClass GetFtClass(string pathFtClss)
{
FeatureClass ftclss = null;
FeatureDataset dtset = null;
if (string.IsNullOrEmpty(pathFtClss))
return null;
Geodatabase gdb = GetGdb(pathFtClss).Result;
ReiniciaOutStr();
if (gdb != null)
{
var task = ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run((Func<FeatureClass>)(() =>
{
string dtsetName = new DirectoryInfo(System.IO.Path.GetDirectoryName(pathFtClss)).Name;
try
{
dtset = gdb.OpenDataset<FeatureDataset>(dtsetName);
}
catch (Exception ex)
{
HelperGdb.OutStr = "Error al abrir Dataset " + dtsetName + ": " + ex.Message;
dtset = null;
}
string ftclassName = System.IO.Path.GetFileNameWithoutExtension(pathFtClss);
if (dtset != null)
{
try
{
ftclss = dtset.OpenDataset<FeatureClass>(ftclassName);
}
catch (Exception ex)
{
ftclss = null;
}
}
else
{
try
{
ftclss = gdb.OpenDataset<FeatureClass>(ftclassName);
}
catch (Exception ex)
{
ftclss = null;
}
}
if (ftclss == null)
HelperGdb.OutStr = "Error al abrir Feature Class " + ftclassName;
return ftclss;
}));
task.Wait();
}
else //mira a ver si es shapefile
{
ftclss = GetFtClassFromShp(pathFtClss).Result;
}
Free(gdb);
Free(dtset);
return ftclss; return ftclss;
} }
//Dado el path de una gdb y el nombre de una feature class, devuelve la //Dado el path de una gdb y el nombre de una feature class, devuelve la
@ -486,7 +567,7 @@ namespace OliviaAddInPro.Helper
{ {
try try
{ {
ftclss = gdb.OpenDataset<FeatureClass>(nameFtclss); ftclss = gdb.OpenDataset<FeatureClass>(nameFtclss);
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -2005,12 +2086,13 @@ namespace OliviaAddInPro.Helper
if (!string.IsNullOrEmpty(ext_)) if (!string.IsNullOrEmpty(ext_))
dlg.DefaultExt = ext_; dlg.DefaultExt = ext_;
if (brwsFilt != null) if (brwsFilt != null)
{
brwsFilt.BrowsingFilesMode = true;
dlg.BrowseFilter = brwsFilt; dlg.BrowseFilter = brwsFilt;
}
try try
{ {
bool? ok = dlg.ShowDialog(); bool? ok = dlg.ShowDialog();
if ((ok ?? true) && dlg.FilePath.Length > 0) if ((ok ?? true) && dlg.FilePath.Length > 0)
return dlg.FilePath; return dlg.FilePath;
else else
@ -2088,7 +2170,8 @@ namespace OliviaAddInPro.Helper
try try
{ {
FeatureDatasetDefinition featureDatasetDefinition = gdb.GetDefinition<FeatureDatasetDefinition>(datasetName); FeatureDatasetDefinition featureDatasetDefinition = gdb.GetDefinition<FeatureDatasetDefinition>(datasetName);
if(featureDatasetDefinition.GetSpatialReference().Equals(spatref)) ArcGIS.Core.Geometry.SpatialReference entr = featureDatasetDefinition.GetSpatialReference();
if (entr.Wkid==spatref.Wkid)
return 0; return 0;
return 2; return 2;
} }
@ -2101,7 +2184,10 @@ namespace OliviaAddInPro.Helper
/** /**
* Crea un FeatureDataset con el nombre dado y la spatialrefernece dada en la gdb dada * Crea un FeatureDataset con el nombre dado y la spatialrefernece dada en la gdb dada
* Devuelve 0 si no hay que crear nada o si lo ha creado bien, 2 si existe el dataset pero con otra referencia espacial, 1 si da error * Devuelve 0 si no hay que crear nada, existe y coincide ref espac
* 2 si existe el dataset pero con otra referencia espacial, así que se crea otro
* 1 si da error
* 4 si no existe así que se crea
*/ */
public static Respuesta<int> CreateDataset(string gdbPath, string datasetName, ArcGIS.Core.Geometry.SpatialReference spatref, out string datasetNameOut) public static Respuesta<int> CreateDataset(string gdbPath, string datasetName, ArcGIS.Core.Geometry.SpatialReference spatref, out string datasetNameOut)
{ {
@ -2123,6 +2209,7 @@ namespace OliviaAddInPro.Helper
bool crea = false; bool crea = false;
int idat = 1; int idat = 1;
int r = 2; int r = 2;
bool refspatdif = false;
while(r==2) while(r==2)
{ {
var task1 = CheckDataset(gdb, datasetName); var task1 = CheckDataset(gdb, datasetName);
@ -2140,7 +2227,8 @@ namespace OliviaAddInPro.Helper
{ {
//existe ese nombre, pero con otra ref espacial //existe ese nombre, pero con otra ref espacial
//crea un nuevo dataset y avisa //crea un nuevo dataset y avisa
datasetName = string.Format("{0}_{1}",datasetName,idat); datasetName = string.Format("{0}_{1}",datasetName,idat);
refspatdif = true;
idat++; idat++;
} }
else//r==1 else//r==1
@ -2186,10 +2274,11 @@ namespace OliviaAddInPro.Helper
task.Wait(); task.Wait();
if (task.Result.Value)//ha ido bien if (task.Result.Value)//ha ido bien
{ {
if (string.IsNullOrEmpty(datasetNameOut)) //avisa
res.Value = 0; if (refspatdif)
res.Value = 2;
else else
res.Value = 2;//avisa res.Value = 4;
//actualiza la gdb //actualiza la gdb
Refresh(gdbPath); Refresh(gdbPath);
} }
@ -2314,17 +2403,73 @@ namespace OliviaAddInPro.Helper
/** /**
* Borrar una feature class de un dataset * Borrar una feature class de un dataset
* Devuelve -1 si da error al abrir la gdb, -2 si da error al abrir el ftclass (igual porque no existe)
* y 0 si da error el proceso de borrar, y 1 si va todo bien
*/ */
public static Respuesta<bool> DeleteFeatureClass(string gdbPath, string featureClassPath) public static Respuesta<int> DeleteFeatureClassSync(string gdbPathDataset, string featureClassName)
{
var res = new Respuesta<int> { Value = 0 };
Geodatabase gdb = GetGdbSync(gdbPathDataset);
if (gdb == null)
{
res.Value = -1;
return res;
}
FeatureClass ftclss = GetFtClassSync(gdbPathDataset + " \\"+ featureClassName);
if (ftclss == null)
{
res.Value = -2;
return res;
}
Respuesta<bool> resp = new Respuesta<bool> { Value = false };
SchemaBuilder schemaBuilder = null;
try
{
// Create a FeatureClassDescription object
FeatureClassDescription featureClassDescription = new FeatureClassDescription(ftclss.GetDefinition());
// Create a SchemaBuilder object
schemaBuilder = new SchemaBuilder(gdb);
// Add the deletion fo the feature class to our list of DDL tasks
schemaBuilder.Delete(featureClassDescription);
// Execute the DDL
resp.Value = schemaBuilder.Build();
if (!resp.Value && schemaBuilder.ErrorMessages.Count > 0)
resp.Error.Add(schemaBuilder.ErrorMessages.FirstOrDefault());
}
catch
{
resp.Error.Add(schemaBuilder.ErrorMessages.FirstOrDefault());
}
if (resp.Value)
res.Value = 1;
else
{
res.Error.Add(resp.Error.FirstOrDefault());
}
Free(gdb);
Free(ftclss);
return res;
}
/**
* Borrar una feature class de un dataset
*/
public static Respuesta<bool> DeleteFeatureClass(string gdbPathDataset, string featureClassName)
{ {
var res = new Respuesta<bool> { Value = false }; var res = new Respuesta<bool> { Value = false };
FeatureClass ftclss = GetFtClass(featureClassPath);
if (ftclss == null) Geodatabase gdb = GetGdb(gdbPathDataset).Result;
return res;
Geodatabase gdb = GetGdb(gdbPath).Result;
if (gdb == null) if (gdb == null)
return res; return res;
FeatureClass ftclss = GetFtClass(gdbPathDataset + " \\" + featureClassName);
if (ftclss == null)
return res;
var task = ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run((Func<Respuesta<bool>>)(() => var task = ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run((Func<Respuesta<bool>>)(() =>
{ {
Respuesta<bool> resp = new Respuesta<bool> { Value = false }; Respuesta<bool> resp = new Respuesta<bool> { Value = false };

13
Model/ComunDef.cs
View File

@ -33,5 +33,18 @@ namespace OliviaAddInPro.Model
public static string atr_pedes; //<Atributo del campo FOW que indica peatonal public static string atr_pedes; //<Atributo del campo FOW que indica peatonal
}; };
/**
* Campos comunes a la capa de entidades
*/
public struct CamposCom
{
public static string camp_oid; //<Campo de la tabla de entidades que indica el objectid
public static string consulta_sector; //<Campo de la tabla donde se guarda info de sector
public static string consulta_secuen; //<Campo de la tabla donde se guarda info de secuencia
public static double giro_max;
public static double desv_max;
public static double desv_max_abs;
}
} }
} }

7
Model/LimpiezaDef.cs
View File

@ -37,8 +37,6 @@ namespace OliviaAddInPro.Model
public static string consulta_observ; //<Campo a consultar de la capa de limpieza, observaciones public static string consulta_observ; //<Campo a consultar de la capa de limpieza, observaciones
public static string consulta_anch_tip; //<Campo a consultar de la capa de limpieza, ancho tipo public static string consulta_anch_tip; //<Campo a consultar de la capa de limpieza, ancho tipo
public static string consulta_tipolo; //<Campo a consultar de la capa de limpieza, tipología public static string consulta_tipolo; //<Campo a consultar de la capa de limpieza, tipología
public static string consulta_sector; //<Campo a consultar de la capa planificada, sector
public static string consulta_secuen; //<Campo a consultar de la capa planificada, planificacion
}; };
/** /**
* Nombre de los atributos (de las capas) sobre los que se realizarán consultas para la limpieza * Nombre de los atributos (de las capas) sobre los que se realizarán consultas para la limpieza
@ -137,15 +135,12 @@ namespace OliviaAddInPro.Model
public static double umbral_reco; //<Umbral de llenado para la recogida de contenedores public static double umbral_reco; //<Umbral de llenado para la recogida de contenedores
}; };
public struct OtrosParam public struct OtrosParam
{ {
public static double giro_max;
public static double anch_peat; public static double anch_peat;
public static double anch_ace; public static double anch_ace;
public static double anch_aplin; public static double anch_aplin;
public static double anch_apbat; public static double anch_apbat;
public static double anch_bordlib; public static double anch_bordlib;
public static double desv_max;
public static double desv_max_abs;
}; };
//************************************************************************************* //*************************************************************************************
//Enums globales limpieza //Enums globales limpieza

25
Model/OliviaConf.cs
View File

@ -263,6 +263,12 @@ namespace OliviaAddInPro.Model
[DisplayName("Ignorar aislados")] [DisplayName("Ignorar aislados")]
[Description("Indica si por defecto se van a ignorar elementos aislados")] [Description("Indica si por defecto se van a ignorar elementos aislados")]
public bool Igno_ais { get; set; } public bool Igno_ais { get; set; }
[Category("General")]
[PropertyOrder(9)]
[DisplayName("Campo para exportar ID")]
[Description("Nombre del campo que indica el ID del ámbito")]
public string id { get; set; }
#endregion #endregion
#region 02CamposLimp #region 02CamposLimp
@ -378,11 +384,6 @@ namespace OliviaAddInPro.Model
#endregion #endregion
#region 04CamposRecogida #region 04CamposRecogida
[Category("Campos Recogida")]
[DisplayName("ID")]
[Description("Nombre del campo que indica el ID del contenedor")]
public string id { get; set; }
[Category("Campos Recogida")] [Category("Campos Recogida")]
[DisplayName("Tipo de carga")] [DisplayName("Tipo de carga")]
[Description("Nombre del campo que indica el tipo de carga")] [Description("Nombre del campo que indica el tipo de carga")]
@ -1069,37 +1070,37 @@ namespace OliviaAddInPro.Model
#endregion #endregion
#region 12TiemposRecoAvanz #region 12TiemposRecoAvanz
[Category("Tiempos de Tratamiento Recogida (min) - Avanzadas")]//OCULTAR [Category("Tiempos de Tratamiento Recogida (seg) - Avanzadas")]//OCULTAR
[DisplayName("Carga Trasera")] [DisplayName("Carga Trasera")]
[Description("")] [Description("")]
public int t_vaci_trasera { get; set; } public int t_vaci_trasera { get; set; }
[Category("Tiempos de Tratamiento Recogida (min) - Avanzadas")]//OCULTAR [Category("Tiempos de Tratamiento Recogida (seg) - Avanzadas")]//OCULTAR
[DisplayName("Carga Lateral")] [DisplayName("Carga Lateral")]
[Description("")] [Description("")]
public int t_vaci_lateral { get; set; } public int t_vaci_lateral { get; set; }
[Category("Tiempos de Tratamiento Recogida (min) - Avanzadas")]//OCULTAR [Category("Tiempos de Tratamiento Recogida (seg) - Avanzadas")]//OCULTAR
[DisplayName("Carga superior")] [DisplayName("Carga superior")]
[Description("")] [Description("")]
public int t_vaci_superior { get; set; } public int t_vaci_superior { get; set; }
[Category("Tiempos de Tratamiento Recogida (min) - Avanzadas")]//OCULTAR [Category("Tiempos de Tratamiento Recogida (seg) - Avanzadas")]//OCULTAR
[DisplayName("Carga Bilateral")] [DisplayName("Carga Bilateral")]
[Description("")] [Description("")]
public int t_vaci_bilateral { get; set; } public int t_vaci_bilateral { get; set; }
[Category("Tiempos de Tratamiento Recogida (min) - Avanzadas")]//OCULTAR [Category("Tiempos de Tratamiento Recogida (seg) - Avanzadas")]//OCULTAR
[DisplayName("Bolseo")] [DisplayName("Bolseo")]
[Description("")] [Description("")]
public int t_vaci_bolseo { get; set; } public int t_vaci_bolseo { get; set; }
[Category("Tiempos de Tratamiento Recogida (min) - Avanzadas")]//OCULTAR [Category("Tiempos de Tratamiento Recogida (seg) - Avanzadas")]//OCULTAR
[DisplayName("Lavado")] [DisplayName("Lavado")]
[Description("")] [Description("")]
public int t_vaci_lavado { get; set; } public int t_vaci_lavado { get; set; }
[Category("Tiempos de Tratamiento Recogida (min) - Avanzadas")]//OCULTAR [Category("Tiempos de Tratamiento Recogida (seg) - Avanzadas")]//OCULTAR
[DisplayName("Otro tipo de carga")] [DisplayName("Otro tipo de carga")]
[Description("")] [Description("")]
public int t_vaci_otra { get; set; } public int t_vaci_otra { get; set; }

9
Model/OliviaDef.cs
View File

@ -51,8 +51,8 @@ namespace OliviaAddInPro.Model
public const int ProgrMax = 100; public const int ProgrMax = 100;
public const int ProgrStep = 5; public const int ProgrStep = 5;
public const int ParamN = 5; public const int ParamN = 5;
public const int ParamLimpN = 45; public const int ParamLimpN = 48;
public const int ParamRecoN = 43; public const int ParamRecoN = 46;
/* /*
* Define el separador entre parámetros de la llamada al proceso oliviatasks * Define el separador entre parámetros de la llamada al proceso oliviatasks
*/ */
@ -60,7 +60,6 @@ namespace OliviaAddInPro.Model
public const string EjecGeoProgName = "olivia"; public const string EjecGeoProgName = "olivia";
public const string EjecGeoParamIgual = ":"; public const string EjecGeoParamIgual = ":";
public const string NombOlvTasks = "OliviaTasks"; public const string NombOlvTasks = "OliviaTasks";
public const string NombColSector = "SECTOR";
/** /**
* Define el nombre del grupo de propiedades generales * Define el nombre del grupo de propiedades generales
*/ */
@ -531,6 +530,10 @@ namespace OliviaAddInPro.Model
public const string GTO_girmax = "Giro_max_vehiculo"; public const string GTO_girmax = "Giro_max_vehiculo";
public const string GTO_desv_max = "Desv_max_rel"; public const string GTO_desv_max = "Desv_max_rel";
public const string GTO_desv_max_abs = "Desv_max_abs"; public const string GTO_desv_max_abs = "Desv_max_abs";
public const string GTO_camp_objectid = "Camp_objectid";
public const string GTO_camp_sector = "Camp_sector";
public const string GTO_camp_secuencia = "Camp_secuencia";
/** /**
* Define el nombre para mandar a oliviatasks la configuración * Define el nombre para mandar a oliviatasks la configuración
*/ */

13
Model/OliviaGlob.cs
View File

@ -446,8 +446,6 @@ namespace OliviaAddInPro.Model
LimpiezaDef.Campos.consulta_observ = c.cons_obser; LimpiezaDef.Campos.consulta_observ = c.cons_obser;
LimpiezaDef.Campos.consulta_anch_tip = c.cons_anch_tip; LimpiezaDef.Campos.consulta_anch_tip = c.cons_anch_tip;
LimpiezaDef.Campos.consulta_tipolo = c.cons_tipolo; LimpiezaDef.Campos.consulta_tipolo = c.cons_tipolo;
LimpiezaDef.Campos.consulta_sector = c.consulta_sector;
LimpiezaDef.Campos.consulta_secuen = c.consulta_secuen;
LimpiezaDef.Atributos.atr_esca = c.atr_esca; LimpiezaDef.Atributos.atr_esca = c.atr_esca;
LimpiezaDef.Atributos.atr_fuent = c.atr_fuent; LimpiezaDef.Atributos.atr_fuent = c.atr_fuent;
@ -540,10 +538,6 @@ namespace OliviaAddInPro.Model
LimpiezaDef.OtrosParam.anch_aplin = c.Ancho_ap_lin_def; LimpiezaDef.OtrosParam.anch_aplin = c.Ancho_ap_lin_def;
LimpiezaDef.OtrosParam.anch_apbat = c.Ancho_ap_bat_def; LimpiezaDef.OtrosParam.anch_apbat = c.Ancho_ap_bat_def;
LimpiezaDef.OtrosParam.anch_bordlib = c.Ancho_bord_lib_def; LimpiezaDef.OtrosParam.anch_bordlib = c.Ancho_bord_lib_def;
LimpiezaDef.OtrosParam.giro_max = c.Giro_max_vehiculo;
LimpiezaDef.OtrosParam.desv_max = c.Desv_max;
LimpiezaDef.OtrosParam.desv_max_abs = c.Desv_max_abs;
//Capas, consultas, atributos y filtros de RECOGIDA //Capas, consultas, atributos y filtros de RECOGIDA
@ -635,6 +629,13 @@ namespace OliviaAddInPro.Model
ComunDef.AtributosNW.atr_N = c.atr_N; ComunDef.AtributosNW.atr_N = c.atr_N;
ComunDef.AtributosNW.atr_pedes = c.atr_pedes; ComunDef.AtributosNW.atr_pedes = c.atr_pedes;
ComunDef.CamposCom.camp_oid = c.id;
ComunDef.CamposCom.consulta_sector = c.consulta_sector;
ComunDef.CamposCom.consulta_secuen = c.consulta_secuen;
ComunDef.CamposCom.giro_max = c.Giro_max_vehiculo;
ComunDef.CamposCom.desv_max = c.Desv_max;
ComunDef.CamposCom.desv_max_abs = c.Desv_max_abs;
} }
} }
} }

2
Model/Recogida.cs
View File

@ -164,7 +164,7 @@ namespace OliviaAddInPro.Model
public override string[] GetCampos(string capa=null) public override string[] GetCampos(string capa=null)
{ {
string[] camps = { string[] camps = {
RecogidaDef.campos_def.cons_id, //RecogidaDef.campos_def.cons_id,
RecogidaDef.campos_def.cons_nomrec, RecogidaDef.campos_def.cons_nomrec,
RecogidaDef.campos_def.cons_lateral , RecogidaDef.campos_def.cons_lateral ,
RecogidaDef.campos_def.cons_fracc, RecogidaDef.campos_def.cons_fracc,

57
Model/TratamientoComun.cs
View File

@ -137,6 +137,8 @@ namespace OliviaAddInPro.Model
set { err_str = value; } set { err_str = value; }
} }
private ObservableCollection<string> nombCamposOrig = new ObservableCollection<string>();
/** /**
* Para la ventana de progreso * Para la ventana de progreso
*/ */
@ -202,10 +204,30 @@ namespace OliviaAddInPro.Model
return null; return null;
} }
/** /**
* Restaura el nombre original del campo si se ha truncado a 10 car al exportar a shp * Restaura el nombre original del campo si se ha truncado a 10 car al exportar a shp
*/ */
public Respuesta<bool> RestauraNomCampos(string nombFtClass) public virtual string[] GetCamposOrig()
{
string[] camps = null;
if (nombCamposOrig.Count > 0)
{
camps = new string[nombCamposOrig.Count];
for (int i=0;i<nombCamposOrig.Count;i++)
{
camps[i] = nombCamposOrig[i];
}
}
return camps;
}
/**
* Restaura el nombre original del campo si se ha truncado a 10 car al exportar a shp
*/
public Respuesta<bool> RestauraNomCampos(string nombFtClass)
{ {
int LENGTHCAMPSHP = 10; int LENGTHCAMPSHP = 10;
Respuesta<bool> resp = new Respuesta<bool> { Value = false }; Respuesta<bool> resp = new Respuesta<bool> { Value = false };
@ -213,7 +235,9 @@ namespace OliviaAddInPro.Model
if (fc == null) if (fc == null)
return resp; return resp;
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
string[] camps = GetCampos(); string[] camps = GetCamposOrig();
if (camps == null)
return resp;
ObservableCollection<string> fields = HelperGdb.GetFieldsSync(fc); ObservableCollection<string> fields = HelperGdb.GetFieldsSync(fc);
HelperGdb.Free(fc); HelperGdb.Free(fc);
@ -228,7 +252,9 @@ namespace OliviaAddInPro.Model
{ {
if (camps[i].Length <= LENGTHCAMPSHP) if (camps[i].Length <= LENGTHCAMPSHP)
continue; continue;
campTrunc = camps[i].Substring(0, LENGTHCAMPSHP); if (EstaRepeNomb(fields, camps[i]))
continue;
campTrunc = camps[i].Substring(0, LENGTHCAMPSHP);
//si tiene más de 10 caracteres, lo ha truncado al exportar //si tiene más de 10 caracteres, lo ha truncado al exportar
//busca el nombre actual del campo en la fc //busca el nombre actual del campo en la fc
indx = fields.IndexOf(campTrunc); indx = fields.IndexOf(campTrunc);
@ -251,5 +277,30 @@ namespace OliviaAddInPro.Model
return resp; return resp;
} }
private bool EstaRepeNomb(ObservableCollection<string> fields, string nomb)
{
foreach( string fnomb in fields)
{
if (string.Compare(fnomb, nomb, true)==0)
return true;
}
return false;
}
/**
* Guarda el nombre de los campos originales para luego restaurarlos
*/
public void GuardaNombCamposOrig(string pathFtClass)
{
FeatureClass fc = HelperGdb.GetFtClassSync(pathFtClass);
if (fc != null)
{
nombCamposOrig = HelperGdb.GetFieldsSync(fc);
}
else
nombCamposOrig = new ObservableCollection<string>();
HelperGdb.Free(fc);
}
} }
} }

2
Services/ConfigServ.cs
View File

@ -356,7 +356,7 @@ namespace OliviaAddInPro.Services
c.t_vaci_lateral=90; c.t_vaci_lateral=90;
c.t_vaci_superior=180; c.t_vaci_superior=180;
c.t_vaci_bilateral=100; c.t_vaci_bilateral=100;
c.t_vaci_bolseo=5; c.t_vaci_bolseo=5*60;
c.t_vaci_lavado=60; c.t_vaci_lavado=60;
c.t_vaci_otra=60; c.t_vaci_otra=60;
c.kgmax_max=20000; c.kgmax_max=20000;

249
Services/EjecServ.cs
View File

@ -10,6 +10,7 @@ using OliviaAddInPro.Helper;
using ArcGIS.Core.Internal.Data; using ArcGIS.Core.Internal.Data;
using ArcGIS.Desktop.Framework.Threading.Tasks; using ArcGIS.Desktop.Framework.Threading.Tasks;
using System.Windows; using System.Windows;
using System.IO;
namespace OliviaAddInPro.Services namespace OliviaAddInPro.Services
{ {
@ -77,6 +78,12 @@ namespace OliviaAddInPro.Services
ErrStr = Resource1.String_cancel_progreso; ErrStr = Resource1.String_cancel_progreso;
return false; return false;
} }
//////////////////////////////////////////////
///Se guarda el nombre de los campos originales
///
com.GuardaNombCamposOrig(com.CapaElems);
//Cuenta las filas que cumplen la consulta //Cuenta las filas que cumplen la consulta
var nelems = HelperGdb.GetNumElemsSync(com.CapaElems, com.ConsultaAmbs); var nelems = HelperGdb.GetNumElemsSync(com.CapaElems, com.ConsultaAmbs);
if (nelems <= 0) if (nelems <= 0)
@ -174,9 +181,17 @@ namespace OliviaAddInPro.Services
return false; return false;
} }
/////////////////////////////////////////////////////////////////////
///Comprueba si está la columna de ObjectId y si no, la crea
if(!ComprCreaColOid(OliviaGlob.Paths.PathData, com.CapaElems, filtroEspacial))
{
ErrStr = "Error al exportar columna " + ComunDef.CamposCom.camp_oid;
return false;
}
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
//ahora si está en modo planificación y la capa no tiene esa columna, exporta la sectorización //ahora si está en modo planificación, ya ha hecho una ejec antes y la capa no tiene esa columna pero la tiene guardada de la ejec anterior, exporta la sectorización
if (modo==ModosEjec.Planifica && !string.IsNullOrEmpty(com.CapaPlanif)) if (modo==ModosEjec.Planifica && !string.IsNullOrEmpty(com.CapaPlanif) && OliviaGlob.IsConfig2())
{ {
string capa_principal = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathData); string capa_principal = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathData);
HelperGdb.CloseLayer(capa_principal); HelperGdb.CloseLayer(capa_principal);
@ -239,22 +254,7 @@ namespace OliviaAddInPro.Services
{ {
ErrStr = "Error al añadir buffer a la geometría"; ErrStr = "Error al añadir buffer a la geometría";
return false; return false;
} }
//quita las restricciones
if (com.GeomRestr != null)
{
geom_export = HelperGdb.QuitaGeom(geom_export, com.GeomRestr);
if (geom_export == null)
{
ErrStr = "Error al intersecar con las restricciones.";
return false;
}
}
if (com.ProgrSrc._ProgrSrc.Getcancelled())
{
ErrStr = Resource1.String_cancel_progreso;
return false;
}
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////
//comprueba si la geometría de exportación contiene a la instalación y a la planta de descarga //comprueba si la geometría de exportación contiene a la instalación y a la planta de descarga
for (int i = 0; i < coords.Length; i++) for (int i = 0; i < coords.Length; i++)
@ -287,13 +287,28 @@ namespace OliviaAddInPro.Services
else else
ErrStr = "Error al incluir punto de instalación en polígono de exportación."; ErrStr = "Error al incluir punto de instalación en polígono de exportación.";
return false; return false;
} }
//actualiza la geometría //actualiza la geometría
geom_export = respGeom.Value; geom_export = respGeom.Value;
} }
} }
} }
} }
//quita las restricciones de circ
if (com.GeomRestr != null)
{
geom_export = HelperGdb.QuitaGeom(geom_export, com.GeomRestr);
if (geom_export == null)
{
ErrStr = "Error al intersecar con las restricciones.";
return false;
}
}
if (com.ProgrSrc._ProgrSrc.Getcancelled())
{
ErrStr = Resource1.String_cancel_progreso;
return false;
}
//mira spatialreference del nw //mira spatialreference del nw
/*FeatureClass fc = HelperGdb.GetFtClass(OliviaGlob.Paths.PathGdbNw); /*FeatureClass fc = HelperGdb.GetFtClass(OliviaGlob.Paths.PathGdbNw);
@ -365,13 +380,13 @@ namespace OliviaAddInPro.Services
//Añade al shp exportado la columna de sector y secuencia //Añade al shp exportado la columna de sector y secuencia
HelperGdb.FieldToAdd[] fields = new HelperGdb.FieldToAdd[2]; HelperGdb.FieldToAdd[] fields = new HelperGdb.FieldToAdd[2];
//campo SECTOR //campo SECTOR
fields[0].Name = LimpiezaDef.Campos.consulta_sector; fields[0].Name = ComunDef.CamposCom.consulta_sector;
fields[0].Alias = LimpiezaDef.Campos.consulta_sector; fields[0].Alias = ComunDef.CamposCom.consulta_sector;
fields[0].Tipo = "LONG"; fields[0].Tipo = "LONG";
fields[0].Length = 0; fields[0].Length = 0;
//campo SECUENCIA //campo SECUENCIA
fields[1].Name = LimpiezaDef.Campos.consulta_secuen; fields[1].Name = ComunDef.CamposCom.consulta_secuen;
fields[1].Alias = LimpiezaDef.Campos.consulta_secuen; fields[1].Alias = ComunDef.CamposCom.consulta_secuen;
fields[1].Tipo = "LONG"; fields[1].Tipo = "LONG";
fields[1].Length = 0; fields[1].Length = 0;
@ -412,8 +427,8 @@ namespace OliviaAddInPro.Services
{ {
//context.Invalidate(rowshp); //context.Invalidate(rowshp);
// modify and execute // modify and execute
modifyOp.Modify(rowshp, LimpiezaDef.Campos.consulta_sector, rowsecto[LimpiezaDef.Campos.consulta_sector]); modifyOp.Modify(rowshp, ComunDef.CamposCom.consulta_sector, rowsecto[ComunDef.CamposCom.consulta_sector]);
modifyOp.Modify(rowshp, LimpiezaDef.Campos.consulta_secuen, rowsecto[LimpiezaDef.Campos.consulta_secuen]); modifyOp.Modify(rowshp, ComunDef.CamposCom.consulta_secuen, rowsecto[ComunDef.CamposCom.consulta_secuen]);
rowshp.Store(); rowshp.Store();
//context.Invalidate(rowshp); //context.Invalidate(rowshp);
} }
@ -495,8 +510,107 @@ namespace OliviaAddInPro.Services
} }
/** /**
* Prepara la geometría para exportar los ámbitos * Comrpueba si existe la columna de oid y si no, la crea y la rellena
*/ */
public bool ComprCreaColOid(string pathCapa, string pathCapaOrig, SpatialQueryFilter filter)
{
//comprueba si está el campo
int NCAMPS = 1;
string[] camps;
camps = new string[NCAMPS];
camps[0] = ComunDef.CamposCom.camp_oid;
int compCamp = HelperGdb.CheckFileds(pathCapa, camps);
ErrStr = HelperGdb.OutStr;
if (compCamp == 0)
return true; //tiene el campo
//no lo tiene, lo crea
//Añade al shp exportado la columna de sector y secuencia
HelperGdb.FieldToAdd[] fields = new HelperGdb.FieldToAdd[1];
//campo
fields[0].Name = ComunDef.CamposCom.camp_oid;
fields[0].Alias = ComunDef.CamposCom.camp_oid;
fields[0].Tipo = "LONG";
fields[0].Length = 0;
if (!HelperGdb.AddFieldsSync(pathCapa, fields))
return false;
//vuelve a cerrar la capa
string capa_principal = System.IO.Path.GetFileNameWithoutExtension(pathCapa);
HelperGdb.CloseLayer(capa_principal);
/////////////////////////////////////////////////////
//Coge los ids de la capa de la que ha exportado
using (FeatureClass fc_orig = HelperGdb.GetFtClassSync(pathCapaOrig))
{
if (fc_orig == null)
return false;
List<long> ids = new List<long>();
//Añade a la lista los ids que cumplen el filtro espacial
try
{
ids = fc_orig.Select(filter, SelectionType.ObjectID, SelectionOption.Normal).GetObjectIDs().ToList();
}
catch
{
ids = new List<long>();
}
//Comprueba que hay tantos ids como elementos en el shp
using (FeatureClass fc_shp = HelperGdb.GetFtClassSync(pathCapa))
{
if (fc_shp == null)
return false;
int nelem_shp = HelperGdb.GetNumElemsSync(fc_shp);
if (nelem_shp != ids.Count)
return false;
/////////////////////////////////////////////////////
//ahora rellena las columnas
try
{
using (RowCursor rc_shp = fc_shp.Search())
{
if (rc_shp == null)
return false;
var modifyOp = new ArcGIS.Desktop.Editing.EditOperation();
modifyOp.Name = "Actualiza OID";
bool ex = false;
//modifyOp.Callback((context) =>
//{
int i = 0;
while (rc_shp.MoveNext() && i < ids.Count)
{
using (Row rowshp = rc_shp.Current)
{
//context.Invalidate(rowshp);
// modify and execute
modifyOp.Modify(rowshp, ComunDef.CamposCom.camp_oid, ids[i++]);
rowshp.Store();
//context.Invalidate(rowshp);
}
}
//}, fc_shp);
ex = modifyOp.Execute();
ArcGIS.Desktop.Core.Project.Current.SaveEditsAsync();
if (ex && modifyOp.IsDone)
return true;
else
return false;
}
}
catch
{
return false;
}
return true;
}
}
}
/**
* Prepara la geometría para exportar los ámbitos
*/
public Geometry GetGeomAmbitsExport() public Geometry GetGeomAmbitsExport()
{ {
Geometry geomAux = null; Geometry geomAux = null;
@ -538,7 +652,7 @@ namespace OliviaAddInPro.Services
//if (geomAux == null) //if (geomAux == null)
{ {
//Ahora hace la geometría de los ámbitos que cumplen la consulta //Ahora hace la geometría de los ámbitos que cumplen la consulta
geomAmbits = HelperGdb.GetGeomConvexHullSync(fc, filtro); geomAmbits = HelperGdb.GetGeomUnique(fc, filtro);
if (geomAmbits == null || geomAmbits.IsEmpty) if (geomAmbits == null || geomAmbits.IsEmpty)
{ {
ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + HelperGdb.OutStr; ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + HelperGdb.OutStr;
@ -549,7 +663,7 @@ namespace OliviaAddInPro.Services
else else
{ {
geomAux = HelperGdb.IntersectGeom(geomAux, geomAmbits); geomAux = HelperGdb.IntersectGeom(geomAux, geomAmbits);
geomAux = GeometryEngine.Instance.ConvexHull(geomAux); //geomAux = GeometryEngine.Instance.ConvexHull(geomAux);
} }
} }
//le quita las restricciones //le quita las restricciones
@ -588,8 +702,8 @@ namespace OliviaAddInPro.Services
int NCAMPS = 2; int NCAMPS = 2;
string[] camps; string[] camps;
camps = new string[NCAMPS]; camps = new string[NCAMPS];
camps[0] = LimpiezaDef.Campos.consulta_sector; camps[0] = ComunDef.CamposCom.consulta_sector;
camps[1] = LimpiezaDef.Campos.consulta_secuen; camps[1] = ComunDef.CamposCom.consulta_secuen;
return HelperGdb.CheckFiledsSync(pathCapa, camps) == 0; return HelperGdb.CheckFiledsSync(pathCapa, camps) == 0;
} }
@ -615,10 +729,10 @@ namespace OliviaAddInPro.Services
/** /**
* Realiza las funciones de importación de la sectorización * Realiza las funciones de importación de la sectorización
*/ */
public Respuesta<string> ImportSecto(string GdbFileName) public Respuesta<string> ImportSecto(string GdbFileName, string FtClssName)
{ {
com.ProgrSrc.IncMessage(10,"Importando capas"); com.ProgrSrc.IncMessage(10,"Importando capas");
var res = Import(GdbFileName, 0); var res = Import(GdbFileName, 0, FtClssName);
if (res.HasError || string.IsNullOrEmpty(res.Value)) if (res.HasError || string.IsNullOrEmpty(res.Value))
{ {
return res; return res;
@ -630,7 +744,7 @@ namespace OliviaAddInPro.Services
string path_import = res.Value; string path_import = res.Value;
//abre con valor único //abre con valor único
string path_lyr = path_import; string path_lyr = path_import;
var resb = HelperGdb.OpenLayerUniqueValue(path_lyr, LimpiezaDef.Campos.consulta_sector); var resb = HelperGdb.OpenLayerUniqueValue(path_lyr, ComunDef.CamposCom.consulta_sector);
if (!resb.Value) if (!resb.Value)
{ {
res.Error.Add("Error al abrir capa "+ path_lyr + " con Valor único. " + resb.Error.FirstOrDefault()); res.Error.Add("Error al abrir capa "+ path_lyr + " con Valor único. " + resb.Error.FirstOrDefault());
@ -644,10 +758,10 @@ namespace OliviaAddInPro.Services
/** /**
* Realiza las funciones de importación de la planificación * Realiza las funciones de importación de la planificación
*/ */
public Respuesta<string> ImportPlanif(string GdbFileName) public Respuesta<string> ImportPlanif(string GdbFileName, string FtClssName)
{ {
com.ProgrSrc.IncMessage(10, "Importando capas"); com.ProgrSrc.IncMessage(10, "Importando capas");
var res = Import(GdbFileName, 1); var res = Import(GdbFileName, 1, FtClssName);
if (res.HasError || string.IsNullOrEmpty(res.Value)) if (res.HasError || string.IsNullOrEmpty(res.Value))
{ {
res.Value = string.Empty; res.Value = string.Empty;
@ -685,7 +799,7 @@ namespace OliviaAddInPro.Services
for(i =0;i<NOPEN;i++) for(i =0;i<NOPEN;i++)
{ {
com.ProgrSrc.IncMessage((uint)(60 / NOPEN)); com.ProgrSrc.IncMessage((uint)(60 / NOPEN));
resb = HelperGdb.OpenLayerUniqueValue(path_lyr_arr[i], LimpiezaDef.Campos.consulta_sector, visible_arr[i]); resb = HelperGdb.OpenLayerUniqueValue(path_lyr_arr[i], ComunDef.CamposCom.consulta_sector, visible_arr[i]);
if (!resb.Value) if (!resb.Value)
break; break;
} }
@ -703,7 +817,7 @@ namespace OliviaAddInPro.Services
/** /**
* Realiza las funciones de importación, modo 0 secto, modo 1 planif * Realiza las funciones de importación, modo 0 secto, modo 1 planif
*/ */
public Respuesta<string> Import(string GdbFileName, int modo) public Respuesta<string> Import(string GdbFileName, int modo, string FtClssName="")
{ {
var res = new Respuesta<string> { Value = string.Empty }; var res = new Respuesta<string> { Value = string.Empty };
@ -734,6 +848,8 @@ namespace OliviaAddInPro.Services
///////////////////////////////////////// /////////////////////////////////////////
/////mira a ver si tiene configurado Dataset /////mira a ver si tiene configurado Dataset
string msg_avisa = string.Empty; string msg_avisa = string.Empty;
string amb_aux = string.Empty;
bool sobreescribe = false;
if (!string.IsNullOrEmpty(OliviaGlob.Paths.PathDatasetImport)) if (!string.IsNullOrEmpty(OliviaGlob.Paths.PathDatasetImport))
{ {
var datname = new System.IO.DirectoryInfo(OliviaGlob.Paths.PathDatasetImport).Name; var datname = new System.IO.DirectoryInfo(OliviaGlob.Paths.PathDatasetImport).Name;
@ -748,10 +864,29 @@ namespace OliviaAddInPro.Services
msg_avisa = "No se encuentra el Dataset " + datname + ". "; msg_avisa = "No se encuentra el Dataset " + datname + ". ";
} }
} }
else
{
/////////////////////////////////////////
//no tiene un dataset configurado, saca ventana para elegir uno
//saca ventana para elegir Dataset, si se cancela, se guarda en el nombre por defecto en función del tratamiento y los ámbitos
//HelperGlobal.ponMsg("A continuación, introduzca nombre de Feature Class y ubicación (Dataset) para importación. Si cancela el proceso, se establecerán el nombre y Dataset por defecto en función de los ámbitos y el tratamiento");
string path_aux = FtClssName;
//HelperGdb.SaveFileDlg("Introduzca nombre de Feature Class a importar", GdbFileName, null, ArcGIS.Desktop.Catalog.ItemFilters.featureClasses_all);
if (!string.IsNullOrEmpty(path_aux))
{
tratamiento = new DirectoryInfo(System.IO.Path.GetDirectoryName(path_aux)).Name;
//tratamiento = System.IO.Path.GetFileName(System.IO.Path.GetDirectoryName(path_aux));
amb_aux = System.IO.Path.GetFileNameWithoutExtension(path_aux);
//comprueba si ya existe ese ft class
FeatureClass ft = HelperGdb.GetFtClass(path_aux);
if (ft != null)
sobreescribe = true;
}
}
//crea el dataset o comprueba si existe //crea el dataset o comprueba si existe
string datasetNameOut = string.Empty; string datasetNameOut = string.Empty;
var resp = HelperGdb.CreateDataset(GdbFileName, tratamiento, spatRefData, out datasetNameOut); var resp = HelperGdb.CreateDataset(GdbFileName, tratamiento, spatRefData, out datasetNameOut);
string err_spatref = "Atención, no coincide la proyección de las FeatureClass del Dataset ya creado con la del FeatureClass a importar";
if(resp.Value==0) if(resp.Value==0)
{ {
//avisa //avisa
@ -764,19 +899,33 @@ namespace OliviaAddInPro.Services
res.Error.Add("Error al crear el Dataset para importar " + tratamiento); res.Error.Add("Error al crear el Dataset para importar " + tratamiento);
return res; return res;
} }
else if (resp.Value == 2) else //2 o 4 if (resp.Value == 2)
{ {
//avisa //avisa
msg_avisa = err_spatref + ", se ha creado un nuevo dataset " + datasetNameOut; string err_spatref = string.Empty;
if (resp.Value==2)
err_spatref = "Atención, no coincide la proyección de las FeatureClass del Dataset ya creado con la del FeatureClass a importar. ";
msg_avisa = err_spatref + "Se ha creado un nuevo dataset " + datasetNameOut;
//HelperGlobal.ponMsg(err_spatref +", se ha creado un nuevo dataset "+ datasetNameOut ); //HelperGlobal.ponMsg(err_spatref +", se ha creado un nuevo dataset "+ datasetNameOut );
tratamiento = datasetNameOut; tratamiento = datasetNameOut;
} }
string dataset = tratamiento; //avisa ahora para dar tiempo?
if (!string.IsNullOrEmpty(msg_avisa))
{
if(!HelperGlobal.ponMsg(msg_avisa, MessageBoxImage.Question, "OLIVIA", MessageBoxButton.OKCancel))
{
res.Error.Add("Proceso de importación Cancelado por el usuario");
return res;
}
}
string dataset = tratamiento;
/////////////////////////////////////////
if (!string.IsNullOrEmpty(amb_aux))
ambitos = amb_aux;
///////////////////////////////////////// /////////////////////////////////////////
//todo ok, se pone a importar //todo ok, se pone a importar
string err_st =string.Empty; string err_st =string.Empty;
string name = ambitos;
string path_import = GdbFileName + "\\" + dataset + "\\" + ambitos; string path_import = GdbFileName + "\\" + dataset + "\\" + ambitos;
int NIMPORT; int NIMPORT;
string[] noms_shp = null; string[] noms_shp = null;
@ -838,7 +987,18 @@ namespace OliviaAddInPro.Services
///////////////////////////////////////// /////////////////////////////////////////
//se embucla para hacer todas las importaciones necesarias //se embucla para hacer todas las importaciones necesarias
for (i = 0; i < NIMPORT; i++) for (i = 0; i < NIMPORT; i++)
{ {
//mira a ver si hay que borrar para reemplazar
if (sobreescribe)
{
resp = HelperGdb.DeleteFeatureClassSync(GdbFileName + "\\" + dataset, noms_gdb[i]);
if (resp.Value!=-2 && resp.Value!=1) //-2 porque puede ser que no pueda abrir la capa porque no existe
{
err_st = "Error al sobreescribir la capa " + noms_gdb[i];
break;
}
}
resp2 = HelperGdb.ImportShp(dir_shp + "\\" + noms_shp[i] + HelperGdb.SHP_EXT, GdbFileName + "\\" + dataset, noms_gdb[i]); resp2 = HelperGdb.ImportShp(dir_shp + "\\" + noms_shp[i] + HelperGdb.SHP_EXT, GdbFileName + "\\" + dataset, noms_gdb[i]);
if (!resp2.Value) if (!resp2.Value)
{ {
@ -853,9 +1013,6 @@ namespace OliviaAddInPro.Services
res.Error.Add("Errores en la importación: "+err_st); res.Error.Add("Errores en la importación: "+err_st);
return res; return res;
} }
//avisa ahora para dar tiempo?
if(!string.IsNullOrEmpty(msg_avisa))
HelperGlobal.ponMsg(msg_avisa);
//cambia el nombre de los campos que había truncado a 10 caracteres al exportar a shp //cambia el nombre de los campos que había truncado a 10 caracteres al exportar a shp
//solo para la capa original //solo para la capa original

18
Services/FinProcServ.cs
View File

@ -42,7 +42,8 @@ namespace OliviaAddInPro.Services
//actualiza los flags //actualiza los flags
OliviaGlob.RemoveFlagTipEjec(TiposEjecucion.FinEjecOk); OliviaGlob.RemoveFlagTipEjec(TiposEjecucion.FinEjecOk);
//importa resultados //importa resultados
resp = IniImport(); string FtClssName = "";
resp = IniImport(out FtClssName);
if (resp.HasError) if (resp.HasError)
{ {
msg = resp.Error.First(); msg = resp.Error.First();
@ -59,7 +60,7 @@ namespace OliviaAddInPro.Services
//actualiza los flags //actualiza los flags
//OliviaGlob.RemoveFlagTipEjec(TiposEjecucion.EjecSecto); //OliviaGlob.RemoveFlagTipEjec(TiposEjecucion.EjecSecto);
//acciones de importación //acciones de importación
resp2 = inst.ServCom.ImportSecto(GdbFileName); resp2 = inst.ServCom.ImportSecto(GdbFileName, FtClssName);
} }
else if (OliviaGlob.HasFlagTipEjec(TiposEjecucion.EjecPlanif)) //Ha terminado bien la planificación else if (OliviaGlob.HasFlagTipEjec(TiposEjecucion.EjecPlanif)) //Ha terminado bien la planificación
{ {
@ -68,7 +69,7 @@ namespace OliviaAddInPro.Services
//guarda csv //guarda csv
//GuardaCsv(inst); en finEjecuta3 //GuardaCsv(inst); en finEjecuta3
//acciones de importación //acciones de importación
resp2 = inst.ServCom.ImportPlanif(GdbFileName); resp2 = inst.ServCom.ImportPlanif(GdbFileName, FtClssName);
} }
Application.Current.Dispatcher.BeginInvoke(new Action<Respuesta<string>, Respuesta<string>, bool, string, TratamientoComun>((p, v, x, u, w) => finEjecuta3(p, v, x, u, w)), resp, resp2, mal, msg, inst); Application.Current.Dispatcher.BeginInvoke(new Action<Respuesta<string>, Respuesta<string>, bool, string, TratamientoComun>((p, v, x, u, w) => finEjecuta3(p, v, x, u, w)), resp, resp2, mal, msg, inst);
@ -110,6 +111,8 @@ namespace OliviaAddInPro.Services
{ {
if (string.IsNullOrEmpty(resp2.Value)) if (string.IsNullOrEmpty(resp2.Value))
{ {
//quita modo config2
OliviaGlob.RemoveFlagTipEjec(TiposEjecucion.Config2);
if (resp2.HasError) if (resp2.HasError)
{ {
msg = resp2.Error.First(); msg = resp2.Error.First();
@ -246,9 +249,10 @@ namespace OliviaAddInPro.Services
/* /*
* Inicializa la importación * Inicializa la importación
*/ */
public Respuesta<string> IniImport() public Respuesta<string> IniImport(out string FtClssName)
{ {
var res = new Respuesta<string>() { Value = string.Empty }; var res = new Respuesta<string>() { Value = string.Empty };
FtClssName = string.Empty;
//Lanza ventana para elegir gdb a la que importar resultados //Lanza ventana para elegir gdb a la que importar resultados
string GdbFileName=""; string GdbFileName="";
if (OliviaGlob.CompruebaExistePath(OliviaGlob.Paths.PathGdbImport)) if (OliviaGlob.CompruebaExistePath(OliviaGlob.Paths.PathGdbImport))
@ -273,6 +277,12 @@ namespace OliviaAddInPro.Services
return res; return res;
} }
res.Value = GdbFileName; res.Value = GdbFileName;
if (string.IsNullOrEmpty(OliviaGlob.Paths.PathDatasetImport))
{ //ahora pide elegir nombre de ftclass
FtClssName = HelperGdb.SaveFileDlg("Seleccione ubicación e introduzca nombre de Feature Class a importar", GdbFileName, null, ArcGIS.Desktop.Catalog.ItemFilters.featureClasses_all);
}
return res; return res;
} }
} }

11
Services/LanzaSrv/LanzaOlvServ.cs
View File

@ -74,10 +74,15 @@ namespace OliviaAddInPro.Services.LanzaSrv
//paths de archivos //paths de archivos
GeneralDef.EjecGeoParamSep + GeneralDef.GG_pd + GeneralDef.EjecGeoParamIgual + OliviaGlob.Paths.PathData + " " + GeneralDef.EjecGeoParamSep + GeneralDef.GG_pd + GeneralDef.EjecGeoParamIgual + OliviaGlob.Paths.PathData + " " +
GeneralDef.EjecGeoParamSep + GeneralDef.GG_pn + GeneralDef.EjecGeoParamIgual + OliviaGlob.Paths.PathNW + " " + GeneralDef.EjecGeoParamSep + GeneralDef.GG_pn + GeneralDef.EjecGeoParamIgual + OliviaGlob.Paths.PathNW + " " +
//nombres de cols de sector y secuencia
GeneralDef.EjecGeoParamSep + GeneralDef.GTO_camp_sector + GeneralDef.EjecGeoParamIgual + ComunDef.CamposCom.consulta_sector + " " +
GeneralDef.EjecGeoParamSep + GeneralDef.GTO_camp_secuencia + GeneralDef.EjecGeoParamIgual + ComunDef.CamposCom.consulta_secuen + " " +
GeneralDef.EjecGeoParamSep + GeneralDef.GTO_camp_objectid + GeneralDef.EjecGeoParamIgual + ComunDef.CamposCom.camp_oid + " " +
//giro max y desv //giro max y desv
GeneralDef.EjecGeoParamSep + GeneralDef.GTO_girmax + GeneralDef.EjecGeoParamIgual + LimpiezaDef.OtrosParam.giro_max + " " + GeneralDef.EjecGeoParamSep + GeneralDef.GTO_girmax + GeneralDef.EjecGeoParamIgual + ComunDef.CamposCom.giro_max + " " +
GeneralDef.EjecGeoParamSep + GeneralDef.GTO_desv_max + GeneralDef.EjecGeoParamIgual + LimpiezaDef.OtrosParam.desv_max + " " + GeneralDef.EjecGeoParamSep + GeneralDef.GTO_desv_max + GeneralDef.EjecGeoParamIgual + ComunDef.CamposCom.desv_max + " " +
GeneralDef.EjecGeoParamSep + GeneralDef.GTO_desv_max_abs + GeneralDef.EjecGeoParamIgual + LimpiezaDef.OtrosParam.desv_max_abs + " "; GeneralDef.EjecGeoParamSep + GeneralDef.GTO_desv_max_abs + GeneralDef.EjecGeoParamIgual + ComunDef.CamposCom.desv_max_abs + " ";
//LimpiezaDef.Campos.consulta_sector;
} }
/** /**

2
Services/LanzaSrv/LanzaRecoSrv.cs
View File

@ -61,7 +61,7 @@ namespace OliviaAddInPro.Services.LanzaSrv
else if (modo == ModosEjec.SoloPlanifica) else if (modo == ModosEjec.SoloPlanifica)
modo_str = GeneralDef.SockConfTodo; modo_str = GeneralDef.SockConfTodo;
var conf = ConfigServ.Serv.Leer(); var conf = ConfigServ.Serv.Leer();
//van ParamLimpN parámetros, sin incluir "CONFIGURACION", si se añaden, incrementar ParamLimpN //van ParamLimpN parámetros, sin incluir "CONFIGURACION", si se añaden, incrementar ParamRecoN
str = GeneralDef.EjecGeoParamSep + modo_str + " " + str = GeneralDef.EjecGeoParamSep + modo_str + " " +
GeneralDef.EjecGeoParamSep + GeneralDef.GR_camp_cap + GeneralDef.EjecGeoParamIgual + conf.capac + " " + GeneralDef.EjecGeoParamSep + GeneralDef.GR_camp_cap + GeneralDef.EjecGeoParamIgual + conf.capac + " " +
GeneralDef.EjecGeoParamSep + GeneralDef.GR_kgM + GeneralDef.EjecGeoParamIgual + reco.KgMaxVehic + " " + GeneralDef.EjecGeoParamSep + GeneralDef.GR_kgM + GeneralDef.EjecGeoParamIgual + reco.KgMaxVehic + " " +

9
Services/ProcesoEjecServ.cs
View File

@ -124,6 +124,7 @@ namespace OliviaAddInPro.Services
} }
} }
int result = Environment.TickCount & Int32.MaxValue; //para que el tickcount no sea negativo
if (cps.Getcancelled()) //mira a ver si ha cancelado el usuario if (cps.Getcancelled()) //mira a ver si ha cancelado el usuario
{ {
//se ha cancelado, lo envía al OliviaTask //se ha cancelado, lo envía al OliviaTask
@ -137,11 +138,11 @@ namespace OliviaAddInPro.Services
if(!fin) //si no ha finalizado normal, el usuario lo ha cancelado if(!fin) //si no ha finalizado normal, el usuario lo ha cancelado
res.Error.Add("Proceso Cancelado por el usuario"); res.Error.Add("Proceso Cancelado por el usuario");
} }
else if (!first_send_cfg && ((Math.Abs(Environment.TickCount) - lastprog) >= m_tm_progr) && !fin) //en caso normal, todo va bien, pide el progreso y la tarea else if (!first_send_cfg && ((result - lastprog) >= m_tm_progr) && !fin) //en caso normal, todo va bien, pide el progreso y la tarea
{ {
//solo pide la programación cada m_tm_progr milis //solo pide la programación cada m_tm_progr milis
var pp = pide_progr(); var pp = pide_progr();
if (pp .Value> TiposActu.ActuFinOk) if (pp.Value> TiposActu.ActuFinOk)
fin = true; fin = true;
if(pp.HasError) if(pp.HasError)
{ {
@ -153,8 +154,10 @@ namespace OliviaAddInPro.Services
else else
nint++; nint++;
} }
if (pp.Value == TiposActu.ActuFinNOk)
res.Error.Add("Finalizado proceso con fallos");
actualiza(pp); actualiza(pp);
lastprog = Environment.TickCount; lastprog = result;
} }
} while (!sal); } while (!sal);

15
Services/RecogidaServ.cs
View File

@ -28,15 +28,16 @@ namespace OliviaAddInPro.Services
*/ */
public int CompruebaCamposReco(string pathCapa) public int CompruebaCamposReco(string pathCapa)
{ {
int NCAMPS = 6; int NCAMPS = 5;
string[] camps; string[] camps;
camps = new string[NCAMPS]; camps = new string[NCAMPS];
camps[0] = RecogidaDef.campos_def.cons_id;
camps[1] = RecogidaDef.campos_def.cons_fracc; camps[0] = RecogidaDef.campos_def.cons_fracc;
camps[2] = RecogidaDef.campos_def.cons_nomrec; camps[1] = RecogidaDef.campos_def.cons_nomrec;
camps[3] = RecogidaDef.campos_def.cons_lateral; camps[2] = RecogidaDef.campos_def.cons_lateral;
camps[4] = RecogidaDef.campos_def.cons_uds; camps[3] = RecogidaDef.campos_def.cons_uds;
camps[5] = RecogidaDef.campos_def.cons_kgrec; camps[4] = RecogidaDef.campos_def.cons_kgrec;
//camps[5] = RecogidaDef.campos_def.cons_id;
int compCamp = HelperGdb.CheckFileds(pathCapa, camps); int compCamp = HelperGdb.CheckFileds(pathCapa, camps);
ErrStr = HelperGdb.OutStr; ErrStr = HelperGdb.OutStr;
if (compCamp == 0) if (compCamp == 0)

1
ViewModel/Limpieza/PaneLimpiezaSub1ViewModel.cs
View File

@ -213,6 +213,7 @@ namespace OliviaAddInPro
TipoTto = -1; TipoTto = -1;
VisTextAnchoVia = System.Windows.Visibility.Hidden; VisTextAnchoVia = System.Windows.Visibility.Hidden;
OliviaGlob.AddFlagTipEjec(TiposEjecucion.Config); //lo reinicia, por si estaba después de planificar OliviaGlob.AddFlagTipEjec(TiposEjecucion.Config); //lo reinicia, por si estaba después de planificar
OliviaGlob.RemoveFlagTipEjec(TiposEjecucion.Config2);
if (string.IsNullOrEmpty(capa)) if (string.IsNullOrEmpty(capa))
return false; return false;
//comprueba los campos de limpieza //comprueba los campos de limpieza

1
ViewModel/Recogida/PaneRecogidaSub1ViewModel.cs
View File

@ -274,6 +274,7 @@ namespace OliviaAddInPro
TiposVehic.Clear(); TiposVehic.Clear();
TiposCapac.Clear(); TiposCapac.Clear();
OliviaGlob.AddFlagTipEjec(TiposEjecucion.Config); //lo reinicia, por si estaba después de planificar OliviaGlob.AddFlagTipEjec(TiposEjecucion.Config); //lo reinicia, por si estaba después de planificar
OliviaGlob.RemoveFlagTipEjec(TiposEjecucion.Config2);
if (string.IsNullOrEmpty(capa)) if (string.IsNullOrEmpty(capa))
return false; return false;