//// Translators
public async Task <string> AddAddress(string args, PublicIdentity client)
{
var request = API.Import <Tuple <string, AddressInfo> >(args);
await api.AddAddress(request, client);
return("");
}
public async Task <string> GetAddresses(string args, PublicIdentity client)
{
var request = API.Import <List <string> >(args);
var response = await api.GetAddresses(request, client);
return(API.Export(response));
}
public async Task <GetImageResponse> Get(string hash, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.NotBlocked);
var p = await conn.GetAsync <Image>(hash);
return(p.ToResponse());
}
public async Task <GetPostResponse> Get(string id, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.NotBlocked);
var post = await conn.GetAsync <Post>(id);
return(post.ToResponse());
}
public async Task <string> Add(AddImageRequest request, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Self);
var resource = Image.FromAddRequest(request);
await conn.InsertOrReplaceAsync(resource);
return(resource.Hash);
}
public async Task <List <PostInfo> > GetList(DateTimeOffset start, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Friend);
var posts = await conn.Table <Post>().Where(x => start < x.TimePosted).ToListAsync();
return(posts.Select(x => new PostInfo {
ID = x.ID, TimePosted = x.TimePosted
}).ToList());
}
public async Task <string> GetProfile(string args, PublicIdentity client)
{
if (args != "")
{
throw new RPException("Arguments were formatted incorrectly!");
}
var response = await api.GetProfile(client);
return(API.Export(response));
}
public async Task RemovePost(string id, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Self);
var num = await conn.DeleteAsync <Post>(id);
if (num == 0)
{
throw new APIException("Image could not be found!");
}
}
public async Task <string> InformAddress(string args, PublicIdentity client, IPEndPoint address)
{
var port = API.Import <int>(args);
if (port == -1)
{
port = address.Port;
}
await api.InformAddress(port, address.Address, client);
return("");
}
public async Task <string> Add(AddPostRequest request, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Self);
var post = Post.FromAddRequest(request);
var num = await conn.InsertAsync(post);
if (num == 0)
{
throw new APIException("Image could not be found!");
}
return(post.ID);
}
public async Task <string> AddPost(string args, PublicIdentity client)
{
AddPostRequest r;
try
{
r = API.Import <AddPostRequest>(args);
}
catch
{
throw new RPException("Arguments were formatted incorrectly!");
}
return(await api.AddPost(r, client));
}
public async Task AuthenticateValid()
{
var serverPrivID = PrivateIdentity.Create();
var serverPubID = new PublicIdentity(serverPrivID.PublicIdentityInfo);
var clientPrivID = PrivateIdentity.Create();
var serverAuthenticator = new Authenticator(serverPrivID);
var clientAuthenticator = new Authenticator(clientPrivID);
var a = serverAuthenticator.AuthenticateClient(protected1);
var b = clientAuthenticator.AuthenticateServer(protected2, serverPubID.ID);
await Task.WhenAll(a, b);
}
public async Task <string> SetProfile(string args, PublicIdentity client)
{
SetProfileRequest r;
try
{
r = API.Import <SetProfileRequest>(args);
}
catch
{
throw new RPException("Arguments were formatted incorrectly!");
}
await api.SetProfile(r, client);
return("");
}
public async Task <string> GetPostList(string args, PublicIdentity client)
{
DateTimeOffset start;
try
{
start = API.Import <DateTimeOffset>(args);
}
catch
{
throw new RPException("Arguments were formatted incorrectly!");
}
var response = await api.GetPostList(start, client);
return(API.Export(response));
}
public async Task <string> SetFriend(string args, PublicIdentity client)
{
FriendInfo info;
try
{
info = API.Import <FriendInfo>(args);
}
catch
{
throw new RPException("Arguments were formatted incorrectly!");
}
await api.SetFriend(info, client);
return("");
}
public async Task <List <ImageInfo> > GetList(PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Self);
var images = await conn.Table <Image>().ToListAsync();
List <ImageInfo> info = new();
foreach (var image in images)
{
info.Add(new ImageInfo
{
Hash = image.Hash,
LastUpdated = image.LastUpdated
});
}
return(info);
}
public async Task Set(SetProfileRequest r, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Self);
if (r.Name.Length > 18)
{
throw new APIException($"Name used {r.Name.Length}/18 characters.");
}
if (r.Tagline.Length > 30)
{
throw new APIException($"Tagline used {r.Tagline.Length}/30 characters.");
}
if (r.Bio.Length > 400)
{
throw new APIException($"Bio used {r.Bio.Length}/400 characters.");
}
await conn.InsertOrReplaceAsync(Profile.FromSetRequest(r, users.Self));
}
private void SenderThread()
{
Random rng = new Random();
while (true)
{
int serverIndex = rng.Next(serviceIdentity.Servers.Count);
PublicIdentity serverIdentity = serviceIdentity.Servers[serverIndex];
byte[] serverPublicKey = serverIdentity.PublicKey;
int randomNumber = rng.Next(10000);
string message = string.Format("Hello {0}", randomNumber);
byte[] messageBytes = Encoding.UTF8.GetBytes(message);
Console.WriteLine("Sending message {0} to {1}", message, IoScheduler.PublicKeyToString(serverPublicKey));
scheduler.SendPacket(serverPublicKey, messageBytes);
Thread.Sleep(1000);
}
}
public async Task <GetProfileResponse> Get(PublicIdentity _)
{
var p = await conn.GetAsync <Profile>(users.Self);
return(p.ToResponse());
}
public async Task <string> RemovePost(string args, PublicIdentity client)
{
await api.RemovePost(args, client);
return("");
}
public async Task <string> GetPost(string args, PublicIdentity client)
{
var response = await api.GetPost(args, client);
return(API.Export(response));
}
public async Task InformAddress(int port, IPAddress address, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Friend);
await AddAddress(client.ID, address, port, false);
}
public IdentityTester()
{
privateIdentity = PrivateIdentity.Create();
publicIdentity = new PublicIdentity(privateIdentity.PublicIdentityInfo);
}
public async Task AddAddress(string user, IPAddress address, int port, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Self);
await AddAddress(user, address, port, true);
}
public async Task <string> GetImageList(PublicIdentity client)
{
var response = await api.GetImageList(client);
return(API.Export(response));
}
public async Task <Dictionary <string, AddressInfo> > GetAddresses(List <string> requested, PublicIdentity client)
{
await users.Authenticate(client, User.Auth.Friend);
var addresses = await conn.Table <Address>().ToListAsync();
var response = new Dictionary <string, AddressInfo>();
foreach (var address in addresses)
{
if (!requested.Contains(address.UserID))
{
continue;
}
response[address.UserID] = new AddressInfo
{
IP = address.IP,
Port = address.Port
};
}
return(response);
}
