public static bool SendMessageParams(OutlookContext context, Message msg, int id, string email, Dictionary <string, int> addresses)
{
foreach (string user in addresses.Keys)
{
if (user.Length == 0)
{
continue;
}
if (user.Equals(email))
{
continue;
}
List <User> dest = context.Users.Where(x => x.EmailAddress.Equals(user)).ToList();
int DestId = dest[0].Id;
if (context.MessageReceivers.Where(x => x.MessageId == msg.Id && x.UserId == DestId).ToList().Count == 0)
{
MessageReceiver msgrec = new MessageReceiver();
msgrec.MessageId = msg.Id;
msgrec.UserId = DestId;
msgrec.ReceiveType = addresses[user];
msgrec.Read = false;
context.MessageReceivers.Add(msgrec);
}
}
return(true);
}
public CategoriesController(
IMapper mapper,
OutlookContext context)
{
this.mapper = mapper;
this.context = context;
}
public ValidationResult Validate(OutlookContext context, int id, string email)
{
Addresses.Clear();
if (CC.Length == 0 && BCC.Length == 0 && Direct.Length == 0)
{
return(new ValidationResult("Error: No addresses provided!"));
}
string[] CCs = CC.Split(';');
string[] BCCs = BCC.Split(';');
string[] Directs = Direct.Split(';');
(bool dis1, ValidationResult v1) = CheckExistence(context, id, email, Directs, "Error in direct", 0);
if (v1 != ValidationResult.Success)
{
return(v1);
}
(bool dis2, ValidationResult v2) = CheckExistence(context, id, email, CCs, "Error in CCs", 1);
if (v2 != ValidationResult.Success)
{
return(v2);
}
(bool dis3, ValidationResult v3) = CheckExistence(context, id, email, BCCs, "Error in BCCs", 2);
if (v3 != ValidationResult.Success)
{
return(v3);
}
return(ValidationResult.Success);
}
public void Group()
{
var options = new DbContextOptionsBuilder <OutlookContext>()
.UseInMemoryDatabase(databaseName: "NetOutlookDatabaseMock")
.Options;
ValidationResult testResult;
using (var context = new OutlookContext(options))
{
ClearContext(context);
context.Users.Add(new User {
Name = "Adam", Surname = "Kowalski", EmailAddress = "*****@*****.**"
});
context.Users.Add(new User {
Name = "Jurgen", Surname = "Kowalski", EmailAddress = "*****@*****.**"
});
context.Users.Add(new User {
Name = "Janusz", Surname = "Kowalski", EmailAddress = "*****@*****.**"
});
context.Groups.Add(new Group {
GroupName = "Kowalscy", OwnerId = 2
});
context.GroupMembers.Add(new GroupMember {
GroupId = 1, UserId = 1
});
context.SaveChanges();
NewMessageModel model = new NewMessageModel();
model.Direct = "g:Kowalscy;[email protected]";
model.CC = "";
model.BCC = "";
testResult = model.Validate(context, 2, "*****@*****.**");
}
Assert.AreEqual(testResult, ValidationResult.Success);
}
public void InvalidAddresses()
{
var options = new DbContextOptionsBuilder <OutlookContext>()
.UseInMemoryDatabase(databaseName: "NetOutlookDatabaseMock")
.Options;
ValidationResult testResult;
using (var context = new OutlookContext(options))
{
ClearContext(context);
context.Users.Add(new User {
Name = "Adam", Surname = "Kowalski", EmailAddress = "*****@*****.**"
});
context.Users.Add(new User {
Name = "Jurgen", Surname = "Kowalski", EmailAddress = "*****@*****.**"
});
context.SaveChanges();
NewMessageModel model = new NewMessageModel();
model.Direct = "[email protected];;;a;;";
model.CC = "";
model.BCC = "";
testResult = model.Validate(context, 2, "*****@*****.**");
}
Assert.AreNotEqual(testResult, ValidationResult.Success);
}
public ValidationResult Validate(OutlookContext context, int id, string email)
{
Addresses.Clear();
if (Emails.Length == 0)
{
return(new ValidationResult("Error: No addresses provided!"));
}
if (GroupName.Length == 0)
{
return(new ValidationResult("Error: No Group Name provided!"));
}
if (GroupName.StartsWith("g:"))
{
return(new ValidationResult("Error: Invalid Group Name, start with 'g:' is not allowed"));
}
if (GroupName.Contains(";"))
{
return(new ValidationResult("Error: Invalid Group Name, using ';' is not allowed"));
}
if (context.Groups.Where(g => g.GroupName == GroupName && g.OwnerId == id).ToList().Count > 0)
{
return(new ValidationResult("Error: Invalid Group Name, you have already group with the same name"));
}
string[] EmailsTab = Emails.Split(';');
(bool dis1, ValidationResult v1) = CheckExistence(context, id, email, EmailsTab, "Error in group members", 0);
if (v1 != ValidationResult.Success)
{
return(v1);
}
return(ValidationResult.Success);
}
public IssuesController(
OutlookContext context,
IMapper mapper)
{
this.context = context;
this.mapper = mapper;
}
public void ClearContext(OutlookContext context)
{
context.GroupMembers.RemoveRange(context.GroupMembers);
context.MessageReceivers.RemoveRange(context.MessageReceivers);
context.Users.RemoveRange(context.Users);
context.Groups.RemoveRange(context.Groups);
context.Messages.RemoveRange(context.Messages);
context.SaveChanges();
}
protected (bool, ValidationResult) CheckExistence(OutlookContext context, int id, string email, string[] addresses, string err_prefix, int send_type)
{
bool distinct = false;
foreach (string user in addresses)
{
if (user.Length == 0)
{
continue;
}
if (user.Equals(email))
{
continue;
}
if (user.StartsWith("g:"))
{
string group = user.Substring(2);
Group g = context.Groups.FirstOrDefault(x => (x.GroupName == group && x.OwnerId == id));
if (g == null)
{
return(false, new ValidationResult($"{err_prefix}: Group {group} doesn't exist!"));
}
List <string> members = context.GetUsersFromGroup(g.Id);
foreach (string member in members)
{
Debug.WriteLine(member);
if (Addresses.ContainsKey(member))
{
if (Addresses[member] != send_type)
{
return(false, new ValidationResult($"{err_prefix}: User {member} from {group} has multiple delivery rules. Remove unnecesary rules!"));
}
}
Addresses[member] = send_type;
}
distinct = true;
}
else
{
User u = context.Users.FirstOrDefault(x => x.EmailAddress == user);
if (u == null)
{
return(false, new ValidationResult($"{err_prefix}: User {user} doesn't exist!"));
}
if (Addresses.ContainsKey(user))
{
if (Addresses[user] != send_type)
{
return(false, new ValidationResult($"{err_prefix}: User {user} has multiple delivery rules. Remove unnecesary rules!"));
}
}
Addresses[user] = send_type;
distinct = true;
}
}
return(distinct, ValidationResult.Success);
}
public MembersController(
OutlookContext context,
MemberService memberService)
{
this.context = context;
this.memberService = memberService;
logger = Logger.Logger.Instance(Logger.Logger.LogField.server);
// Save the List of categories names to be accessed
Categories = context.Category.Select(c => c.Name).ToList();
}
public CommentsController(
OutlookContext context,
IdentityService identityService,
IMapper mapper,
IHubContext <ArticleHub, IArticleHub> articleHub)
{
this.context = context;
this.identityService = identityService;
this.mapper = mapper;
this.articleHub = articleHub;
logger = Logger.Logger.Instance(Logger.Logger.LogField.web);
}
public DataFactory(
OutlookContext context,
UserManager <OutlookUser> userManager,
SignInManager <OutlookUser> signInManager,
RoleManager <IdentityRole> roleManager,
IConfiguration configuration)
{
this.context = context;
this.userManager = userManager;
this.signInManager = signInManager;
this.roleManager = roleManager;
Configuration = configuration;
}
public AddUserModel(
UserManager <OutlookUser> userManager,
SignInManager <OutlookUser> signInManager,
ILogger <RegisterModel> logger,
IEmailSender emailSender,
OutlookContext context)
{
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
_emailSender = emailSender;
this.logger = Logger.Logger.Instance(Logger.Logger.LogField.server);
this.context = context;
}
public ArticlesController(
OutlookContext context,
IMapper mapper,
IdentityService identityService,
IHubContext <ArticleHub, IArticleHub> articlehub,
IWebHostEnvironment env, IConfiguration configuration)
{
this.context = context;
this.mapper = mapper;
this.identityService = identityService;
this.env = env;
this.configuration = configuration;
this.configuration = configuration;
hubContext = articlehub;
logger = Logger.Logger.Instance(Logger.Logger.LogField.userArticles);
}
protected (bool, ValidationResult) CheckExistence(OutlookContext context, int id, string email, string[] addresses, string err_prefix, int send_type)
{
char[] charsToTrim = { '\t', ' ', '\n' };
bool distinct = false;
foreach (string userT in addresses)
{
string user = userT.Trim(charsToTrim);
if (user.Length == 0)
{
continue;
}
if (user.Equals(email))
{
continue;
}
if (user.StartsWith("g:"))
{
//string group = user.Substring(2);
Group g = context.Groups.FirstOrDefault(x => (x.GroupName == user && x.OwnerId == id));
if (g == null)
{
return(false, new ValidationResult($"{err_prefix}: Group {user} doesn't exist!"));
}
Addresses.Add(user);
distinct = true;
}
else
{
User u = context.Users.FirstOrDefault(x => x.EmailAddress == user);
if (u == null)
{
return(false, new ValidationResult($"{err_prefix}: User {user} doesn't exist!"));
}
Addresses.Add(user);
distinct = true;
}
}
return(distinct, ValidationResult.Success);
}
public ArticlesController(
OutlookContext context,
IWebHostEnvironment env,
ArticleService articleService)
{
this.context = context;
this.env = env;
this.articleService = articleService;
logger = Logger.Logger.Instance(Logger.Logger.LogField.server);
// Save the List of wrtiers names to be accessed
Writers = context.Member
.Select(m => m.Name)
.ToList();
// Save the List of categories names to be accessed
Categories = context.Category
.Select(c => c.Name)
.ToList();
}
public IssuesController(OutlookContext context, IWebHostEnvironment env)
{
this.context = context;
this.env = env;
logger = Logger.Logger.Instance(Logger.Logger.LogField.server);
}
public HomeController(ILogger <HomeController> logger, OutlookContext context)
{
_logger = logger;
this.context = context;
}
public static List <GroupMember> GroupManagerParams(OutlookContext context, Group gr, int id, string email, HashSet <string> addresses)
{
HashSet <string> emailsToGroup = new HashSet <string>();
List <GroupMember> groupMembers = new List <GroupMember>();
foreach (string user in addresses)
{
if (user.Length == 0)
{
continue;
}
if (user.Equals(email))
{
continue;
}
if (!user.StartsWith("g:") && emailsToGroup.Add(user))
{
List <User> dest = context.Users.Where(x => x.EmailAddress.Equals(user)).ToList();
int DestId = dest[0].Id;
GroupMember grmem = new GroupMember();
grmem.GroupId = gr.Id;
grmem.UserId = DestId;
grmem.User = dest[0];
grmem.Group = gr;
groupMembers.Add(grmem);
context.GroupMembers.Add(grmem);
}
else
{
string group = user.Substring(2);
List <Group> dest = context.Groups.Where((x => x.GroupName.Equals(group) && x.OwnerId == id)).ToList();
List <GroupMember> receivers = dest[0].Members.ToList();
foreach (GroupMember gm in receivers)
{
if (gm.UserId == id)
{
continue;
}
if (!emailsToGroup.Add(gm.User.EmailAddress))
{
continue;
}
List <User> dest2 = context.Users.Where(x => x.Id == gm.UserId).ToList();
int DestId = dest2[0].Id;
GroupMember grmem = new GroupMember();
grmem.GroupId = gr.Id;
grmem.UserId = DestId;
grmem.User = dest2[0];
grmem.Group = gr;
groupMembers.Add(grmem);
context.GroupMembers.Add(grmem);
}
}
}
return(groupMembers);
}
public HomeController(OutlookContext context)
{
this.context = context;
}
public UsersController(ILogger <UsersController> logger, OutlookContext context)
{
this.logger = logger;
this.context = context;
}
public NewMessageController(ILogger <NewMessageController> logger, OutlookContext context)
{
_logger = logger;
this.context = context;
}
public GroupManagerController(ILogger <GroupManagerController> logger, OutlookContext context)
{
_logger = logger;
this.context = context;
}
public InboxController(ILogger <InboxController> logger, OutlookContext context)
{
_logger = logger;
this.context = context;
}
public ArticleService(OutlookContext context)
{
this.context = context;
}
public VolumesController(OutlookContext context)
{
this.context = context;
logger = Logger.Logger.Instance(Logger.Logger.LogField.server);
}
public AdminPageController(ILogger <AdminPageController> logger, OutlookContext context)
{
_logger = logger;
this.context = context;
}
