[WebMethod] // anotação que faz com que este método seja reconhecido no web service
public ZipCodeInfo[] searchByAddress(int paramUf, string paramCity, string paramAddress) // searchByAddress é um método do web service que iremos utilizar para fazer a pesquisa pelo uf, cidade e endereço informados como parâmetro.
{
try
{
//Observações
//Cidade no minimo 3 letras
//Endereço no minimo 3 letras
ZipCodeLoad zipLoad = new ZipCodeLoad(); // instanciando o objeto de um serviço externo de cep
ZipCodeInfo[] zipCodeInfos = null; // criando a variável de retorno, que é uma lista, mas atribuímos um valor nulo, por enquanto
// criamos uma variável uf para identificar de qual uf iremos fazer a pesquisa, de acordo com a uf informada
ZipCodeUf uf = (ZipCodeUf)Enum.GetValues(typeof(ZipCodeUf)).GetValue(paramUf);
AddressCode addressCode = null; // criamos uma variável e atribuímos o valor nulo pra ela
if (AddressCode.TryParse(uf, paramCity, paramAddress, out addressCode)) // convertemos nossos parâmetros em um endereço válido e atribuímos a variável criada anteriormente
{
zipCodeInfos = zipLoad.Address(addressCode); // consumimos o serviço que faz a pesquisa do endereço e retornamos seu resultado a variável de lista que criamos anteriormente
}
return(zipCodeInfos); // retornamos os resultados em forma de lista
}
catch (ZipCodeException ex) // em caso de erro no código acima este método é chamado e executado, fazendo com que seja retornado um erro, no formato xml
{
throw ex;
}
}
public void TestTestAddressCodeTryParseFalse()
{
bool result = AddressCode
.TryParse(ZipCodeUf.SP, "", "", out AddressCode addressCode);
Assert.IsFalse(result);
Assert.IsNull(addressCode);
}
public void TestTestAddressCode()
{
AddressCode addressCode = new AddressCode(ZipCodeUf.SP, "SÃO PAULO", "AVENIDA");
Assert.AreEqual(ZipCodeUf.SP, addressCode.Uf);
Assert.AreEqual("SÃO PAULO", addressCode.City);
Assert.AreEqual("AVENIDA", addressCode.Address);
Assert.IsInstanceOfType(addressCode.GetType(), typeof(AddressCode).GetType());
}
public async Task <IActionResult> Address([FromBody] AddressCodeData data)
{
if (AddressCode.TryParse(ParseZipCodeUf(data.Uf), data.City, data.Address, out AddressCode addressCode))
{
AddressCodeResult addressCodeResult = await AddressCodeLoad.FindAsync(addressCode);
return(Json(addressCodeResult));
}
return(Json(new { IsValid = false }));
}
public void TestTestAddressCodeTryParse()
{
bool result = AddressCode
.TryParse(ZipCodeUf.SP, "SÃO PAULO", "AVENIDA", out AddressCode addressCode);
Assert.AreEqual(ZipCodeUf.SP, addressCode.Uf);
Assert.AreEqual("SÃO PAULO", addressCode.City);
Assert.AreEqual("AVENIDA", addressCode.Address);
Assert.IsTrue(result);
Assert.IsInstanceOfType(addressCode.GetType(), typeof(AddressCode).GetType());
}
public async Task TestAddressCodeLoadFindAsyncException()
{
try
{
await AddressCodeLoad.FindAsync(AddressCode.Parse(ZipCodeUf.SP, "", ""));
}
catch (AddressCodeException ex)
{
throw ex;
}
}
public void TestAddressCodeLoadFindException()
{
try
{
AddressCodeLoad.Find(AddressCode.Parse(ZipCodeUf.SP, "", ""));
}
catch (AddressCodeException ex)
{
throw ex;
}
}
public void InsertAddressCode()
{
using (var context = new UNSModel())
{
var y = new AddressCode()
{
IFNSFL = "s", OKATO = "x", OKTMO = "z"
};
context.Set <AddressCode>().Add(y);
context.SaveChanges();
context.Set <AddressCode>().Remove(y);
context.SaveChanges();
}
}
/// <summary>
/// Returns a 13 character array, representing the code word to be sent.
/// A code word consists of 9 address bits, 3 data bits, and on sync bit
/// but in our case, only the first 8 address bits and the last 2 data
/// bits are used. A code bit can have 4 different states: "F" (floating),
/// "1" (high), "0" (low), and "S" (synchronous bit).<br/><br/>
/// +-------------------------------+--------------------------------+-----------------------------------------+-----------------------------------------+----------------------+------------+
/// | 4 bits address (switch group) | 4 bits address (switch number) | 1 bit address (not used, so never mind) | 1 bit address (not used, so never mind) | 2 data bits (on|off) | 1 sync bit |
/// | 1=0FFF 2=F0FF 3=FF0F 4=FFF0 | 1=0FFF 2=F0FF 3=FF0F 4=FFF0 | F | F | on=FF off=F0 | S |
/// +-------------------------------+--------------------------------+-----------------------------------------+-----------------------------------------+----------------------+------------+
/// <br/>
/// </summary>
/// <param name="address">
/// The switch group (address).
/// </param>
/// <param name="chan">
/// The channel (switch) to manipulate.
/// </param>
/// <param name="status">
/// Whether to switch on (true) or off (false).
/// </param>
/// <returns>
/// a single-character array containing only a null-character.
/// </returns>
private String GetCodeWordB(AddressCode address, ChannelCode chan, Boolean status)
{
Int32 returnPos = 0;
char[] word = new char[13];
String[] code = new String[5] {
"FFFF", "0FFF", "F0FF", "FF0F", "FFF0"
};
if (((Int32)address < 1) || ((Int32)address > 4) ||
((Int32)chan < 1) || ((Int32)chan > 4))
{
return(new String(new char[1] {
'\0'
}));
}
for (Int32 i = 0; i < 4; i++)
{
word[returnPos++] = code[(Int32)address][i];
}
for (Int32 j = 0; j < 4; j++)
{
word[returnPos++] = code[(Int32)chan][j];
}
word[returnPos++] = 'F';
word[returnPos++] = 'F';
word[returnPos++] = 'F';
if (status)
{
word[returnPos++] = 'F';
}
else
{
word[returnPos++] = '0';
}
word[returnPos] = '\0';
return(new String(word));
}
public void TestTestAddressCodeParseException()
{
AddressCode.Parse(ZipCodeUf.SP, "", "");
}
/// <summary>
/// Switch a remote switch off (Type B with two rotary/sliding switches).
/// </summary>
/// <param name="address">
/// The address of the switch group.
/// </param>
/// <param name="channel">
/// The channel (switch) itself.
/// </param>
public void SwitchOff(AddressCode address, ChannelCode channel)
{
this.SendTriState(this.GetCodeWordB(address, channel, false).ToCharArray());
}
/// <summary>
/// Switch a remote switch off (Type B with two rotary/sliding switches).
/// </summary>
/// <param name="address">
/// The address of the switch group.
/// </param>
/// <param name="channel">
/// The channel (switch) itself.
/// </param>
public void SwitchOff(AddressCode address, ChannelCode channel) {
this.SendTriState(this.GetCodeWordB(address, channel, false).ToCharArray());
}
/// <summary>
/// Returns a 13 character array, representing the code word to be sent.
/// A code word consists of 9 address bits, 3 data bits, and on sync bit
/// but in our case, only the first 8 address bits and the last 2 data
/// bits are used. A code bit can have 4 different states: "F" (floating),
/// "1" (high), "0" (low), and "S" (synchronous bit).<br/><br/>
/// +-------------------------------+--------------------------------+-----------------------------------------+-----------------------------------------+----------------------+------------+
/// | 4 bits address (switch group) | 4 bits address (switch number) | 1 bit address (not used, so never mind) | 1 bit address (not used, so never mind) | 2 data bits (on|off) | 1 sync bit |
/// | 1=0FFF 2=F0FF 3=FF0F 4=FFF0 | 1=0FFF 2=F0FF 3=FF0F 4=FFF0 | F | F | on=FF off=F0 | S |
/// +-------------------------------+--------------------------------+-----------------------------------------+-----------------------------------------+----------------------+------------+
/// <br/>
/// </summary>
/// <param name="address">
/// The switch group (address).
/// </param>
/// <param name="chan">
/// The channel (switch) to manipulate.
/// </param>
/// <param name="status">
/// Whether to switch on (true) or off (false).
/// </param>
/// <returns>
/// a single-character array containing only a null-character.
/// </returns>
private String GetCodeWordB(AddressCode address, ChannelCode chan, Boolean status) {
Int32 returnPos = 0;
char[] word = new char[13];
String[] code = new String[5] { "FFFF", "0FFF", "F0FF", "FF0F", "FFF0" };
if (((Int32)address < 1) || ((Int32)address > 4) ||
((Int32)chan < 1) || ((Int32)chan > 4)) {
return new String(new char[1] { '\0' });
}
for (Int32 i = 0; i < 4; i++) {
word[returnPos++] = code[(Int32)address][i];
}
for (Int32 j = 0; j < 4; j++) {
word[returnPos++] = code[(Int32)chan][j];
}
word[returnPos++] = 'F';
word[returnPos++] = 'F';
word[returnPos++] = 'F';
if (status) {
word[returnPos++] = 'F';
}
else {
word[returnPos++] = '0';
}
word[returnPos] = '\0';
return new String(word);
}
