public async Task <IActionResult> CreateAsync(
[FromForm] string username,
[FromForm] string fullName,
[FromForm] string password,
[FromForm] string confirmedPassword,
CancellationToken cancellationToken
)
{
if (password != confirmedPassword)
{
return(BadRequest());
}
var id = ObjectId.GenerateNewId().ToString();
var document = new UserDocument
{
Id = id,
Username = username,
Password = _passwordHasher.HashPassword(id, password),
FullName = fullName
};
await _users.InsertOneAsync(document, null, cancellationToken);
return(Ok());
}
/// <summary>
/// Function to make entry in database for uploaded document
/// </summary>
/// <param name="userID">userID</param>
/// <param name="docID">docID</param>
/// <param name="docName">docName</param>
/// <returns></returns>
public bool UploadDocument(int userID, int docID, string docName)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var userDocRepo =
new UserDocumentRepository(new EFRepository <UserDocument>(), unitOfWork);
UserDocument doc = new UserDocument();
doc.UserDocumentName = docName;
doc.FK_DocumentID = docID;
doc.Status = "Pending";
doc.FK_UserID = userID;
doc.IsDeleted = false;
userDocRepo.Add(doc);
userDocRepo.Save();
return(true);
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(false);
}
}
public async Task <IActionResult> UploadDocumentSignature(IFormFile file)
{
if (file == null)
{
return(Ok());
}
if (file.Length == 0)
{
return(BadRequest("File size is zero."));
}
var storage = new FileStorageCore(dc, CurrentUserId);
var storageId = await storage.Save(file);
dc.DbTran(() =>
{
var doc = new UserDocument
{
UserId = CurrentUserId,
Tag = "DocumentSignature",
FileStorageId = storageId
};
dc.Table <UserDocument>().Add(doc);
});
return(Ok());
}
public ActionResult UploadDocument(int user_Id, HttpPostedFileBase documentInfo)
{
string fileName = Path.GetFileName(documentInfo.FileName);
string filePath = user_Id.ToString() + "-" + DateTime.Now.ToString("MMddyyyyhhmmsstt") + Path.GetExtension(documentInfo.FileName);
string rootedPath = Path.Combine(Server.MapPath("~/Files"), filePath); // full direction from root, complete path
documentInfo.SaveAs(rootedPath);
UserDocument doc = new UserDocument();
doc.Id = 0;
doc.FileName = fileName;
doc.FilePath = filePath;
doc.User_Id = user_Id;
doc.UploadedBy = ((User)Session["User"]).Id;
doc.UploadOn = DateTime.Now;
_docRepo.SaveDocument(doc);
//_userRepo.UpdateImagePath(user_Id, fileName, filePath);
/* MemoryStream ms = new MemoryStream();
* fileInfo.InputStream.CopyTo(ms);
* byte[] fileArray = ms.ToArray();
* _userRepo.UpdateImagePath(userId, fileArray, fileName);*/
return(RedirectToAction("ViewDetails", "User", new { id = user_Id }));
}
public async Task <ActionResult <UserDocument> > Create([FromBody] UserDocument user)
{
var createdUser = await _userService.CreateAsync(_userDocumentConverter.ToUserDto(user));
return(CreatedAtAction(nameof(GetById), new { id = createdUser.Id },
_userDocumentConverter.ToUserDocument(createdUser)));
}
public async Task <IActionResult> UploadDocument(IFormFile fileToUpload)
{
if (fileToUpload.Length > 0)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
var uploadResult = new ImageUploadResult();
using (var stream = fileToUpload.OpenReadStream())
{
var uploadParams = new ImageUploadParams
{
File = new FileDescription(fileToUpload.Name, stream)
};
uploadResult = await _cloudinary.UploadAsync(uploadParams);
}
UserDocument document = new UserDocument()
{
DateAdded = DateTime.Now,
ApplicationUserId = claim.Value,
PublicId = uploadResult.PublicId,
Url = uploadResult.Url.ToString()
};
await _unitOfWork.UserDocument.AddAsync(document);
_unitOfWork.Save();
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult Create(UserDocumentViewModel vm)
{
if (ModelState.IsValid)
{
var newDocument = new UserDocument
{
UserId = vm.UserId,
DocumentType = vm.DocumentType,
FileSize = 0.0
};
if (vm.Document != null)
{
var siteSettings = _settingsService.GetSiteSettings();
var blobUploadService = new BlobUploadService(siteSettings.BlobSettings);
var blobPath = blobUploadService.UploadHRDocument(vm.Document);
newDocument.DocumentPath = blobPath;
newDocument.FileName = vm.Document.FileName;
}
_userDocumentRepository.Create(newDocument);
_unitOfWork.Commit();
return(RedirectToAction("Details", "Users", new { id = vm.UserId }));
}
return(View(vm));
}
private static async Task <IEnumerable <Claim> > ResolveProviderClaimsAsync(UserDocument user, HttpContext httpContext)
{
var claims = new List <Claim>();
var providerIdRouteValue = httpContext.GetRouteData()
.Values.GetValueOrDefault("ProviderId", StringComparison.OrdinalIgnoreCase)?.ToString();
if (!string.IsNullOrEmpty(providerIdRouteValue) && user.UserType == UserType.Provider)
{
var providersRepository = httpContext.RequestServices
.GetRequiredService <IProvidersRepository>();
var provider = await providersRepository
.GetAsync(providerIdRouteValue)
.ConfigureAwait(false);
if (provider?.PrincipalId.HasValue ?? false &&
provider.PrincipalId.Value.ToString().Equals(user.Id, StringComparison.OrdinalIgnoreCase))
{
claims.Add(new Claim(ClaimTypes.Role, ProviderUserRoles.ProviderWritePolicyRoleName));
}
}
return(claims);
}
public IHttpActionResult DeleteUserDocument([FromUri] int id)
{
try
{
UserDocument Doc = Mgr.FindById(id);
if (this.ActiveUser.Id != Doc.UserId)
{
return(BadRequest());
}
Doc.IsDeleted = true;
Doc.State = BaseState.Deleted;
Mgr.AddUpdate(Doc);
Unit.SaveChanges();
return(Ok(Doc));
}
catch (Exception ex)
{
Unit.LogError(ex, this.ToString(), this.ActionContext.ActionArguments.ToList());
return(InternalServerError(ex));
}
}
/// <summary>
///
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
private XElement Save(UserDocument user)
{
XElement xe = new XElement("Users");
foreach (var vv in user.Users)
{
XElement xx = new XElement("User");
xx.SetAttributeValue("Name", vv.Value.Name);
xx.SetAttributeValue("Password", vv.Value.Password);
xx.SetAttributeValue("NewDatabase", vv.Value.NewDatabase);
xx.SetAttributeValue("DeleteDatabase", vv.Value.DeleteDatabase);
xx.SetAttributeValue("IsAdmin", vv.Value.IsAdmin);
if (vv.Value.Databases != null && vv.Value.Databases.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (var vvv in vv.Value.Databases)
{
sb.Append(vvv + ",");
}
sb.Length = sb.Length > 0 ? sb.Length - 1 : sb.Length;
xx.SetAttributeValue("Database", sb.ToString());
}
xe.Add(xx);
}
return(xe);
}
public async Task <ActionResult> Login(UserDocument document)
{
if (ModelState.IsValid)
{
string connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString;
MongoClientSettings settings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));
settings.SslSettings = new SslSettings()
{
EnabledSslProtocols = SslProtocols.Tls12
};
MongoClient client = new MongoClient(settings);
var database = client.GetDatabase("TestDB");
var collection = database.GetCollection <UserDocument>("users");
UserDocument user = await collection.Find(_ => _.Username == document.Username).SingleOrDefaultAsync();
if (user != null)
{
if (MatchHashed(document.Password, user.Password))
{
ViewBag.ModelState = "Success";
}
}
//var builder = Builders<UserDocument>.Filter;
//var filter = builder.Eq("username", document.Username);
return(View("Index", new UserDocument()));
}
else
{
return(View("Index", document));
}
}
public bool AddDocument(DocumentEL document)
{
bool isInserted = false;
UserDocument newDoc = new UserDocument();
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
}))
{
try
{
if (document != null)
{
using (uow = new UnitOfWork.UnitOfWork())
{
#region Add New Document
newDoc.DocID = document.DocumentID;
newDoc.UserID = document.UserID;
newDoc.UploadPath = document.DocumentPath;
uow.UserDocumentRepository.Insert(newDoc);
uow.Save();
#endregion
transactionScope.Complete();
isInserted = true;
}
}
}
catch (Exception ex)
{
transactionScope.Dispose();
}
return(isInserted);
}
}
public ActionResult Create(CreateDocumentViewModel vm)
{
if (ModelState.IsValid)
{
var newDocument = new UserDocument()
{
Description = vm.Description,
Name = vm.file.FileName,
UploadTime = DateTime.Now,
/*UserId = vm.EnitityId,*/
};
newDocument.UserId = _userManager.GetUserId(User);
using (var memoryStream = new MemoryStream())
{
vm.file.CopyTo(memoryStream);
newDocument.DocumentData = memoryStream.ToArray();
}
//_context.UserDocument.Add(newDocument);
//_context.SaveChanges();
//Can't get it to accept nameof(Details) for some reason
return(RedirectToAction("Details", "StudentAdmin", new { id = vm.EnitityId }));
}
else
{
return(View(vm));
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
await CreateIndexesAsync(stoppingToken);
var hasAnyUsers = await _users
.Find(FilterDefinition <UserDocument> .Empty)
.AnyAsync(stoppingToken);
if (hasAnyUsers)
{
return;
}
var id = ObjectId.GenerateNewId().ToString();
var admin = new UserDocument
{
Id = id,
Username = "******",
FullName = "Event Store Administrator",
Password = _passwordHasher.HashPassword(id, "changeit")
};
await _users.InsertOneAsync(admin, cancellationToken : stoppingToken);
}
public JsonModel DeleteUserDocument(int id, TokenModel token)
{
// get document by id
UserDocument userDoc = _documentRepository.GetFirstOrDefault(a => a.Id == id && a.IsActive == true && a.IsDeleted == false);
if (userDoc != null)
{
userDoc.IsDeleted = true;
userDoc.DeletedDate = DateTime.UtcNow;
_documentRepository.Update(userDoc);
_documentRepository.SaveChanges();
return(new JsonModel()
{
data = new object(),
Message = StatusMessage.DocumentDelete,
StatusCode = (int)HttpStatusCodes.NoContent
});
}
else
{
return(new JsonModel()
{
data = new object(),
Message = StatusMessage.NotFound,
StatusCode = (int)HttpStatusCodes.NotFound
});
}
}
public string GetPublisherProfileNameByConversationId(string conversationId, string email)
{
PublisherProfileDocument publisherProfile = new PublisherProfileDocument();
string profileName = string.Empty;
string query = string.Empty;
List <string> users = GetUsersIdInConversation(conversationId);
// todo
collectionName = CosmosCollections.User.ToString();
// user one
query = $"SELECT * FROM {collectionName} WHERE {collectionName}.id='{users[0]}'";
UserDocument userOne = context.ExecuteQuery <UserDocument>(databaseName, collectionName, query).FirstOrDefault();
// user two
query = $"SELECT * FROM {collectionName} WHERE {collectionName}.id='{users[1]}'";
UserDocument userTwo = context.ExecuteQuery <UserDocument>(databaseName, collectionName, query).FirstOrDefault();
if (userOne != null && userOne.Email != email)
{
publisherProfile = GetPublisherProfile(userOne.Email);
profileName = publisherProfile.Name;
}
if (userTwo != null && userTwo.Email != email)
{
publisherProfile = GetPublisherProfile(userTwo.Email);
profileName = publisherProfile.Name;
}
return(profileName);
}
public ActionResult Create(HttpPostedFileBase file)
{
UserDocument userDocument = new UserDocument();
try
{
if (file != null && file.ContentLength > 0)
{
string filePath = Path.Combine(Server.MapPath("/Uploaded Files"), file.FileName);
string fileExtension = Path.GetExtension(file.FileName);
if (!System.IO.File.Exists(filePath))
{
userDocument.FileName = file.FileName;
userDocument.FilePath = "/Uploaded Files/" + file.FileName;
userDocument.UserId = User.Identity.GetUserId();
userDocument.CreateDate = DateTime.Now;
file.SaveAs(filePath);
db.UserDocuments.Add(userDocument);
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
// Log Exception
throw;
}
return(View(userDocument));
}
public async Task DeleteAllTrackedTimezones()
{
try
{
await JSR.StorageUtils.LocalStorageDeleteItem(TrackedTimezonesKey);
}
catch (Exception)
{
Logger.LogError("Failed to delete from local storage.");
}
// Save to firestore
var user = await AuthService.GetCurrentUser();
if (user != null)
{
// Collection
string collection = "users";
string docId = user.uid;
UserDocument doc = new UserDocument();
FirestoreOperationResult <UserDocument> result =
await FirestoreService.UpdateDocument <UserDocument, UserDocument>(collection, docId, doc);
Logger.LogInformation($"Doc save result: {result.Success}");
}
}
public async Task <IActionResult> Edit(int id, [Bind("UserDocumentId,AppUserId,FileModelId,FileDataTypeId")] UserDocument userDocument)
{
if (id != userDocument.UserDocumentId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userDocument);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserDocumentExists(userDocument.UserDocumentId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AppUserId"] = new SelectList(_context.Users, "Id", "Id", userDocument.AppUserId);
ViewData["FileDataTypeId"] = new SelectList(_context.FileDataTypes, "FileDataTypeId", "FileDataTypeId", userDocument.FileDataTypeId);
ViewData["FileModelId"] = new SelectList(_context.Files, "Id", "Id", userDocument.FileModelId);
return(View(userDocument));
}
public async Task <ResultCrmDb> AddUserDocument(int docId, int userId)
{
var result = new ResultCrmDb();
try
{
var model = await _wordDbContext.UserDocument.FirstOrDefaultAsync(f => f.UserId == userId && f.DocumentLoaderId == docId);
if (model != null)
{
return(result);
}
model = new UserDocument()
{
DocumentLoaderId = docId, UserId = userId
};
_wordDbContext.Add(model);
await _wordDbContext.SaveChangesAsync();
}
catch (Exception e)
{
result.AddError("-", e.Message);
}
return(result);
}
public async Task UpdateTodoListTaskAsync()
{
var requestDto = new UpdateTodoListTaskRequestDto
{
TodoListId = Guid.NewGuid(),
TodoListTaskId = Guid.NewGuid(),
Title = TodoServiceTest.GetRandomToken(),
Description = TodoServiceTest.GetRandomToken(),
Deadline = DateTime.UtcNow.AddDays(20),
};
var todoListDocument = new TodoListDocument
{
Id = requestDto.TodoListId,
Tasks = new[]
{
new TodoListTaskDocument
{
TaskId = requestDto.TodoListTaskId,
},
},
};
var userDocument = new UserDocument();
await _todoService.UpdateTodoListTaskAsync(requestDto, todoListDocument, userDocument, CancellationToken.None);
_documentClientMock.Verify();
}
public Lazy <ApplicationUser> MapToApplicationUser(UserDocument user)
{
Lazy <ApplicationUser> applicationUser = new Lazy <ApplicationUser>();
if (user != null)
{
applicationUser.Value.AccessFailAccount = user.AccessFailAccount;
applicationUser.Value.Email = user.Email;
applicationUser.Value.EmailConfirmed = user.EmailConfirmed;
applicationUser.Value.Hometown = user.Hometown;
applicationUser.Value.Id = user.Id;
applicationUser.Value.IsMetamask = user.IsMetamask;
applicationUser.Value.IsPremium = user.IsPremium;
applicationUser.Value.LastRolId = user.LastRolId;
applicationUser.Value.LockoutEnabled = user.LockoutEnabled;
applicationUser.Value.LockoutEndDateUtc = user.LockoutEndDateUtc;
applicationUser.Value.Name = user.Name;
applicationUser.Value.PasswordHash = user.PasswordHash;
applicationUser.Value.PhoneNumber = user.PhoneNumber;
applicationUser.Value.PhoneNumberConfirmed = user.PhoneNumberConfirmed;
applicationUser.Value.PrimaryRolId = user.PrimaryRolId;
applicationUser.Value.RegisterDate = user.RegisterDate;
applicationUser.Value.Roles = user.Roles;
applicationUser.Value.SecondaryRolId = user.SecondaryRolId;
applicationUser.Value.SecurityStamp = user.SecurityStamp;
applicationUser.Value.TokenAddress = user.TokenAddress;
applicationUser.Value.TwoFactorEnabled = user.TwoFactorEnabled;
applicationUser.Value.UserName = user.UserName;
applicationUser.Value.WalletAddress = user.WalletAddress;
}
return(applicationUser);
}
private static IList <IInternalFriend> CreateFriends(IUserDatabase userDatabase)
{
return(userDatabase.GetAllFriendDocuments().Select(delegate(FriendDocument friendDoc)
{
UserDocument userBySwid = userDatabase.GetUserBySwid(friendDoc.Swid);
return RemoteUserFactory.CreateFriend(friendDoc.Swid, friendDoc.IsTrusted, userBySwid.DisplayName, userBySwid.FirstName, userDatabase);
}).ToList());
}
public ActionResult DeleteConfirmed(int id)
{
UserDocument userDocument = db.UserDocuments.Find(id);
db.UserDocuments.Remove(userDocument);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static ActiveUserDocument FromUserDocument(UserDocument document) => new ActiveUserDocument
{
Content = document.Content,
DateUploaded = document.DateUploaded,
Name = document.Name,
UserId = document.UserId,
_id = document._id,
};
/// <summary>
/// When getting a user asynchronous.
/// </summary>
private async Task WhenGettingAUserAsync()
{
this.userResult = await this.service.GetUserAsync(new UserGetRequest()
{
UserEmail = this.createdUser.UserEmail, UserPartition = this.createdUser.UserPartition
})
.ConfigureAwait(false);
}
public static async Task ExecuteAsync(
[HttpTrigger("post", Route = "todo/{todoListId}/task/{todoListTaskId}")] HttpRequest httpRequest,
[Request] CompleteTodoListTaskRequestDto requestDto,
[Document] TodoListDocument todoListDocument,
[Authorization] UserDocument userDocument,
[Service] ITodoService service,
CancellationToken cancellationToken)
=> await service.CompleteTodoListTaskAsync(requestDto, todoListDocument, userDocument, cancellationToken);
public async Task <IActionResult> CreateUser(ProfileViewModel model)
{
var user = await _userManager.GetUserAsync(User);
if (user != null)
{
UserProfile userProfile = new UserProfile
{
UserId = user.Id,
Name = model.Name,
Surname = model.Surname,
Patronymic = model.Patronymic,
Gender = model.Gender,
BirthDay = model.BirthDay,
};
db.UserProfiles.Add(userProfile);
UserDocument userDocument = new UserDocument()
{
UserId = user.Id,
TypeDocument = model.TypeDocument,
SeriesNamberDocument = model.SeriesNamberDocument,
DateIssuanceDicument = model.DateIssuanceDicument,
IssuanceOffice = model.IssuanceOffice,
BirthPlace = model.BirthPlace,
Phone = model.Phone
};
db.UserDocuments.Add(userDocument);
UserDocumentFile userDocumentFile = new UserDocumentFile {
UserId = user.Id
};
if (model.IdentityDocument != null && model.Photo != null)
{
byte[] imageDocument = null;
using (var binaryReader = new BinaryReader(model.IdentityDocument.OpenReadStream()))
{
imageDocument = binaryReader.ReadBytes((int)model.IdentityDocument.Length);
}
byte[] imagePhoto = null;
using (var binaryReader = new BinaryReader(model.Photo.OpenReadStream()))
{
imagePhoto = binaryReader.ReadBytes((int)model.Photo.Length);
}
userDocumentFile.IdentityDocument = imageDocument;
userDocumentFile.Photo = imagePhoto;
}
db.UserDocumentFiles.Add(userDocumentFile);
await db.SaveChangesAsync();
return(RedirectToAction("Details"));
}
return(NotFound());
}
/// <inheritdoc />
public Task UpdateUserAsync(UserDocument user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
return(this.cosmosRepository.UpdateAsync(user));
}
public static async Task <CreateTodoListResponseDto> ExecuteAsync(
[HttpTrigger("post", Route = "todo")] HttpRequest httpRequest,
[Request] CreateTodoListRequestDto requestDto,
[Authorization] UserDocument userDocument,
[Validation(ValidatorType = typeof(CreateTodoListValidator),
ThrowIfInvalid = true)] ValidationResult validationResult,
[Service] ITodoService service,
CancellationToken cancellationToken)
=> await service.CreateTodoListAsync(requestDto, userDocument, cancellationToken);
// Select Inserted File Data
public List<UserDocument> selectUploadFiles(string _studentid)
{
UserDocument _document = null;
List<UserDocument> _documentList = new List<UserDocument>();
string selectDocumentQuery = "SELECT * FROM UserDocument WHERE UserID=@student ORDER BY Date DESC, Time DESC;";
conn = new SqlConnection(DBConnection.ConnectionString);
using (conn)
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
try
{
cmd.CommandText = selectDocumentQuery;
cmd.Prepare();
cmd.Parameters.AddWithValue("@student", _studentid);
SqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
long _documentid = long.Parse(rdr["DocumentID"].ToString());
string _userid = rdr["UserID"].ToString();
DateTime _date = DateTime.Parse(rdr["Date"].ToString());
DateTime _time = DateTime.Parse(rdr["Time"].ToString());
string _uploadPath = rdr["UploadPath"].ToString();
_document = new UserDocument(_documentid, _userid, _date, _time, _uploadPath);
_documentList.Add(_document);
}
return _documentList;
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
return null;
}
finally
{
conn.Close();
}
}
}
}
