[Test] public void Assoc()
{
var w = new Whatsit();
Assert.Equal(EType.A, Assoc <Whatsit, EType> .Get(x => x.Distance));
Assert.Equal(EType.C, Assoc <Whatsit, EType> .Get(x => x.Speed));
Assert.Equal(5, Assoc <Whatsit, int> .Get(x => x.Distance));
Assert.Equal(0.001, Assoc <Whatsit, double> .Get(x => x.Speed));
// Enum members with the same value still have unique associated values
Assert.Equal(EType.A.Assoc <int>("#"), 1);
Assert.Equal(EType.B.Assoc <int>("#"), 2);
Assert.Equal(EType.C.Assoc <int>("#"), 3);
// Literal or variable works
var e = EType.B;
Assert.Equal(EType.A.Assoc <int>("#"), 1);
Assert.Equal(e.Assoc <int>("#"), 2);
// Associated reflected type
Assert.Equal(Color.Red, EType2.R.Assoc <Color>());
Assert.Equal(Color.Green, EType2.G.Assoc <Color>());
Assert.Equal(Color.Blue, EType2.B.Assoc <Color>());
}
internal InfixOp(Assoc assoc, Parser <Func <A, A, A> > p)
:
base(OperatorTag.Infix)
{
Assoc = assoc;
Op = p;
}
void PrecedenceAndAssoc(Token token, int precedence, Assoc assoc)
{
for (; token != null; token = lexer.next_token())
{
if (token.type == TokenType.DOT)
{
break;
}
else if (token.type == TokenType.ID && char.IsUpper(token.text[0]))
{//首字符大写，视为终结符
Symbol symbol = lemon.AddSymbol(token.text);
if (symbol.prec >= 0)
{
Error(token, "Symbol has already be given a precedence.");
}
else
{
symbol.prec = precedence;
symbol.assoc = assoc;
}
}
else
{
Error(token, "This TokenType must be ID and first char is upper case");
}
}
}
internal InfixOp(Assoc assoc, Parser <I, Func <O, O, O> > p)
:
base(OperatorTag.Infix)
{
Assoc = assoc;
Op = p;
}
public Op(string op, int precedence, Assoc assoc, Arity arity)
{
this.op = op;
this.prec = precedence;
this.assoc = assoc;
this.arity = arity;
}
public Infix(string name, Parser <Func <A, A, A> > parser, Assoc assoc)
:
base(OperatorType.Infix, name)
{
Parser = parser;
Assoc = assoc;
}
internal InfixOpIO(Assoc assoc, Parser <char, Func <T, T, T> > p)
:
base(OperatorTag.Infix)
{
Assoc = assoc;
Op = p;
}
/// <summary>
/// This is the main routine called from TCP layer for handling DICOM data
/// </summary>
/// <param name="state"></param>
/// <param name="direction"></param>
public void ReceiveTCPData(TCPState state, int direction)
{
byte[] p = state.data[direction];
int length = (int)state.Position[direction];
uint Position = 0;
Association Assoc = (Association)state.UserInfo;
bool TryAnotherPDU = true;
while (length >= Position + 6 && TryAnotherPDU)
{
TryAnotherPDU = false;
byte PDUType = p[Position];
uint Index = Position + 2;
uint PDULength = DICOMUtility.Get4BytesBigEndian(p, ref Index);
if (Assoc == null && PDUType == 1)
{
Assoc = new Association(state, BaseFileName + state.Signature[0], System.DateTime.Now);
Assoc.Output += new Association.OutputEvent(OutputHandler);
state.UserInfo = Assoc;
string signature = state.Signature[0];
list.Add(signature, Assoc);
OutputHandler("New : " + signature + "\r\n", true, true);
// snifferObj.Invoke(snifferObj.AddConnectionHandler, new object[] { signature });
}
if (Assoc != null && length >= Index + PDULength)
{
lock (Assoc)
{
Assoc.HandlePDU(p, Position, PDULength, direction, state);
TryAnotherPDU = true;
}
}
else if (length > 64000 && Assoc == null) // non-DICOM
{
OutputHandler("Non-DICOM data : " + state.Signature[0] + "\r\n", true, true);
break; // don't process any more if we have a currently unhandleable PDU
}
else
{
break; // don't prcess any more if we have a currently unhandleable PDU
}
Position += PDULength + 6;
}
if (Position > 0)
{
if (state.data[direction] != null)
{
state.UsedData(Position, direction);
}
// Check if there is anything we have "stacked up" on the other direction
ReceiveTCPData(state, 1 - direction);
}
return;
}
/// <summary>
/// For operators with a description
/// </summary>
/// <param name="assoc"></param>
/// <param name="weight"></param>
/// <param name="arguments"></param>
/// <param name="compute"></param>
/// <param name="description"></param>
public Operator(Assoc assoc, int weight, int arguments, RPN.Run compute, Description description)
{
Weight = weight;
Arguments = arguments;
Assoc = assoc;
Compute = compute;
Description = description;
}
public IActionResult Leave(int activityId)
{
User userInDb = GetUserInDb();
if (userInDb != null)
{
Assoc leaving = dbContext.Assocs.FirstOrDefault(a => a.UserId == userInDb.UserId && a.ActivyId == activityId);
dbContext.Assocs.Remove(leaving);
dbContext.SaveChanges();
return(RedirectToAction("Dashboard"));
}
else
{
return(RedirectToAction("Logout"));
}
}
public IActionResult Join(int activityId)
{
User userInDb = GetUserInDb();
if (userInDb != null)
{
Assoc joigning = new Assoc();
joigning.UserId = userInDb.UserId;
joigning.ActivyId = activityId;
dbContext.Assocs.Add(joigning);
dbContext.SaveChanges();
return(RedirectToAction("Dashboard"));
}
else
{
return(RedirectToAction("Logout"));
}
}
public static Operator <I, O> Infix <I, O>(Assoc assoc, Parser <I, Func <O, O, O> > p) => new InfixOp <I, O>(assoc, p);
public static async Task CommandDispatcherMethod(TelegramBotAbstract sender, MessageEventArgs e)
{
var cmdLines = e.Message.Text.Split(' ');
var cmd = cmdLines[0];
switch (cmd)
{
case "/start":
{
await Start(sender, e);
return;
}
case "/force_check_invite_links":
{
if (GlobalVariables.Creators.Contains(e.Message.Chat.Id))
{
_ = ForceCheckInviteLinksAsync(sender, e);
}
else
{
await DefaultCommand(sender, e);
}
return;
}
case "/contact":
{
await ContactUs(sender, e);
return;
}
case "/help":
{
await Help(sender, e);
return;
}
case "/banAll":
{
if (GlobalVariables.Creators.Contains(e.Message.From.Id))
{
_ = BanAllAsync(sender, e, cmdLines, e.Message.From.LanguageCode, e.Message.From.Username);
}
else
{
await DefaultCommand(sender, e);
}
return;
}
case "/ban":
{
_ = BanUserAsync(sender, e, cmdLines);
return;
}
case "/unbanAll":
{
if (GlobalVariables.Creators.Contains(e.Message.From.Id))
{
_ = UnbanAllAsync(sender, e, cmdLines[1]);
}
else
{
await DefaultCommand(sender, e);
}
return;
}
case "/getGroups":
{
if (GlobalVariables.Creators.Contains(e.Message.From.Id) && e.Message.Chat.Type == ChatType.Private)
{
string username = null;
if (!string.IsNullOrEmpty(e.Message.From.Username))
{
username = e.Message.From.Username;
}
_ = GetAllGroups(e.Message.From.Id, username, sender, e.Message.From.LanguageCode);
return;
}
await DefaultCommand(sender, e);
return;
}
case "/time":
{
var lang = new Language(new Dictionary <string, string>
{
{ "", DateTimeClass.NowAsStringAmericanFormat() }
});
await SendMessage.SendMessageInPrivate(sender, e, lang);
return;
}
case "/assoc_send":
{
_ = Assoc.Assoc_SendAsync(sender, e);
return;
}
default:
{
await DefaultCommand(sender, e);
return;
}
}
}
public static async Task CommandDispatcherMethod(TelegramBotAbstract sender, MessageEventArgs e)
{
var cmdLines = e.Message.Text.Split(' ');
var cmd = cmdLines[0].Trim();
if (cmd.Contains("@"))
{
var cmd2 = cmd.Split("@");
var botUsername = await sender.GetBotUsernameAsync();
if (cmd2[1].ToLower() != botUsername.ToLower())
{
return;
}
}
switch (cmd)
{
case "/start":
{
await Start(sender, e);
return;
}
case "/force_check_invite_links":
{
if (GlobalVariables.Creators.Contains(e.Message?.Chat?.Username?.ToLower()))
{
_ = ForceCheckInviteLinksAsync(sender, e);
}
else
{
await DefaultCommand(sender, e);
}
return;
}
case "/contact":
{
await ContactUs(sender, e);
return;
}
case "/help":
{
await Help(sender, e);
return;
}
case "/muteAll":
{
if (e.Message.Chat.Type != ChatType.Private)
{
await CommandNotSentInPrivateAsync(sender, e);
return;
}
if (GlobalVariables.AllowedMuteAll.Contains(e.Message.From?.Username?.ToLower()))
{
_ = MuteAllAsync(sender, e, cmdLines, e.Message.From.LanguageCode, e.Message.From.Username);
}
else
{
await DefaultCommand(sender, e);
}
return;
}
case "/banAll":
{
if (e.Message.Chat.Type != ChatType.Private)
{
await CommandNotSentInPrivateAsync(sender, e);
return;
}
if (GlobalVariables.AllowedBanAll.Contains(e.Message.From?.Username?.ToLower()))
{
_ = BanAllAsync(sender, e, cmdLines, e.Message.From.LanguageCode, e.Message.From.Username);
}
else
{
await DefaultCommand(sender, e);
}
return;
}
/*
* case "/massiveSend":
* {
* if (e.Message.Chat.Type != ChatType.Private)
* {
* await CommandNotSentInPrivateAsync(sender, e);
* return;
* }
*
* try
* {
* if (GlobalVariables.AllowedBanAll.Contains(e.Message.From?.Username?.ToLower()))
* _ = MassiveSendAsync(sender, e, cmdLines, e.Message.From.LanguageCode, e.Message.From.Username);
* else
* await DefaultCommand(sender, e);
* }
* catch
* {
* ;
* }
*
* return;
* }
*/
case "/ban":
{
_ = BanUserAsync(sender, e, cmdLines);
return;
}
case "/banAllHistory":
{
// _ = BanUserAsync(sender, e, cmdLines);
_ = BanUserHistoryAsync(sender, e);
return;
}
case "/unbanAll":
{
if (e.Message.Chat.Type != ChatType.Private)
{
await CommandNotSentInPrivateAsync(sender, e);
return;
}
if (GlobalVariables.AllowedBanAll.Contains(e.Message.From?.Username?.ToLower()))
{
_ = UnbanAllAsync(sender, e, cmdLines, e.Message.From.LanguageCode, e.Message.From.Username);
}
else
{
await DefaultCommand(sender, e);
}
return;
}
case "/test_spam":
{
if (e.Message == null)
{
return;
}
if (e.Message.ReplyToMessage == null)
{
return;
}
await TestSpamAsync(e.Message.ReplyToMessage, sender, e);
return;
}
case "/groups":
{
await SendRecommendedGroupsAsync(sender, e);
return;
}
case "/getGroups":
{
if ((GlobalVariables.Creators.Contains(e.Message.From.Username) ||
Owners.CheckIfOwner(e.Message.From.Id)) &&
e.Message.Chat.Type == ChatType.Private)
{
string username = null;
if (!string.IsNullOrEmpty(e.Message.From.Username))
{
username = e.Message.From.Username;
}
_ = GetAllGroups(e.Message.From.Id, username, sender, e.Message.From.LanguageCode);
return;
}
await DefaultCommand(sender, e);
return;
}
case "/allowmessage":
{
if ((Owners.CheckIfOwner(e.Message.From.Id)) &&
e.Message.Chat.Type == ChatType.Private)
{
if (e.Message.ReplyToMessage == null || string.IsNullOrEmpty(e.Message.ReplyToMessage.Text))
{
var text = new Language(new Dictionary <string, string>
{
{ "en", "You have to reply to a message containing the message" }
});
await sender.SendTextMessageAsync(e.Message.From.Id, text, ChatType.Private,
e.Message.From.LanguageCode, ParseMode.Html, null, e.Message.From.Username,
e.Message.MessageId);
return;
}
AllowedMessages.AddMessage(e.Message.ReplyToMessage.Text);
return;
}
await DefaultCommand(sender, e);
return;
}
case "/unallowmessage":
{
if ((Owners.CheckIfOwner(e.Message.From.Id)) &&
e.Message.Chat.Type == ChatType.Private)
{
if (e.Message.ReplyToMessage == null || string.IsNullOrEmpty(e.Message.ReplyToMessage.Text))
{
var text = new Language(new Dictionary <string, string>
{
{ "en", "You have to reply to a message containing the message" }
});
await sender.SendTextMessageAsync(e.Message.From.Id, text, ChatType.Private,
e.Message.From.LanguageCode, ParseMode.Html, null, e.Message.From.Username,
e.Message.MessageId);
return;
}
AllowedMessages.removeMessage(e.Message.ReplyToMessage.Text);
return;
}
await DefaultCommand(sender, e);
return;
}
case "/updateGroups":
{
if ((GlobalVariables.Creators.Contains(e.Message.From.Username) ||
Owners.CheckIfOwner(e.Message.From.Id)) &&
e.Message.Chat.Type == ChatType.Private)
{
//System.Data.DataTable groups = Groups.GetAllGroups();
//var jsonFile = JObject.Parse(groups.ToString());
if (Variabili.L == null)
{
Variabili.L = new ListaGruppo();
}
Variabili.L.ImportaGruppiDaTabellaTelegramGruppiBot_PuntoBin();
var json =
JsonBuilder.getJson(new CheckGruppo(CheckGruppo.E.RICERCA_SITO_V3),
false);
}
await DefaultCommand(sender, e);
return;
}
case "/testtime":
{
if (e.Message.Chat.Type == ChatType.Private)
{
await TestTime(sender, e);
}
return;
}
case "/time":
{
var lang = new Language(new Dictionary <string, string>
{
{ "", DateTimeClass.NowAsStringAmericanFormat() }
});
await SendMessage.SendMessageInPrivate(sender, e.Message.From.Id,
usernameToSendTo : e.Message.From.Username, langCode : e.Message.From.LanguageCode,
text : lang, parseMode : ParseMode.Default, messageIdToReplyTo : null);
return;
}
case "/assoc_write":
case "/assoc_send":
{
_ = await Assoc.Assoc_SendAsync(sender, e);
return;
}
case "/assoc_publish":
{
if (Owners.CheckIfOwner(e.Message.From.Id))
{
_ = await Assoc.Assoc_Publish(sender, e);
}
else
{
_ = await DefaultCommand(sender, e);
}
return;
}
case "/assoc_read":
{
_ = await Assoc.Assoc_Read(sender, e, false);
return;
}
case "/assoc_read_all":
{
if (Owners.CheckIfOwner(e.Message.From.Id))
{
_ = await Assoc.Assoc_ReadAll(sender, e);
}
else
{
_ = await DefaultCommand(sender, e);
}
return;
}
case "/assoc_delete":
case "/assoc_remove":
{
_ = await Assoc.Assoc_Delete(sender, e);
return;
}
case "/rooms":
{
await Rooms.RoomsMainAsync(sender, e);
return;
}
case "/rules":
{
_ = await Rules(sender, e);
return;
}
case "/qe":
{
_ = await QueryBot(true, e, sender);
return;
}
case "/qs":
{
_ = await QueryBot(false, e, sender);
return;
}
case "/update_links_from_json":
{
await InviteLinks.UpdateLinksFromJsonAsync(sender, e);
return;
}
default:
{
await DefaultCommand(sender, e);
return;
}
}
}
public static Operator <A> Infix <A>(Assoc assoc, Parser <Func <A, A, A> > p) => new InfixOp <A>(assoc, p);
public static OperatorIO <T> Infix <T>(Assoc assoc, Parser <char, Func <T, T, T> > p) => new InfixOpIO <T>(assoc, p);
public void AddToAssocs(Assoc assoc)
{
base.AddObject("Assocs", assoc);
}
public static Assoc CreateAssoc(long order, long sourceId, long destinationId, long ID, global::System.Guid tid, string name, long createdById, long modifiedById, global::System.DateTimeOffset created, global::System.DateTimeOffset modified)
{
Assoc assoc = new Assoc();
assoc.Order = order;
assoc.SourceId = sourceId;
assoc.DestinationId = destinationId;
assoc.Id = ID;
assoc.Tid = tid;
assoc.Name = name;
assoc.CreatedById = createdById;
assoc.ModifiedById = modifiedById;
assoc.Created = created;
assoc.Modified = modified;
return assoc;
}
public static Operator <T> Infix <T>(Assoc assoc, Parser <Func <T, T, T> > p) => new InfixOp <T>(assoc, p);
