public static void SendInfoToInsert_Client(ClientPackage cp, ref bool dobar)
{
string responseData = "";
IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 20000);
TcpClient client = new TcpClient(iPEndPoint);
NetworkStream ns = client.GetStream();
string poruka = "Client_Insert;" + cp.ToString();
Byte[] data = System.Text.Encoding.ASCII.GetBytes(poruka);
ns.Write(data, 0, data.Length);
Int32 bytes = ns.Read(data, 0, data.Length);
responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
if (responseData == "true")
{
dobar = true;
}
else
{
dobar = false;
}
ns.Close();
client.Close();
}
public void ClientPackage_FromString_Neispravan_VrstaKonverzija(string tekst)
{
Assert.Throws <ArgumentNullException>(() => {
ClientPackage cptest = new ClientPackage();
cptest.FromString(tekst);
});
}
public ActionResult SaveOrUpdate(ClientPackage model)
{
if (model.ClientId == 0)
{
TempData["msg"] = "<script>alert('Campul Client este obligatoriu!');</script>";
return(View(model));
}
else
{
if (ModelState.IsValid)
{
using (MyDBContext dc = new MyDBContext())
{
if (model.Id > 0) //Update
{
var original = dc.ClientPackage.Where(a => a.Id == model.Id).FirstOrDefault();
if (original != null)
{
dc.Entry(original).CurrentValues.SetValues(model);
}
}
else //Save
{
dc.ClientPackage.Add(model);
}
dc.SaveChanges();
}
}
return(View("Index"));
}
}
public void ClientPackage_FromString_Neispravan_DatumVrednosti(string tekst)
{
Assert.Throws <ArgumentOutOfRangeException>(() => {
ClientPackage cptest = new ClientPackage();
cptest.FromString(tekst);
});
}
public ClientPackage getLatestClient()
{
MemoryStream stream = new MemoryStream();
ClientPackage package = new ClientPackage();
//package.zip = File.ReadAllBytes(@"C:\1.zip");
return(package);
}
public void GetNextPackageByArrayEmptyTest()
{
var data = new byte[] { 0, 0, 0, 0 };
ClientPackage clientPackage = _factory.GetNextPackage(data);
Assert.Null(clientPackage);
}
public void ClientPackage_ToString_Ispravan(string tekst)
{
ClientPackage cpctrl = new ClientPackage();
cpctrl.Datum = ispravanDatum;
cpctrl.Region = "VOJVODINA";
cpctrl.Potrosnja = 323.23;
Assert.AreEqual(cpctrl.ToString(), tekst);
}
public void SetTargetsPackageTest()
{
var data = _setTargetsPackage.ToByteArray();
ClientPackage clientPackage = _factory.GetNextPackage(data);
Assert.NotNull(clientPackage);
Assert.AreEqual(_setTargetsPackage.Type, clientPackage.Type);
Assert.AreEqual(_setTargetsPackage.Units.Length, ((SetTargetsPackage)clientPackage).Units.Length);
Assert.AreEqual(data, clientPackage.ToByteArray());
}
public void GetRoomPackageTest()
{
var package = new GetRoomPackage();
var data = package.ToByteArray();
ClientPackage clientPackage = _factory.GetNextPackage(data);
Assert.NotNull(clientPackage);
Assert.AreEqual(data, clientPackage.ToByteArray());
Assert.AreEqual(package.Type, clientPackage.Type);
}
public ClientPackage AddClient(ClientPackageAdd clientPackage, int createdbyId)
{
var toAdd = new ClientPackage {
CreatedById = createdbyId,
CreatedOn = DateTime.Now,
Source = clientPackage.Source,
OnlyFiles = clientPackage.OnlyFiles,
PackageId = clientPackage.PackageId
};
context.Add(toAdd);
context.SaveChanges();
return(toAdd);
}
public void ClientPackage_FromString_Ispravan(string tekst)
{
ClientPackage cpctrl = new ClientPackage();
cpctrl.Datum = ispravanDatum;
cpctrl.Region = "VOJVODINA";
cpctrl.Potrosnja = 323.23;
ClientPackage cptest = new ClientPackage();
cptest.FromString(tekst);
Assert.AreEqual(cpctrl.Datum, cptest.Datum);
Assert.AreEqual(cpctrl.Region, cptest.Region);
Assert.AreEqual(cpctrl.Potrosnja, cptest.Potrosnja);
}
public void GetNextPackageEmptyTest()
{
var data = new byte[] { 0, 0, 0, 0 };
ClientPackage clientPackage = null;
using (var stream = new MemoryStream(data))
{
Console.WriteLine(stream.Length);
clientPackage = _factory.GetNextPackage(stream);
}
Assert.Null(clientPackage);
}
public void SendPackage(ClientPackage package)
{
var data = package.ToByteArray();
try
{
_stream.BeginWrite(data, 0, data.Length, SendCallback, package);
}
catch (NullReferenceException e)
{
}
catch (IOException e)
{
}
}
public void ExitFromRoomPackageTest()
{
var package = new ExitFromRoomPackage
{
RoomId = 1
};
var data = package.ToByteArray();
ClientPackage clientPackage = _factory.GetNextPackage(data);
Assert.NotNull(clientPackage);
Assert.AreEqual(data, clientPackage.ToByteArray());
Assert.AreEqual(package.Type, clientPackage.Type);
Assert.AreEqual(package.RoomId, ((ExitFromRoomPackage)clientPackage).RoomId);
}
public void activeSP([FromBody] ClientPackage forSP) //remember
{
db.Configuration.ProxyCreationEnabled = false;
// string sp = "Activate Service Package";
DateTime Now = DateTime.Now;
//refiloeknowsbest
Sale sales = new Sale();
sales.ClientID = forSP.Sale.ClientID;
//sales.Decription = activeSP; // this is where the sale type is specific
sales.Payment = forSP.Sale.Payment;
//sales.SaleType = type id of activate
sales.PaymentTypeID = forSP.Sale.PaymentTypeID;
sales.StatusID = 2;
sales.Date = Now;
//sales.Description = sp;
db.Sales.Add(sales);
db.SaveChanges();
int SaleID = db.Sales.Where(zz => zz.ClientID == forSP.Sale.ClientID && zz.SaleTypeID == forSP.Sale.SaleTypeID).Select(zz => zz.SaleID).LastOrDefault();
//ading to client sdjfnjvn thingy
ClientPackage CP = new ClientPackage();
CP.SaleID = SaleID;
CP.PackageID = forSP.ServicePackage.PackageID;
CP.Date = Now;
CP.ExpiryDate = Now.AddMonths(forSP.ServicePackage.Duration);
db.ClientPackages.Add(CP);
db.SaveChanges();
//**********instance for the service package*****************
int loop = forSP.ServicePackage.Quantity;
for (int j = 0; j <= loop; j++)
{
PackageInstance addInstance = new PackageInstance();
addInstance.PackageID = CP.PackageID;
addInstance.SaleID = SaleID;
addInstance.StatusID = 1;
db.PackageInstances.Add(addInstance);
db.SaveChanges();
}
}
public ActionResult SaveOrUpdate(int id)
{
if (id != -1) //update
{
using (MyDBContext dc = new MyDBContext())
{
var pack = dc.ClientPackage.Where(a => a.Id == id).Include(x => x.User).Include(x => x.User.UserDetails).FirstOrDefault();
return(View(pack));
}
}
else // create
{
ClientPackage pack = new ClientPackage();
pack.Id = -1;
return(View(pack));
}
}
public void SetUp()
{
calcPack = new CalculationPackage(ispravanDatum, 245.16, VrstaProracuna.MINIMALNI);
ispravanDatum = new DateTime(2020, 10, 28, 22, 45, 59);
ch = new Calculation();
ClientPackage cp = new ClientPackage();
cp.Datum = ispravanDatum;
cp.Potrosnja = 256.36;
cp.Region = "VOJVODINA";
ispravnalista.Add(cp);
cp = new ClientPackage();
cp.Datum = new DateTime(2020, 6, 15, 15, 59, 59);
cp.Potrosnja = 3636.36;
cp.Region = "MACVA";
ispravnalista.Add(cp);
}
public async void Process()
{
byte[] data = new byte[1024];
try
{
do
{
int len = await _stream.ReadAsync(data, 0, data.Length, _tokenSource.Token);
byte[] buffer = new byte[len];
Array.Copy(data, buffer, len);
using (var stream = new MemoryStream(buffer))
{
ClientPackage package = null;
do
{
package = _packageFactory.GetNextPackage(stream);
if (package != null)
{
var handler = PackageHandler.GetPackageHandler(this, package);
if (handler != null)
{
handler.HandlePackage();
}
else
{
Logger.Warn($"Package handler for package {package.Type} are not found! Client {ClientId}");
}
}
} while (package != null);
}
} while (_tcpClient.Connected && !_tokenSource.IsCancellationRequested);
}
catch (IOException)
{
Logger.Info($"Disconnect client {ClientId} by exception");
Disconnect();
}
catch (TaskCanceledException)
{
Logger.Info($"Disconnect client {ClientId} by exception");
Disconnect();
}
}
public ActionResult Delete(ClientPackage model)
{
using (MyDBContext dc = new MyDBContext())
{
var v = dc.ClientPackage.Where(a => a.Id == model.Id).FirstOrDefault();
if (v != null)
{
var userRel = dc.UserRelationship.Where(x => x.ClientPackageId == model.Id).ToList();
foreach (var rel in userRel)
{
dc.UserRelationship.Remove(rel);
}
dc.ClientPackage.Remove(v);
dc.SaveChanges();
}
}
return(View("Index"));
}
private void downloadLatestSetupFile()
{
//if (!_downloadingSetupInProgress)
//{
//_downloadingSetupInProgress = true;
Logger.Instance.Info("downloading new installation from server");
ClientPackage installationPack = ConnectionManager.Proxy.getLatestClient();
Logger.Instance.Info("Download Complete");
frmMain.ClientSetupDownloadLocation = string.Format(@"{0}\{1}", ClientUtils.TEMP_DIR, installationPack.binName);
Logger.Instance.Info(string.Format("Saving msi to {0}", frmMain.ClientSetupDownloadLocation));
Shared.Utils.SaveBinaryToFile(frmMain.ClientSetupDownloadLocation, installationPack.bin);
Logger.Instance.Info("Saving msi completed successfully");
//_downloadingSetupInProgress = false;
_downloadCompleteEvent.Set();
if (OnFinishedDownloading != null)
{
OnFinishedDownloading();
}
//}
}
public void InstallClientPackage(ClientPackage package)
{
string folder = "wwwroot/lib/" + package.Package.Name;
if (string.IsNullOrWhiteSpace(package.OnlyFiles))
{
Process.Start("git.exe", $"clone {package.Source} {folder}");
var process = new Process();
process.StartInfo.FileName = "git.exe";
process.StartInfo.Arguments = $"clone {package.Source} {folder}";
process.Start();
process.WaitForExit();
Directory.Delete(folder + "/.git");
}
else
{
using (var client = new WebClient())
{
string baseAddr = package.Source;
if (baseAddr.EndsWith(".git"))
{
baseAddr = baseAddr.Substring(0, baseAddr.Length - 4);
}
baseAddr = baseAddr
.Replace("https://github.com", "https://raw.githubusercontent.com");
if (!baseAddr.EndsWith("/"))
{
baseAddr += "/";
}
client.BaseAddress = baseAddr;
foreach (var file in package.OnlyFiles.Replace(", ", ",").Split(','))
{
string location = $"{folder}/{file}";
Directory.CreateDirectory(Path.GetDirectoryName(location));
client.DownloadFile($"master/{file}", location);
}
}
}
}
public static PackageHandler GetPackageHandler(Client client, ClientPackage package)
{
switch (package.Type)
{
case ClientPackageType.Ping:
return(new PingPackageHandler(client, package));
case ClientPackageType.Login:
return(new LoginPackageHandler(client, package));
case ClientPackageType.GetRoom:
return(new GetRoomPackageHandler(client, package));
case ClientPackageType.SetTargets:
return(new SetTargetsPackageHandler(client, package));
case ClientPackageType.ExitFromRoom:
return(new ExitFromRoomPackageHandler(client, package));
}
return(null);
}
private dynamic getInstancePackage(ClientPackage service)
{
List <dynamic> dymanicinstances = new List <dynamic>();
//int Total = 0;
foreach (PackageInstance pack in service.PackageInstances)
{
dynamic dynamicInstancePackage = new ExpandoObject();
dynamicInstancePackage.PackageID = pack.PackageID;
dynamicInstancePackage.Date = pack.Date;
dynamicInstancePackage.SaleID = pack.SaleID;
dynamicInstancePackage.StatusID = pack.StatusID;
InstanceStatu stat = db.InstanceStatus.Where(zz => zz.StatusID == pack.StatusID).FirstOrDefault();
dynamicInstancePackage.Status = stat.Status;
//if (stat.Status == "Active")
// Total++;
//dynamicInstancePackage.TotalAvailable = Total;
dymanicinstances.Add(dynamicInstancePackage);
}
return(dymanicinstances);
}
public GetRoomPackageHandler(Client client, ClientPackage package) : base(client, package)
{
}
public LoginPackageHandler(Client client, ClientPackage package) : base(client, package)
{
}
public ExitFromRoomPackageHandler(Client client, ClientPackage package) : base(client, package)
{
}
protected PackageHandler(Client client, ClientPackage package)
{
Client = client;
Package = package;
}
static void Main(string[] args)
{
/*---------------------------------------------------------------------------------------------------------------------------
* KOMUNIKACIJA DATA ACCESS KOMPONENTE SA CALCULATION HANDLER KOMPONENTOM
*--------------------------------------------------------------------------------------------------------------------------*/
CalculationHandlerCommunication clh = new CalculationHandlerCommunication();
List <CalculationPackage> cp = new List <CalculationPackage>();
var th1 = new Thread(() => CalculationHandlerCommunication.ReceiveMessage());
th1.IsBackground = true;
th1.Start();
/*--------------------------------------------------------------------------------------------------------------------------
* KOMUNIKACIJA DATA ACCESS KOMPONENTE SA BAZOM PODATAKA, UBACITI GDE TREBA
* -------------------------------------------------------------------------------------------------------------------------*/
/*
* var th2 = new Thread(() => DataBaseCommunication.AskForList(*DATUM ZA KOJI SE TRAZI *,*REFERENCA LISTE U KOJU DA VRATI PODATKE*));
* th2.IsBackground = true;
* th2.Start();
*/
/*--------------------------------------------------------------------------------------------------------------------------
* KOMUNIKACIJA DATA ACCESS KOMPONENTE SA KLIJENTOM
*-------------------------------------------------------------------------------------------------------------------------*/
DateTime datumuporuci;
int sekunde = 0, minuti = 0, sati = 0, dani = 0, meseci = 0, godine = 0;
string region = "";
int vrstaporuke;
double vrednostpotrosnje;
ClientPackage clientPackage = new ClientPackage();
TcpListener server = null;
//List<CalculationPackage> lista;
try
{
Int32 port = 13000;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
server = new TcpListener(localAddr, port);
// Start listening for client requests.
server.Start();
// Buffer for reading data
Byte[] bytes = new Byte[256];
String data = null;
// Enter the listening loop.
while (true)
{
Console.Write("Waiting for a connection... ");
// Perform a blocking call to accept requests.
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("Connected!");
data = null;
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
int i;
// Loop to receive all the data sent by the client.
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
// Translate data bytes to a ASCII string.
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
Console.WriteLine("Received: {0}", data);
string[] parametri = data.Split(';');
if (Int32.TryParse(parametri[0], out vrstaporuke) == false)
{
continue;
}
//--------------------------------------------------------
//VRSTA PORUKE KADA KORISNIK DODAJE OBJEKAT U BAZU PODATAKA
//--------------------------------------------------------
else if (vrstaporuke == 1)
{
region = parametri[1];
string[] datumpodaci = parametri[2].Split('/');
Int32.TryParse(datumpodaci[0], out sekunde);
Int32.TryParse(datumpodaci[1], out minuti);
Int32.TryParse(datumpodaci[2], out sati);
Int32.TryParse(datumpodaci[3], out dani);
Int32.TryParse(datumpodaci[4], out meseci);
Int32.TryParse(datumpodaci[5], out godine);
datumuporuci = new DateTime(godine, meseci, dani, sati, minuti, sekunde);
vrednostpotrosnje = Double.Parse(parametri[3]);
//PUNJENJE IZVUCENIH PODATAKA U FORMU
clientPackage.Datum = datumuporuci;
clientPackage.Potrosnja = vrednostpotrosnje;
clientPackage.Region = region;
bool dobar = false;
var porukathread = new Thread(() => DataBaseCommunication.SendInfoToInsert_Client(clientPackage, ref dobar));
porukathread.Start();
if (dobar)
{
bytes = System.Text.Encoding.ASCII.GetBytes("WRITTEN");
stream.Write(bytes, 0, bytes.Length);
}
else
{
bytes = System.Text.Encoding.ASCII.GetBytes("NOTWRITTEN");
stream.Write(bytes, 0, bytes.Length);
}
}
//--------------------------------------------------------
//VRSTA PORUKE KADA KORISNIK TRAZI LISTU PODATAKA IZ BAZE
//--------------------------------------------------------
else
{
string[] datumpodaci = parametri[2].Split('/');
Int32.TryParse(datumpodaci[0], out dani);
Int32.TryParse(datumpodaci[1], out meseci);
Int32.TryParse(datumpodaci[2], out godine);
sekunde = 0;
minuti = 0;
sati = 0;
datumuporuci = new DateTime(godine, meseci, dani, sati, minuti, sekunde);
string odgovorporuka = "";
var porukathread = new Thread(() => DataBaseCommunication.AskForList(datumuporuci, ref odgovorporuka, true));
bytes = System.Text.Encoding.ASCII.GetBytes(odgovorporuka);
stream.Write(bytes, 0, bytes.Length);
}
}
// Shutdown and end connection
client.Close();
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
finally
{
// Stop listening for new clients.
server.Stop();
}
Console.WriteLine("\nHit enter to continue...");
Console.Read();
}
public PingPackageHandler(Client client, ClientPackage package) : base(client, package)
{
}
public SetTargetsPackageHandler(Client client, ClientPackage package) : base(client, package)
{
}
