private Models.routerInfoModel getRouterInfo(int router_sk)
{
router router = db.routers.Where(x => x.router_sk == router_sk).FirstOrDefault();
List <dispositivo> devices = db.dispositivos.Where(x => x.router_sk == router.router_sk).ToList();
List <Models.dispositivoInfoModel> devicesModel = Models.dispositivoInfoModel.ConvertTo(devices);
List <lk_web> webs = router.lk_web.ToList();
List <Models.webModel> websModel = new List <Models.webModel>();
foreach (var w in webs)
{
websModel.Add(new Models.webModel
{
ip = w.web_ip,
url = w.web_url,
id = w.web_sk,
nombre = w.web_nombre
});
}
Models.routerInfoModel routerFinal = new Models.routerInfoModel();
routerFinal.router_sk = router.router_sk;
routerFinal.modelo = router.router_modelo;
routerFinal.ssid = router.router_ssid;
routerFinal.password = router.router_psw;
routerFinal.devices = devicesModel;
routerFinal.webs_bloqueadas = websModel;
return(routerFinal);
}
public void GetInfo()
{
CER.Test.org.gs1us.prod.gepir.router r = new router();
var o = r.GetItemByGTIN(new GetItemByGTIN {
requestedGtin = "0788687", requestedLanguages = new string[] { "En-US" }, version = 4.0M
});
}
public IHttpActionResult Getcliente(string username)
{
cliente cliente = _clientService.buscar(username);
if (cliente == null)
{
return(NotFound());
}
router router = _clientService.getRouterFromClient(cliente.cliente_sk);
List <dispositivo> devices = _clientService.getDevices(cliente.cliente_sk, router.router_sk);
List <lk_web> webs = router.lk_web.ToList();
List <webModel> websModel = new List <webModel>();
foreach (var w in webs)
{
websModel.Add(new webModel
{
ip = w.web_ip, url = w.web_url, id = w.web_sk, nombre = w.web_nombre
});
}
List <dispositivoInfoModel> devicesModel = dispositivoInfoModel.ConvertTo(devices);
clientInfoModel info = new clientInfoModel
{
id = cliente.cliente_sk,
username = cliente.cliente_id,
mb_contratado = cliente.cliente_vel_mb_contr,
mb_umbral = cliente.cliente_vel_mb_umbral,
nombre = cliente.cliente_desc,
router = new routerInfoModel
{
router_sk = router.router_sk,
modelo = router.router_modelo,
ssid = router.router_ssid,
password = router.router_psw,
devices = devicesModel,
webs_bloqueadas = websModel
}
};
return(Ok(info));
}
public IHttpActionResult updatearRouter(Models.router2Model router)
{
try
{
router r = db.routers.Where(x => x.router_sk == router.router_sk).FirstOrDefault();
r.router_modelo = router.router_modelo;
r.router_psw = router.router_psw;
r.router_ssid = router.router_ssid;
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { status = "ok" }, new { ot = router }));
}
catch (Exception ex)
{
return(CreatedAtRoute("DefaultApi", new { status = "error" }, new { mensaje = ex.ToString() }));
}
}
public static router CreateProductServiceProxy()
{
//var ps = new ProductSearchWebServiceGateway();
//var wsConfig = new OPVWebServiceConfiguration();
//var username = wsConfig.Username;
//var password = wsConfig.Password;
var header = new gepirRequestHeader {
requesterGln = "7350050279998", cascade = 9, cascadeSpecified = true
};
var gepirRouter = new router
{
UseDefaultCredentials = true,
gepirRequestHeaderValue = header,
Timeout = 60000
};
return(gepirRouter);
}
public IHttpActionResult Postrouter(Models.webBloqModel webBloq)
{
try
{
router routerModel = db.routers.Where(z => z.router_sk == webBloq.router_sk).FirstOrDefault();
int cant_bloq = 0;
int cant_no_bloq = 0;
JavaScriptSerializer serializer = new JavaScriptSerializer();
List <webABloquearModel> webABloquearModelString = serializer.Deserialize <List <webABloquearModel> >(webBloq.webs);
foreach (Models.webABloquearModel webok in webABloquearModelString)
{
Data.lk_web web;
web = db.lk_web.Where(x => x.web_sk == webok.web_sk).FirstOrDefault();
if (webok.web_bloqueado)
{
routerModel.lk_web.Add(web);
cant_bloq++;
}
else
{
routerModel.lk_web.Remove(web);
cant_no_bloq++;
}
}
db.SaveChanges();
Models.routerInfoModel routerModelfinal = getRouterInfo(webBloq.router_sk);
return(CreatedAtRoute("DefaultApi", new { cant = cant_no_bloq + cant_bloq }, new { status = "ok", cant_bloq = cant_bloq, cant_no_bloq = cant_no_bloq, router = routerModelfinal }));
}
catch (Exception ex)
{
return(CreatedAtRoute("DefaultApi", new { id = 123 }, new { status = "error:" + ex.ToString(), data = webBloq }));
}
}
public static void compareDatabasesAndUpdateIfNeeded(List <router> mainDBList, List <router> ownDBList)
{
// list for logFile
if (mainDBList.Count == ownDBList.Count)
{
Console.WriteLine("Databases vergelijken...");
log.Info("Comparing Databases...");
mainDBList = mainDBList.OrderBy(id => id.routerMainDB).ToList(); //order list for comparison
ownDBList = ownDBList.OrderBy(id => id.routerMainDB).ToList(); // order list for comparison
List <router> newOwnDBList = new List <router>();
int totalChanges = 0;
for (int count = 0; count < mainDBList.Count; count++) // algorithm for choosing the new information
{
router newRouter = new router();
newRouter.routerId = ownDBList[count].routerId; //mainDB is leading
newRouter.routerName = mainDBList[count].routerName; //mainDB is leading
if (mainDBList[count].routerName != ownDBList[count].routerName)
{
string newName = "Naam - ID: " + mainDBList[count].routerMainDB + " naam was: " + ownDBList[count].routerName + " is nu: " + mainDBList[count].routerName;
Console.WriteLine(newName);
log.Info(newName);
totalChanges++;
}
newRouter.routerAlias = mainDBList[count].routerAlias; // mainDB is leading
if (mainDBList[count].routerAlias != ownDBList[count].routerAlias)
{
string newAlias = "Alias - ID: " + mainDBList[count].routerMainDB + " alias was: " + ownDBList[count].routerAlias + " is nu: " + mainDBList[count].routerAlias;
Console.WriteLine(newAlias);
log.Info(newAlias);
totalChanges++;
}
newRouter.routerAddress = mainDBList[count].routerAddress; // mainDB is leading
if (mainDBList[count].routerAddress != ownDBList[count].routerAddress)
{
string newAddress = "IP adres - ID: " + mainDBList[count].routerMainDB + " IP adres was: " + ownDBList[count].routerAddress + " is nu: " + mainDBList[count].routerAddress;
Console.WriteLine(newAddress);
log.Info(newAddress);
totalChanges++;
}
newRouter.routerActivate = mainDBList[count].routerActivate; // mainDB is leading
if (mainDBList[count].routerActivate != ownDBList[count].routerActivate)
{
string newActive = "Active - ID: " + mainDBList[count].routerMainDB + " active status was: " + ownDBList[count].routerActivate + " is nu: " + mainDBList[count].routerActivate;
Console.WriteLine(newActive);
log.Info(newActive);
totalChanges++;
}
newRouter.routerSerialnumber = ownDBList[count].routerSerialnumber; // ownDB is leading
newRouter.routerMainDB = ownDBList[count].routerMainDB; // mainDB is leading
if (mainDBList[count].routerMainDB != ownDBList[count].routerMainDB)
{
string newMainDB = "ID - ID: " + mainDBList[count].routerMainDB + " Main database ID was: " + ownDBList[count].routerMainDB + " is nu: " + mainDBList[count].routerMainDB;
Console.WriteLine(newMainDB);
log.Info(newMainDB);
totalChanges++;
}
newOwnDBList.Add(newRouter);
}
if (totalChanges == 0)
{
Console.WriteLine();
Console.WriteLine("Geen veranderingen tussen databases");
log.Info("No difference between databases");
}
else
{
try
{
log.Info("Trying to update new Data...");
var updateItems = updateRoutersOwnServer(newOwnDBList);
if (updateItems == true)
{
log.Info("Data succesfully updated");
log.Info("Total values changed: " + totalChanges);
}
Console.WriteLine();
Console.WriteLine("Database is bijgewerkt");
Console.WriteLine("Aantal veranderingen: " + totalChanges);
}
catch (Exception ex)
{
Console.WriteLine("Error bij het updaten van de nieuwe gegevens");
Console.WriteLine("Error message: " + ex.Message);
log.Error("Error - error while updating new data");
log.Error("Error code: " + ex.Message);
log.Error("location error: " + ex.Source);
}
}
}
else if (mainDBList.Count > ownDBList.Count) //mainDB has more than ownDB
{
Console.WriteLine();
Console.WriteLine("Databases zijn niet gelijk in aantal, Update functie wordt nu uitgevoerd...");
log.Info("Databases are not equal, update function will be executed");
log.Info("Starting update Function...");
getNewByCompare(mainDBList, ownDBList);
ownDBList = getDataFromMicrosoftSQL(Connections.OwnDB(), PrivateValues.getAllFromOwnDatabaseQuery);
compareDatabasesAndUpdateIfNeeded(mainDBList, ownDBList);
}
else //ownDB had more than mainDB
{
Console.WriteLine();
Console.WriteLine("Database heeft teveel items - database wordt opnieuw aangemaakt...");
log.Info(@"Database has more items than leading database - database will be rebuild");
clearDatabaseAndRefill(mainDBList, ownDBList);
}
}
public static List <router> getDataFromMySQL(MySqlConnection connection, string query)
{
try
{
connection.Open();
}
catch (MySqlException ex)
{
switch (ex.Number)
{
case 0: // unable to connect to server
Console.WriteLine("kan niet verbinden met database");
log.Error("Could not connect to Main Database - Unable to connect");
break;
case 1042: // username or password is wrong
Console.WriteLine("Gebruikersnaam en/of wachtwoord zijn fout, probeer het opnieuw");
Console.WriteLine("Controleer het config bestand, of de gebruikersnaam en wachtwoord correct zijn");
log.Error("Could not connect to Main Database - Wrong username or password");
log.Error("Please check the username and password in the config file");
break;
case 1326: // server was not found
Console.WriteLine("geen MySQL server gevonden op dit ip");
log.Error("could not find MySQL server on given ip");
break;
default: // this will step into action if its not one of the above
Console.WriteLine("kan niet verbinden met database");
Console.WriteLine("Geen foutafhandeling, deze code graag doorgeven aan de ontwikkelaar: " + ex.Number);
log.Error("Could not connect to Main Database - Error code: " + ex.Number);
break;
}
Exit.exitByMySQL(ex.Message);
return(null);
}
MySqlCommand command = connection.CreateCommand();
command.CommandText = query;
List <router> routers = new List <router>();
MySqlDataReader reader = command.ExecuteReader(); // starts the reader
while (reader.Read())
{
router Router = new router();
try
{
//checks if there is a null value in the cell
bool one = reader.IsDBNull(1);
bool two = reader.IsDBNull(2);
bool three = reader.IsDBNull(3);
bool four = reader.IsDBNull(4);
Router.routerId = reader.GetInt32(0); //ID
if (one == false)
{
Router.routerName = reader.GetString(1);
} // name
if (two == false)
{
Router.routerAlias = reader.GetString(2);
} // alias
if (three == false)
{
Router.routerAddress = reader.GetString(3);
} // IP address
if (four == false)
{
Router.routerActivate = reader.GetString(4);
} // active
// serialnumber
Router.routerMainDB = reader.GetInt32(0); // mainDatabase ID
routers.Add(Router);
}
catch (Exception ex)
{
Console.WriteLine("Probleem bij het lezen van één waarde uit de Main Database - Error Message: " + ex.Message);
Console.WriteLine("Locatie probleem: " + ex.Source);
log.Error("Error while reading one value from Main Database - Error Message : " + ex.Message);
log.Error("Error Location: " + ex.Source);
}
}
connection.Close();
return(routers);
}
public static List <router> getDataFromMicrosoftSQL(SqlConnection connection, string query)
{
try
{
connection.Open();
Console.WriteLine("Verbonden met Cisco Tool database");
log.Info("Connected to Cisco Tool Database");
}
catch (SqlException ex)
{
switch (ex.Number)
{
case 0: // unable to connect to server
Console.WriteLine("kan niet verbinden met database");
log.Error("Could not connect to Cisco Tool Database - Unable to connect");
break;
case 1045: // username or password is wrong
Console.WriteLine("Gebruikersnaam en/of wachtwoord zijn fout, probeer het opnieuw");
log.Error("Could not connect to Cisco Tool Database - Wrong username or password");
break;
case 1326: // server was not found
Console.WriteLine("geen sql server gevonden op dit ip");
log.Error("could not find sql server on given ip");
break;
default: // this will step into action if its not one of the above
Console.WriteLine("kan niet verbinden met database");
Console.WriteLine("Geen foutafhandeling, deze code graag doorgeven aan de ontwikkelaar: " + ex.Number);
log.Error("Could not connect to Cisco Tool Database - Error code: " + ex.Number);
break;
}
Exit.exitBySQL(ex.Message);
return(null);
}
SqlCommand command = connection.CreateCommand();
command.CommandText = query;
List <router> routers = new List <router>();
SqlDataReader reader = command.ExecuteReader(); // starts the reader
while (reader.Read())
{
router Router = new router();
try
{
//checks if there is a null value in the cell
bool one = reader.IsDBNull(1);
bool two = reader.IsDBNull(2);
bool three = reader.IsDBNull(3);
Type threeString = reader.GetFieldType(3);
if (threeString != typeof(string))
{
three = true;
}
bool four = reader.IsDBNull(4);
bool five = reader.IsDBNull(5);
Router.routerId = reader.GetInt32(0); // ID
if (one == false)
{
Router.routerName = reader.GetString(1);
} // Name
if (two == false)
{
Router.routerAlias = reader.GetString(2);
} // alias
if (three == false)
{
Router.routerAddress = reader.GetString(3);
} // ip address
if (four == false)
{
Router.routerActivate = reader.GetString(4);
} // active
if (five == false)
{
Router.routerSerialnumber = reader.GetString(5);
} // Serialnumber
Router.routerMainDB = reader.GetInt32(6); // mainDatabase ID
routers.Add(Router);
}
catch (Exception ex)
{
Console.WriteLine("Probleem bij het lezen van één waarde uit de Cisco Tool Database - Error Message: " + ex.Message);
Console.WriteLine("Locatie probleem: " + ex.Source);
log.Error("Error while reading one value from Cisco Tool Database - Error Message : " + ex.Message);
log.Error("Error Location: " + ex.Source);
Exit.defaultExit();
}
}
connection.Close();
Console.WriteLine("Verbinding met Cisco Tool database correct afgesloten");
log.Info("Connection to Cisco Tool Database correctly closed");
return(routers);
}
public static string telnetClientTCP(router router, string username, string password) // telnet client using tcp client
{
log.Info("Telnet function was been started");
//initialze all values
string command = "sh diag | inc Serial"; // command to get serialnumber
string message = username + "\r\n" + password + "\r\n" + command + "\r\n";
string response = "";
string chassisSerialNumber = "";
log.Info("Getting serialnumber...");
bool convertIP = Network.validation.validateIPv4(router.routerAddress);
if (convertIP == true && router.routerActivate == "1")
{
try
{
response = Networkstreams.TalkToCiscoRouterAndWaitForResponse(router.routerAddress, message);
if (response != null)
{
if (!response.Contains("Chassis Serial Number"))
{
Console.WriteLine("error - kon niet verbinden met " + router.routerAddress + " via telnet om serienummer op te halen ");
Console.WriteLine("Error, gebruikersnaam en/of wachtwoord is onjuist");
log.Error("ERROR - Could not connect to " + router.routerAddress + " using telnet to get serialnumber ");
log.Error("errormessage - username and/or password invalid");
}
else
{
chassisSerialNumber = General.findCereal(response); //get serialcode from response
Console.WriteLine(router.routerAddress + " serienummer: " + chassisSerialNumber);
log.Info("Serialnumber received - IP Address: " + router.routerAddress + " Serialnumber: " + chassisSerialNumber);
}
}
else
{
Console.WriteLine("error - kon niet verbinden met " + router.routerAddress + " via telnet om serienummer op te halen ");
Console.WriteLine("Error, er vond een timeout plaats");
log.Error("ERROR - Could not connect to " + router.routerAddress + " using telnet to get serialnumber ");
log.Error("errormessage - Timeout, client did not respond within 2 seconds ");
}
}
catch (Exception ex)
{
if (response.Contains("Login invalid"))
{
Console.WriteLine("error - kon niet verbinden met " + router.routerAddress + " via telnet om serienummer op te halen ");
Console.WriteLine("Error, gebruikersnaam en/of wachtwoord is onjuist");
log.Error("ERROR - Could not connect to " + router.routerAddress + " using telnet to get serialnumber ");
log.Error("errormessage - username and/or password invalid");
}
else if (router.routerActivate == "0")
{
Console.WriteLine(router.routerAddress + " is niet actief en zal niet worden voorzien van een serienummer");
log.Info(router.routerAddress + " is marked as not active, serialnumber will not be received");
}
else
{
Console.WriteLine("error - kon niet verbinden met " + router.routerAddress + " via telnet om serienummer op te halen ");
Console.WriteLine("errormessage - " + ex.Message);
log.Error("ERROR - Could not connect to " + router.routerAddress + " using telnet to get serialnumber ");
log.Error("errormessage - " + ex.Message);
}
}
}
else
{
Console.WriteLine("error - Er was een probleem met het controleren van het ip adres ");
Console.WriteLine("probleem ontstond bij : " + router.routerAddress);
log.Error("ERROR - IP address was not legit - IP:" + router.routerAddress + " *If ip address is not shown, please contact app developer*");
}
return(chassisSerialNumber);
}
private void UpdateDomain(router router, string gtin, itemDataLineType gepirProduct)
{
if (string.IsNullOrEmpty(gepirProduct.brandName))
{
return;
}
using (var brandRepository = _repositoryFactory.Build <IBrandRepository, Brand>())
{
Brand brand = null;
var matchingBrands = brandRepository.Find(x => x.BrandName == gepirProduct.brandName);
// If a brand with the given name doesn't exist yet, we create it.
if (!matchingBrands.Any())
{
brand = new Brand {
BrandName = gepirProduct.brandName, LastUpdated = DateTime.Now
};
brandRepository.Add(brand);
}
// Else if there exists exactly one brand with the given name we use that brand
else if (matchingBrands.Count() == 1)
{
brand = matchingBrands.First();
// If the brand we retrieved doesn't have an owner we can add it as well
if (brand.Owner == null)
{
var manufacturerGln = gepirProduct.manufacturerGln ?? gepirProduct.informationProviderGln;
var getPartyByGln = new GetPartyByGLN {
requestedGln = new[] { manufacturerGln }, versionSpecified = false
};
var partyByGln = router.GetPartyByGLN(getPartyByGln);
if (partyByGln != null && partyByGln.partyDataLine != null && partyByGln.partyDataLine.Length > 0)
{
using (var companyRepository = _repositoryFactory.Build <IRepository <Company>, Company>())
{
var manufacturer = partyByGln.partyDataLine[0];
Company company = null;
var matchingCompanies =
companyRepository.Find(x => x.CompanyName == manufacturer.partyName);
if (!matchingCompanies.Any())
{
company = _gepirCompanyMapper.Map(manufacturer);
companyRepository.Add(company);
companyRepository.Persist();
}
else if (matchingCompanies.Count() == 1)
{
company = matchingCompanies.First();
}
// If we added or found the correct company
if (company != null)
{
//Todo: This should actually be done within the repository
var brandOwner = brandRepository.FindDomainObject(company);
brand.Owner = brandOwner;
}
brandRepository.Persist();
using (var productRepository = _repositoryFactory.Build <IProductRepository, Product>())
{
// If product doesn't exist in database yet - add it.
if (!productRepository.Find(x => x.GlobalTradeItemNumber == gtin).Any())
{
gepirProduct.gtin = gtin;
var newProduct = _gepirProductMapper.Map(gepirProduct);
productRepository.Add(newProduct);
productRepository.Persist();
}
}
}
}
}
}
if (brand != null && brand.Owner == null)
{
}
}
}
