public async Task <IActionResult> UploadFile(Resources resources) { UploadFileRequest request = new UploadFileRequest(); request.FileName = resources.FileName; string fileName = Path.GetFileNameWithoutExtension(resources.ImagePath.FileName); string extension = Path.GetExtension(resources.ImagePath.FileName); // fileName = fileName + DateTime.Now.ToString("yymmssfff") + extension; fileName = fileName + extension; Console.WriteLine(fileName); var currentuser = context.User.SingleOrDefault(x => x.Email == User.Identity.Name); request.FilePath = "D:\\00\\" + fileName; resources.SubjectId = 1; resources.UserId = currentuser.Id; //upload file on azure await service.UploadFileBlobAsync(request.FilePath, request.FileName); //save file data in db context.Add(resources); await context.SaveChangesAsync(); return(RedirectToAction("ListResources", "Resources")); }
public async Task <IActionResult> EditProfile(int id, [Bind("Id,Email,Password,Name,Semester,Branch,Role")] User model) { if (id != model.Id) { return(View("NotFound")); } if (ModelState.IsValid) { try { context.Update(model); await context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserExists(model.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction("ViewProfile", "Profile")); } return(View(model)); }
public async void add([FromBody] AddFolderRequest request) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Devices) .Include(a => a.Folders) .Where(a => a.AccountId == request.AccountId) .FirstOrDefaultAsync(); if (account == null) { return; } foreach (var folder in request.Folders) { dbContext.Folders.Add(folder); account.Folders.Add(folder); //await FirebaseHelper.SendMessage(account, "added_folder", folder); } await dbContext.SaveChangesAsync(); } }
public async void add([FromBody] AddBlacklistRequest request) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Devices) .Include(a => a.Blacklists) .Where(a => a.AccountId == request.AccountId) .FirstOrDefaultAsync(); if (account == null) { return; } foreach (var blacklist in request.Blacklists) { dbContext.Blacklists.Add(blacklist); account.Blacklists.Add(blacklist); await FirebaseHelper.SendMessage(account, "added_blacklist", new { id = blacklist.DeviceId, phone_number = blacklist.PhoneNumber, phrase = blacklist.Phrase }); } await dbContext.SaveChangesAsync(); } }
public async void cleanup([FromQuery] string account_id, [FromQuery] long timestamp) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Messages) .Where(a => a.AccountId == account_id) .FirstOrDefaultAsync(); if (account == null) { return; } var messages = account.Messages.Where(m => m.Timestamp < timestamp).ToList(); foreach (var message in messages) { dbContext.Messages.Remove(message); account.Messages.Remove(message); } await FirebaseHelper.SendMessage(account, "cleanup_messages", new { timestamp }); await dbContext.SaveChangesAsync(); } }
public async void add([FromBody] AddContactRequest request) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Contacts) .Where(a => a.AccountId == request.AccountId) .FirstOrDefaultAsync(); if (account == null) { return; } foreach (var contact in request.Contacts) { dbContext.Contacts.Add(contact); account.Contacts.Add(contact); await FirebaseHelper.SendMessage(account, "added_contact", new { phone_number = contact.PhoneNumber, name = contact.Name, type = contact.ContactType, color = contact.Color, color_dark = contact.ColorDark, color_light = contact.ColorLight, color_accent = contact.ColorAccent }); } await dbContext.SaveChangesAsync(); } }
public async void update([FromQuery] string phone_number, [FromQuery] long device_id, [FromQuery] string account_id, [FromBody] UpdateContactRequest request) { using (var dbContext = new PulseDbContext()) { var(account, contact) = await GetContact(dbContext, device_id, account_id); if (contact == null) { return; } contact.PhoneNumber = request.PhoneNumber; contact.Name = request.Name; await FirebaseHelper.SendMessage(account, "updated_contact", new { device_id = device_id, phone_number = contact.PhoneNumber, name = contact.Name, type = contact.ContactType, color = contact.Color, color_dark = contact.ColorDark, color_light = contact.ColorLight, color_accent = contact.ColorAccent }); await dbContext.SaveChangesAsync(); } }
public async void update(long device_id, [FromQuery] string account_id, [FromBody] UpdateMessageRequest request) { using (var dbContext = new PulseDbContext()) { var(account, message) = await GetMessage(dbContext, device_id, account_id); if (message == null) { return; } message.MessageType = request.Type; message.Read = request.Read; message.Seen = request.Seen; message.Timestamp = request.Timestamp; await FirebaseHelper.SendMessage(account, "updated_message", new { id = message.DeviceId, type = message.MessageType, message.Read, message.Seen, timestamp = message.Timestamp }); await dbContext.SaveChangesAsync(); } }
public async void update(long device_id, [FromQuery] string account_id, [FromBody] UpdateScheduledMessageRequest request) { using (var dbContext = new PulseDbContext()) { var(account, message) = await GetScheduledMessage(dbContext, device_id, account_id); if (message == null) { return; } message.To = request.To; message.Data = request.Data; message.MimeType = request.MimeType; message.Timestamp = request.Timestamp; message.Title = request.Title; message.Repeat = request.Repeat; await FirebaseHelper.SendMessage(account, "updated_scheduled_message", new { id = message.DeviceId, to = message.To, data = message.Data, mimeType = message.MimeType, timestamp = message.Timestamp, title = message.Title, repeat = message.Repeat }); await dbContext.SaveChangesAsync(); } }
public async Task <IActionResult> Create(Course course) { if (course == null) { ViewBag.ErrorMessage = "Please Try Again."; return(View("NotFound")); } if (ModelState.IsValid) { context.Add(course); await context.SaveChangesAsync(); return(RedirectToAction("ListCourses")); } return(View()); }
public async void remove(long device_id, [FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Blacklists) .Where(a => a.AccountId == account_id) .FirstOrDefaultAsync(); if (account == null) { return; } var blacklist = account.Blacklists.Where(c => c.DeviceId == device_id).FirstOrDefault(); if (blacklist == null) { return; } await FirebaseHelper.SendMessage(account, "removed_blacklist", new { id = device_id }); dbContext.Blacklists.Add(blacklist); account.Blacklists.Add(blacklist); await dbContext.SaveChangesAsync(); } }
public async void add([FromBody] AddTemplateRequest request) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Templates) .Where(a => a.AccountId == request.AccountId) .FirstOrDefaultAsync(); if (account == null) { return; } foreach (var template in request.Templates) { dbContext.Templates.Add(template); account.Templates.Add(template); //await FirebaseHelper.SendMessage(account, "added_template", template); } await dbContext.SaveChangesAsync(); } }
public async void update(long device_id, [FromQuery] string account_id, [FromBody] UpdateDraftRequest request) { using (var dbContext = new PulseDbContext()) { var(account, draft) = await GetDraft(dbContext, device_id, account_id); if (draft == null) { return; } draft.Data = request.Data; draft.MimeType = request.MimeType; await FirebaseHelper.SendMessage(account, "replaced_drafts", new { id = draft.DeviceId, conversation_id = draft.DeviceConversationId, data = draft.Data, mime_type = draft.MimeType }); await dbContext.SaveChangesAsync(); } }
public async void add([FromBody] AddDraftRequest request) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Drafts) .Where(a => a.AccountId == request.AccountId) .FirstOrDefaultAsync(); if (account == null) { return; } foreach (var draft in request.Drafts) { dbContext.Drafts.Add(draft); account.Drafts.Add(draft); await FirebaseHelper.SendMessage(account, "added_draft", new { id = draft.DeviceId, conversation_id = draft.DeviceConversationId, data = draft.Data, mime_type = draft.MimeType }); } await dbContext.SaveChangesAsync(); } }
public async void update(long device_id, [FromQuery] string account_id, [FromBody] UpdateAutoReplyRequest request) { using (var dbContext = new PulseDbContext()) { var(account, autoReply) = await GetAutoReply(dbContext, device_id, account_id); if (autoReply == null) { return; } autoReply.ReplyType = request.Type; autoReply.Pattern = request.Pattern; autoReply.Response = request.Response; await FirebaseHelper.SendMessage(account, "added_auto_reply", new { device_id = autoReply.DeviceId, type = autoReply.ReplyType, pattern = autoReply.Pattern, response = autoReply.Response }); await dbContext.SaveChangesAsync(); } }
public async void add([FromBody] AddAutoReplyRequest request) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.AutoReplies) .Where(a => a.AccountId == request.AccountId) .FirstOrDefaultAsync(); if (account == null) { return; } foreach (var autoReply in request.AutoReplies) { dbContext.AutoReplies.Add(autoReply); account.AutoReplies.Add(autoReply); await FirebaseHelper.SendMessage(account, "added_auto_reply", new { device_id = autoReply.DeviceId, type = autoReply.ReplyType, pattern = autoReply.Pattern, response = autoReply.Response }); } await dbContext.SaveChangesAsync(); } }
public async void add([FromBody] AddScheduledMessageRequest request) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.ScheduledMessages) .Where(a => a.AccountId == request.AccountId) .FirstOrDefaultAsync(); if (account == null) { return; } foreach (var message in request.ScheduledMessages) { dbContext.ScheduledMessages.Add(message); account.ScheduledMessages.Add(message); await FirebaseHelper.SendMessage(account, "added_scheduled_message", new { id = message.DeviceId, to = message.To, data = message.Data, mimeType = message.MimeType, timestamp = message.Timestamp, title = message.Title, repeat = message.Repeat }); } await dbContext.SaveChangesAsync(); } }
public async void removeFromFolder(long device_id, [FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var(_, conversation) = await GetConversation(dbContext, device_id, account_id); if (conversation == null) { return; } conversation.FolderId = -1L; await dbContext.SaveChangesAsync(); } }
public async void unarchive(long device_id, [FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var(_, conversation) = await GetConversation(dbContext, device_id, account_id); if (conversation == null) { return; } conversation.Archive = false; await dbContext.SaveChangesAsync(); } }
public async void update(long device_id, [FromQuery] string account_id, [FromBody] UpdateConversationRequest request) { using (var dbContext = new PulseDbContext()) { var(_, conversation) = await GetConversation(dbContext, device_id, account_id); if (conversation == null) { return; } request.CloneTo(conversation); await dbContext.SaveChangesAsync(); } }
public async void remove(long device_id, [FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var(account, conversation) = await GetConversation(dbContext, device_id, account_id); if (conversation == null) { return; } dbContext.Conversations.Remove(conversation); account.Conversations.Remove(conversation); await dbContext.SaveChangesAsync(); } }
public async void update(long device_id, [FromQuery] string account_id, [FromBody] UpdateTemplateRequest request) { using (var dbContext = new PulseDbContext()) { var(account, template) = await GetTemplate(dbContext, device_id, account_id); if (template == null) { return; } template.Text = request.Text; //await FirebaseHelper.SendMessage(account, "updated_template", template); await dbContext.SaveChangesAsync(); } }
public async void clear([FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Contacts) .Where(a => a.AccountId == account_id) .FirstOrDefaultAsync(); var contacts = account.Contacts.ToArray(); foreach (var contact in contacts) { dbContext.Contacts.Remove(contact); account.Contacts.Remove(contact); } await dbContext.SaveChangesAsync(); } }
public async void update(long device_id, [FromQuery] string account_id, [FromBody] UpdateFolderRequest request) { using (var dbContext = new PulseDbContext()) { var(account, folder) = await GetFolder(dbContext, device_id, account_id); if (folder == null) { return; } folder.Name = request.Name; //await FirebaseHelper.SendMessage(account, "updated_folder", folder); await dbContext.SaveChangesAsync(); } }
public async void remove(int id, [FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Devices) .Where(a => a.AccountId == account_id) .FirstOrDefaultAsync(); var device = account.Devices.Where(d => d.DeviceId == id).FirstOrDefault(); if (device == null) return; dbContext.Devices.Remove(device); account.Devices.Remove(device); await dbContext.SaveChangesAsync(); } }
public async void add([FromBody] AddConversationRequest request) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Conversations) .Where(a => a.AccountId == request.AccountId) .FirstOrDefaultAsync(); if (account == null) { return; } foreach (var conversation in request.Conversations) { dbContext.Conversations.Add(conversation); account.Conversations.Add(conversation); //await FirebaseHelper.SendMessage(account, "added_conversation", new //{ // id = conversation.DeviceId, // color = conversation.Color, // color_dark = conversation.ColorDark, // color_light = conversation.ColorLight, // color_accent = conversation.ColorAccent, // led_color = conversation.LedColor, // pinned = conversation.Pinned, // read = conversation.Read, // timestamp = conversation.Timestamp, // title = conversation.Title, // phone_numbers = conversation.PhoneNumbers, // snippet = conversation.Snippet, // ringtone = conversation.Ringtone, // id_matcher = conversation.IdMatcher, // mute = conversation.Mute, // archive = conversation.Archive, // folder_id = conversation.FolderId //}); } await dbContext.SaveChangesAsync(); } }
public async Task <IActionResult> Register(User model) { if (ModelState.IsValid) { var user = new IdentityUser { UserName = model.Email, Email = model.Email }; //identity table user added var result = await userManager.CreateAsync(user, model.Password); if (result.Succeeded) { // await signInManager.SignInAsync(user, isPersistent: false); //my user table => user added _context.Add(model); await _context.SaveChangesAsync(); var res = await userManager.AddToRoleAsync(user, model.Role); if (res.Succeeded) { return(RedirectToAction("login", "account")); } foreach (var err in res.Errors) { ModelState.AddModelError("", err.Description); } } foreach (var err in result.Errors) { ModelState.AddModelError("", err.Description); } } return(View(model)); }
public async void remove(long device_id, [FromQuery] string android_device, [FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var (account, draft) = await GetDraft(dbContext, device_id, account_id); if (draft == null) return; dbContext.Drafts.Remove(draft); account.Drafts.Remove(draft); await FirebaseHelper.SendMessage(account, "removed_drafts", new { id = draft.DeviceId }); await dbContext.SaveChangesAsync(); } }
public async void updatePrimary([FromQuery] string new_primary_device_id, [FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var account = await dbContext.Accounts .Include(a => a.Devices) .Where(a => a.AccountId == account_id) .FirstOrDefaultAsync(); var device = account.Devices.Where(d => d.Primary).FirstOrDefault(); if (device != null) device.Primary = false; device = account.Devices.Where(d => d.DeviceId == long.Parse(new_primary_device_id)).FirstOrDefault(); if (device != null) device.Primary = true; await dbContext.SaveChangesAsync(); } }
public async void seen([FromQuery] string account_id) { using (var dbContext = new PulseDbContext()) { var converstaions = await dbContext.Conversations .Where(a => a.AccountId == account_id) .FirstOrDefaultAsync(); if (converstaions == null) { return; } converstaions.Seen = true; //await FirebaseHelper.SendMessage(account, "seen_conversations", new {}); await dbContext.SaveChangesAsync(); } }