public async static Task <List <Home_Stuff> > GetOtherGoods(string productType)
{
List <Home_Stuff> products = new List <Home_Stuff>();
var url = DataRoot.GenerateURL("getProducts");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
var data = new
{
product_type = productType
};
var jsonData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, jsonData);
var json = await response.Content.ReadAsStringAsync();
var home_stuffRoot = JsonConvert.DeserializeObject <DataRoot>(json);
products = home_stuffRoot.home_stuff as List <Home_Stuff>;
}
return(products);
}
public async static Task <List <AssignedOccasions> > GetAssignedOccasions()
{
List <AssignedOccasions> products = new List <AssignedOccasions>();
var url = DataRoot.GenerateURL("getAssignedOccasions");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
var response = await client.GetAsync(url);
var json = await response.Content.ReadAsStringAsync();
var dataRoot = JsonConvert.DeserializeObject <DataRoot>(json);
products = dataRoot.assigned_occasions as List <AssignedOccasions>;
}
return(products);
}
//----- Prideta filtracijai
public async static Task <List <Flower_Type> > GetFlowerTypes()
{
List <Flower_Type> flowerTypes = new List <Flower_Type>();
var url = DataRoot.GenerateURL("getTypes");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
var data = new
{
flower_type = 1
};
var jsonData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, jsonData);
var json = await response.Content.ReadAsStringAsync();
var dataRoot = JsonConvert.DeserializeObject <DataRoot>(json);
flowerTypes = dataRoot.flowers_type as List <Flower_Type>;
}
return(flowerTypes);
}
public async static Task <string> GetProductImage(int productId, string productType)
{
string productImage;
var url = DataRoot.GenerateURL("getProductImage");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
var data = new
{
id = productId.ToString(),
product_type = productType
};
var jsonData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, jsonData);
var json = await response.Content.ReadAsStringAsync();
var productRoot = JsonConvert.DeserializeObject <DataRoot>(json);
productImage = productRoot.product_image;
}
return(productImage);
}
async public Task <string> Initialize()
{
StringBuilder output = new StringBuilder();
await Task.Run(() => {
List <DataRoot> roots = new List <DataRoot>();
ProcessStatus status = new ProcessStatus();
Assembly assembly = Assembly.GetExecutingAssembly();
string[] resources = assembly.GetManifestResourceNames();
foreach (string resource in resources)
{
if (!resource.EndsWith(".xml"))
{
continue;
}
status.Message = Translator.Translate("Loading game data...");
Progress.Report(status);
using (Stream stream = assembly.GetManifestResourceStream(resource)) {
DataRoot data = DataRoot.FromXml(stream);
output.AppendLine(data.ToXml());
roots.Add(data);
}
}
status.MaxValue = roots.Count;
for (int i = 0; i < roots.Count; i++)
{
status.Value = i;
status.Message = i.ToString();
Progress.Report(status);
}
});
return(output.ToString());
}
public Serializer(string inputFile) : base(inputFile)
{
DependencyChecker.AssertVCRedistInstalled();
Features.ChannelNameEdit = ChannelNameEditMode.All;
Features.DeleteMode = DeleteMode.Physically;
Features.CanSkipChannels = true;
Features.CanLockChannels = true;
Features.CanHideChannels = false;
Features.CanHaveGaps = false;
Features.EncryptedFlagEdit = true;
Features.SortedFavorites = true;
DataRoot.AddChannelList(avbtChannels);
DataRoot.AddChannelList(avbcChannels);
DataRoot.AddChannelList(dvbtChannels);
DataRoot.AddChannelList(dvbcChannels);
DataRoot.AddChannelList(dvbsChannels);
DataRoot.AddChannelList(antennaipChannels);
DataRoot.AddChannelList(cableipChannels);
DataRoot.AddChannelList(satipChannels);
DataRoot.AddChannelList(freesatChannels);
// hide columns for fields that don't exist in Panasonic channel list
foreach (ChannelList list in DataRoot.ChannelLists)
{
list.VisibleColumnFieldNames.Remove("PcrPid");
list.VisibleColumnFieldNames.Remove("VideoPid");
list.VisibleColumnFieldNames.Remove("AudioPid");
}
}
private void LoadTunerData(SQLiteCommand cmd, string joinTable, string joinFields, Action <HisTransponder, SQLiteDataReader, int> enhanceTransponderInfo)
{
if (!tableNames.Contains(joinTable.ToLower()))
{
return;
}
cmd.CommandText = $"select tuner.tunerid, oid, tid, satellite {joinFields} "
+ $" from tuner inner join {joinTable} on {joinTable}.tunerid=tuner.tunerid";
using (var r = cmd.ExecuteReader())
{
while (r.Read())
{
var id = r.GetInt32(0);
var trans = new HisTransponder(id);
trans.OriginalNetworkId = r.GetInt32(1);
trans.TransportStreamId = r.GetInt32(2);
trans.Satellite = DataRoot.Satellites.TryGet(r.GetInt32(3));
enhanceTransponderInfo(trans, r, 4);
DataRoot.AddTransponder(trans.Satellite, trans);
}
}
}
public async static Task <List <UserAddress> > GetUserAddresses(string tokenC)
{
List <UserAddress> addresses = new List <UserAddress>();
var url = DataRoot.GenerateURL("getUserAddresses");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokenC);
//var jsonData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = await client.GetAsync(url);
var json = await response.Content.ReadAsStringAsync();
var dataRoot = JsonConvert.DeserializeObject <DataRoot>(json);
addresses = dataRoot.user_addresses as List <UserAddress>;
}
return(addresses);
}
public async static Task <string> ChangeUserPass(string tokenC, string oldPassword, string newPassword)
{
var rez = "";
var url = DataRoot.GenerateURL("changeUserPass");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
var data = new
{
token = tokenC,
oldPass = oldPassword,
newPass = newPassword
};
var jsonData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, jsonData);
var json = await response.Content.ReadAsStringAsync();
var userRoot = JsonConvert.DeserializeObject <DataRoot>(json);
var result = userRoot.message;
rez = result;
}
return(rez);
}
public SatChannel(int order, int slot, DataMapping data, DataRoot dataRoot) : base(data)
{
this.InUse = data.GetWord(_SatConfigIndex) != 0xFFFF;
if (!InUse)
{
return;
}
this.InitCommonData(slot, SignalSource.DVBS, data);
this.InitDvbData(data);
int transponderIndex = data.GetWord(_TransponderIndex);
var transponder = dataRoot.Transponder.TryGet(transponderIndex);
var sat = transponder.Satellite;
this.Transponder = transponder;
this.Satellite = sat.Name;
this.SatPosition = sat.OrbitalPosition;
this.RecordOrder = order;
this.TransportStreamId = transponder.TransportStreamId;
this.OriginalNetworkId = transponder.OriginalNetworkId;
this.SymbolRate = transponder.SymbolRate;
this.Polarity = transponder.Polarity;
this.FreqInMhz = transponder.FrequencyInMhz;
}
public async static Task <string> DeleteUserAddress(string tokenC, int id)
{
var rez = "";
var url = DataRoot.GenerateURL("deleteUserAddress");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
var data = new
{
id = id
};
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokenC);
var jsonData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, jsonData);
var json = await response.Content.ReadAsStringAsync();
var userRoot = JsonConvert.DeserializeObject <DataRoot>(json);
var result = userRoot.message;
rez = result;
}
return(rez);
}
public SatChannel(int slot, SignalSource presetList, DataMapping data, DataRoot dataRoot, FavoritesIndexMode sortedFavorites, IDictionary <int, string> providerNames) :
base(data, sortedFavorites)
{
this.InitCommonData(slot, SignalSource.DVBS | presetList, data);
if (!this.InUse)
{
this.IsDeleted = true;
return;
}
this.InitDvbData(data, providerNames);
int transponderIndex = data.GetWord(_TransponderIndex);
Transponder transponder = dataRoot.Transponder.TryGet(transponderIndex);
if (transponder == null)
{
var list = dataRoot.GetChannelList(this.SignalSource | SignalSource.TV);
dataRoot.Warnings.AppendFormat("{0} channel record #{1} (Pr# {2} \"{3}\") contains invalid transponder index {4}\r\n",
list.ShortCaption, slot, this.OldProgramNr, this.Name, transponderIndex);
return;
}
Satellite sat = transponder.Satellite;
this.Satellite = sat.Name;
this.SatPosition = sat.OrbitalPosition;
this.Polarity = transponder.Polarity;
this.SymbolRate = transponder.SymbolRate;
this.FreqInMhz = transponder.FrequencyInMhz;
this.ChannelOrTransponder = "";
}
internal DbChannel(SQLiteDataReader r, IDictionary <string, int> field, DataRoot dataRoot, Encoding encoding)
{
this.RecordIndex = r.GetInt32(field["rowid"]);
this.RecordOrder = r.GetInt32(field["major_channel"]);
this.OldProgramNr = r.GetInt32(field["major_channel"]);
if (this.OldProgramNr == 1178)
{
}
int ntype = r.GetInt32(field["ntype"]);
if (ntype == 1)
{
this.SignalSource |= SignalSource.DvbS;
if (r.GetInt32(field["ya_svcid"]) >= 0)
{
this.SignalSource |= SignalSource.Freesat;
}
}
else if (ntype == 2)
{
this.SignalSource |= SignalSource.DvbT;
}
else if (ntype == 3)
{
this.SignalSource |= SignalSource.DvbC;
}
else if (ntype == 10)
{
this.SignalSource |= SignalSource.AnalogT | SignalSource.Tv;
}
else if (ntype == 14)
{
this.SignalSource |= SignalSource.AnalogC | SignalSource.Tv;
}
else if (ntype == 15)
{
this.SignalSource |= SignalSource.SatIP;
}
byte[] buffer = new byte[1000];
var len = r.GetBytes(field["delivery"], 0, buffer, 0, 1000);
this.AddDebug(buffer, 0, (int)len);
this.Skip = r.GetInt32(field["skip"]) != 0;
this.Encrypted = r.GetInt32(field["free_CA_mode"]) != 0;
this.Lock = r.GetInt32(field["child_lock"]) != 0;
this.ParseFavorites(r, field);
this.ReadNamesWithEncodingDetection(r, field, encoding);
if (ntype == 10 || ntype == 14)
{
this.ReadAnalogData(r, field);
}
else
{
this.ReadDvbData(r, field, dataRoot, buffer);
}
}
public virtual SceneData GetSceneAsCache(int mapID)
{
if (mapID != 0)
{
return(DataRoot.LoadScene(mapID, true, false, false));
}
return(null);
}
public Serializer(string inputFile) : base(inputFile)
{
Features.ChannelNameEdit = ChannelNameEditMode.None;
Features.DeleteMode = DeleteMode.Physically;
Features.FavoritesMode = FavoritesMode.None;
DataRoot.AddChannelList(allChannels);
}
public bool Equals(Crosslink?other)
{
return(!(other is null) &&
Shard == other.Shard &&
StartEpoch == other.StartEpoch &&
EndEpoch == other.EndEpoch &&
DataRoot.Equals(other.DataRoot) &&
ParentRoot.Equals(other.ParentRoot));
}
public LnbConfig(DataMapping mapping, DataRoot dataRoot)
{
this.Id = mapping.GetByte("SettingId");
if (this.Id == 0)
{
return;
}
int satIndex = mapping.GetByte("SatIndex");
this.Satellite = dataRoot.Satellites[satIndex];
}
public static List <Laptop> Parse(String filePath)
{
List <Laptop> laptopList = new List <Laptop>();
String json = File.ReadAllText(filePath);
DataRoot rlr = JsonConvert.DeserializeObject <DataRoot>(json);
foreach (Data raw in rlr.data)
{
laptopList.Add(new Laptop(raw));
}
return(laptopList);
}
public static DataRoot DeserializeFromXML(string xml)
{
var xsExpirations = new XmlSerializer(typeof(DataRoot));
DataRoot rootDataObj = null;
using (TextReader reader = new StringReader(xml))
{
rootDataObj = (DataRoot)xsExpirations.Deserialize(reader);
reader.Close();
}
return(rootDataObj);
}
public void Execute()
{
if (IsValid(Owner))
{
DataRoot.PostCommand(this);
}
if (IsInsertCommand)
{
var model = Owner as LineModel;
model.AutoExpandLeft = true;
model.ChildDelta -= 2;
}
}
private void ReadChannels()
{
var pos = 0;
using var file = new StreamReader(FileName);
string line;
while ((line = file.ReadLine()) != null)
{
ChannelInfo channel = new Channels(pos, line, DataRoot);
DataRoot.AddChannel(allChannels, channel);
pos++;
}
}
public DigitalChannel(int slot, SignalSource signalSource, DataMapping data, DataRoot dataRoot,
IDictionary <int, decimal> transpFreq, FavoritesIndexMode sortedFavorites, IDictionary <int, string> providerNames) :
base(data, sortedFavorites)
{
// ToDo - ShiT
this.InitCommonData(slot, signalSource & ~SignalSource.TVAndRadioAndData, data);
if (!this.InUse)
{
return;
}
// "InUse" and "IsDeleted" are not always guessed correctly. If PrNr=0, the channel contains garbage
if (this.OldProgramNr == 0)
{
this.InUse = false;
return;
}
this.InitDvbData(data, providerNames);
decimal freq = 0;
int transp = data.GetByte(_ChannelOrTransponder);
if (dataRoot.Transponder.TryGetValue(transp, out var tp))
{
this.Polarity = tp.Polarity;
}
freq = transpFreq.TryGet(transp);
if (freq == 0 && tp != null)
{
freq = tp.FrequencyInMhz;
}
if (freq == 0)
{
if ((this.SignalSource & SignalSource.Antenna) != 0)
{
freq = transp * 8 + 306;
}
else if ((this.SignalSource & SignalSource.Cable) != 0)
{
freq = transp * 8 + 106;
}
}
this.ChannelOrTransponder = transp.ToString();
this.FreqInMhz = freq;
}
public void Release()
{
if (Owner is null)
{
return;
}
DataRoot.Remove(this);
Discard(); //discard myself and recursivly discard all my children
if (this is RootModel)
{
DataRoot.Discard(); //kill off the dataChef
}
Owner = null;
}
private void LoadLists(SQLiteCommand cmd)
{
cmd.CommandText = "select Pid, Name from FavoriteList";
using (var r = cmd.ExecuteReader())
{
while (r.Read())
{
int listId = r.GetInt32(0);
string name = r.GetString(1);
if (name == "$all")
{
pidAll = listId;
}
else if (name == "$av")
{
pidAv = listId;
}
else if (name.StartsWith("FAV"))
{
// all real user favorite lists are using the "userFavList"
favListIdToFavIndex.Add(listId, int.Parse(name.Substring(3)) - 1);
continue;
}
// lists for physical channel sources
var list = new ChannelList(SignalSource.All, name);
list.VisibleColumnFieldNames = ColumnNames;
channelLists.Add(listId, list);
if (name.StartsWith("$"))
{
list.ReadOnly = true;
}
else
{
DataRoot.AddChannelList(list); // only lists in the DataRoot will be visible in the UI
}
}
}
// add the special list for the user favorites 1-4
userFavList.VisibleColumnFieldNames = ColumnNames;
userFavList.IsMixedSourceFavoritesList = true;
channelLists.Add(0, userFavList);
DataRoot.AddChannelList(userFavList);
}
public async static Task <List <object> > AddUserAddress(string tokenC, UserAddress userAddress)
{
List <object> rez = new List <object>();
var url = DataRoot.GenerateURL("addUserAddress");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
var data = new
{
address = userAddress.address,
postal_code = userAddress.postal_code,
city = userAddress.city,
phone_number = userAddress.phone_number,
customer_name = userAddress.name
};
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokenC);
var jsonData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, jsonData);
var json = await response.Content.ReadAsStringAsync();
var userRoot = JsonConvert.DeserializeObject <DataRoot>(json);
if (userRoot.last_id != null)
{
rez.Add("Id");
rez.Add(userRoot.last_id);
}
else
{
var result = userRoot.message;
rez.Add("Message");
rez.Add(result);
}
}
return(rez);
}
public async static Task <List <string> > RegisterUser(string userEmail, string userPassword)
{
// User user = new User();
List <string> userx = new List <string>();
var url = DataRoot.GenerateURL("register");
//-----
// sito reikia nes nera ssl
var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
//------
using (HttpClient client = new HttpClient(handler))
{
var data = new
{
email = userEmail,
password = userPassword
};
var jsonData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, jsonData);
var json = await response.Content.ReadAsStringAsync();
var userRoot = JsonConvert.DeserializeObject <DataRoot>(json);
if (userRoot.userToken != null)
{
// user = userRoot.user_data as User;
userx.Add("Token");
userx.Add(userRoot.userToken);
}
else
{
userx.Add("Message");
userx.Add(userRoot.message);
}
}
return(userx);
}
private void AssertRefListContent(DataRoot dataRoot, string refListFile)
{
MemoryStream mem = new MemoryStream();
var writer = new StreamWriter(mem);
CsvRefListSerializer.Save(writer, dataRoot, false); // don't include deleted channels to maintain compatibility between new code and old test files
writer.Flush();
mem.Seek(0, SeekOrigin.Begin);
var actual = new StreamReader(mem).ReadToEnd();
var expected = File.ReadAllText(refListFile);
// satellite orbital position is no longer part of the UID (Samsung J series doesn't provide this information)
var regex = new Regex(@",S\d+.\d+[EW](-\d+-\d+-\d+,)");
expected = regex.Replace(expected, @",S$1");
Assert.AreEqual(expected, actual);
}
public static string SerializeToXml(DataRoot DataObject)
{
var xsSubmit = new XmlSerializer(typeof(DataRoot));
using (var sw = new StringWriter())
{
using (var writer = XmlWriter.Create(sw))
{
xsSubmit.Serialize(writer, DataObject);
var data = sw.ToString();
writer.Flush();
writer.Close();
sw.Flush();
sw.Close();
return(data);
}
}
}
internal DbChannel(SQLiteDataReader r, IDictionary <string, int> field, DataRoot dataRoot, Dictionary <long, string> providers, Satellite sat, Transponder tp)
{
var chType = r.GetInt32(field["chType"]);
this.SignalSource = DbSerializer.ChTypeToSignalSource(chType);
this.RecordIndex = r.GetInt64(field["SRV.srvId"]);
this.OldProgramNr = r.GetInt32(field["major"]);
this.FreqInMhz = (decimal)r.GetInt32(field["freq"]) / 1000;
this.ChannelOrTransponder =
(this.SignalSource & SignalSource.DvbT) == SignalSource.DvbT ? LookupData.Instance.GetDvbtTransponder(this.FreqInMhz).ToString() :
(this.SignalSource & SignalSource.DvbC) == SignalSource.DvbC ? LookupData.Instance.GetDvbcTransponder(this.FreqInMhz).ToString() :
(this.SignalSource & SignalSource.DvbS) == SignalSource.DvbS ? LookupData.Instance.GetAstraTransponder((int)this.FreqInMhz).ToString() :
"";
this.Name = DbSerializer.ReadUtf16(r, 6);
this.Hidden = r.GetBoolean(field["hidden"]);
this.Encrypted = r.GetBoolean(field["scrambled"]);
this.Lock = r.GetBoolean(field["lockMode"]);
this.Skip = !r.GetBoolean(field["numSel"]);
if (sat != null)
{
this.Satellite = sat.Name;
this.SatPosition = sat.OrbitalPosition;
}
if (tp != null)
{
this.Transponder = tp;
this.SymbolRate = tp.SymbolRate;
this.Polarity = tp.Polarity;
}
if ((this.SignalSource & SignalSource.Digital) != 0)
{
this.ReadDvbData(r, field, dataRoot, providers);
}
else
{
this.ReadAnalogData(r, field);
}
base.IsDeleted = this.OldProgramNr == -1;
}
private void AssertRefListContent(DataRoot dataRoot, string refListFile)
{
CsvFileSerializer csv = new CsvFileSerializer(null, dataRoot, false);
MemoryStream mem = new MemoryStream();
var writer = new StreamWriter(mem);
csv.Save(writer);
writer.Flush();
mem.Seek(0, SeekOrigin.Begin);
var actual = new StreamReader(mem).ReadToEnd();
var expected = File.ReadAllText(refListFile);
// satellite orbital position is no longer part of the UID (Samsung J series doesn't provide this information)
var regex = new Regex(@",S\d+.\d+[EW](-\d+-\d+-\d+,)");
expected = regex.Replace(expected, @",S$1");
Assert.AreEqual(expected, actual);
}
