Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango

1 files changed, 274 insertions, 0 deletions

diff --git a/Software/Visual_Studio/Web/Tango.MachineService/Controllers/MachineStudioController.cs b/Software/Visual_Studio/Web/Tango.MachineService/Controllers/MachineStudioController.cs
new file mode 100644
index 000000000..c9d7ea8b6
--- /dev/null
+++ b/Software/Visual_Studio/Web/Tango.MachineService/Controllers/MachineStudioController.cs
@@ -0,0 +1,274 @@
+using Microsoft.IdentityModel.Clients.ActiveDirectory;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Security.Authentication;
+using System.Web.Http;
+using Tango.BL;
+using Tango.BL.Builders;
+using Tango.BL.Entities;
+using Tango.BL.Enumerations;
+using Tango.Core.Cryptography;
+using Tango.MachineService.Models;
+using Tango.MachineStudio.Common.Authentication;
+using System.Data.Entity;
+using Tango.MachineStudio.Common.Update;
+using Tango.Web.Controllers;
+using Tango.Web.Helpers;
+using Tango.Web.Storage;
+using Tango.Web.Authentication;
+using Tango.Web.ActiveDirectory;
+
+namespace Tango.MachineService.Controllers
+{
+    public class MachineStudioController : JsonController
+    {
+        private static TokensManager _tokens_manager;
+        private static List<MachineStudioPendingUpload> _pendingUploads;
+        private ActiveDirectoryManager _ad_manager;
+
+        static MachineStudioController()
+        {
+            _tokens_manager = new TokensManager();
+            _pendingUploads = new List<MachineStudioPendingUpload>();
+        }
+
+        public MachineStudioController() : base()
+        {
+            _ad_manager = new ActiveDirectoryManager();
+        }
+
+        #region Update
+
+        [HttpPost]
+        public CheckForUpdatesResponse CheckForUpdates(CheckForUpdatesRequest request)
+        {
+            LogManager.Log("Request received...");
+
+            CheckForUpdatesResponse response = new CheckForUpdatesResponse();
+
+            using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+            {
+                if (_tokens_manager.Exists(request.AccessToken))
+                {
+                    var versions = db.MachineStudioVersions.ToList();
+
+                    MachineStudioVersion latestVersion = null;
+
+                    if (request.AcceptBetaRelease)
+                    {
+                        latestVersion = versions.OrderByDescending(x => Version.Parse(x.Version)).FirstOrDefault();
+                    }
+                    else
+                    {
+                        latestVersion = versions.Where(x => x.Stable).OrderByDescending(x => Version.Parse(x.Version)).FirstOrDefault();
+                    }
+
+                    Version currentVersion = Version.Parse(request.Version);
+
+                    String comments = String.Join(Environment.NewLine, versions.OrderBy(x => Version.Parse(x.Version)).Where(x => Version.Parse(x.Version) > currentVersion).Select(x => x.Comments));
+
+                    if (latestVersion != null && Version.Parse(latestVersion.Version) > currentVersion)
+                    {
+                        var manager = new StorageManager();
+                        var container = manager.GetContainer(MachineServiceConfig.MACHINE_STUDIO_VERSIONS_CONTAINER);
+                        var blob = container.GetBlockBlobReference(latestVersion.BlobName);
+
+                        response.BlobAddress = blob.GenerateReadSignature(TimeSpan.FromMinutes(60));
+
+                        response.IsUpdateAvailable = true;
+                        response.Version = latestVersion.Version;
+                        response.Comments = latestVersion.Comments;
+                        response.IsStable = latestVersion.Stable;
+                    }
+                }
+                else
+                {
+                    throw new AuthenticationException("Invalid token.");
+                }
+            }
+
+            return response;
+        }
+
+        [HttpPost]
+        public UploadVersionResponse UploadVersion(UploadVersionRequest request)
+        {
+            UploadVersionResponse response = new UploadVersionResponse();
+
+            using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+            {
+                //Load relation first...
+                db.Roles.ToList();
+                db.Permissions.ToList();
+                db.UsersRoles.ToList();
+                db.RolesPermissions.ToList();
+
+                var user = db.Users.SingleOrDefault(x => x.Email.ToLower() == request.Email.ToLower() && x.Password == request.Password);
+
+                if (user != null && user.HasPermission(Permissions.PublishMachineStudioVersions))
+                {
+                    var latestVersion = db.MachineStudioVersions.ToList().OrderByDescending(x => Version.Parse(x.Version)).FirstOrDefault();
+                    Version currentVersion = Version.Parse(request.Version);
+
+                    if (latestVersion == null || currentVersion > Version.Parse(latestVersion.Version))
+                    {
+                        String newVersionFileName = "Machine Studio Version" + " " + currentVersion.ToString() + ".zip";
+
+                        var manager = new StorageManager();
+                        var container = manager.GetContainer(MachineServiceConfig.MACHINE_STUDIO_VERSIONS_CONTAINER);
+                        var blob = container.CreateEmptyBlob(newVersionFileName);
+
+                        response.Token = Guid.NewGuid().ToString();
+                        response.BlobAddress = blob.GenerateWriteSignature(TimeSpan.FromMinutes(30));
+
+                        _pendingUploads.Add(new MachineStudioPendingUpload()
+                        {
+                            UserGuid = user.Guid,
+                            Comments = request.Comments,
+                            ForcedUpdate = request.ForcedUpdate,
+                            Token = response.Token,
+                            Version = request.Version,
+                            IsStable = request.IsStable,
+                            BlobName = blob.Name,
+                        });
+                    }
+                    else
+                    {
+                        throw new ArgumentException("New version must be greater than latest version.");
+                    }
+                }
+                else
+                {
+                    throw new AuthenticationException("Invalid user credentials.");
+                }
+            }
+
+            return response;
+        }
+
+        [HttpPost]
+        public UploadCompletedResponse NotifyUploadCompleted(UploadCompletedRequest request)
+        {
+            MachineStudioPendingUpload upload = _pendingUploads.FirstOrDefault(x => x.Token == request.AccessToken);
+
+            if (upload != null)
+            {
+                _pendingUploads.RemoveAll(x => x.Token == upload.Token);
+
+                using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+                {
+                    db.MachineStudioVersions.Add(new MachineStudioVersion()
+                    {
+                        Comments = upload.Comments,
+                        BlobName = upload.BlobName,
+                        UserGuid = upload.UserGuid,
+                        Version = upload.Version,
+                        ForceUpdate = upload.ForcedUpdate,
+                        Stable = upload.IsStable,
+                    });
+
+                    db.SaveChanges();
+                }
+
+                return new UploadCompletedResponse();
+            }
+            else
+            {
+                throw new ArgumentException("Invalid Token.");
+            }
+        }
+
+        [HttpPost]
+        public LatestVersionResponse GetLatestVersion(LatestVersionRequest request)
+        {
+            using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+            {
+                var version = db.MachineStudioVersions.ToList().OrderByDescending(x => Version.Parse(x.Version)).FirstOrDefault();
+                return new LatestVersionResponse() { Version = version != null ? version.Version : "0.0.0.0" };
+            }
+        }
+
+        #endregion
+
+        [HttpPost]
+        public LoginResponse Login(LoginRequest request)
+        {
+            var authResult =_ad_manager.ValidateUserCredentials(request.Email, request.Password);
+
+            if (!_ad_manager.CanUserAccessCurrentEnvironment(request.Email))
+            {
+                throw new AuthenticationException($"You do not have permissions to access the {MachineServiceConfig.DEPLOYMENT_SLOT.ToDescription()} environment.");
+            }
+
+            using (ObservablesContext db = ObservablesContextHelper.CreateContext())
+            {
+                db.Roles.ToList();
+                db.Permissions.ToList();
+                db.UsersRoles.ToList();
+                db.RolesPermissions.ToList();
+
+                var user = db.Users.SingleOrDefault(x => x.Email.ToLower() == request.Email.ToLower());
+
+                IHashGenerator g = new BasicHashGenerator();
+
+                if (user == null)
+                {
+                    //Than add the user !!
+                    User new_user = new User();
+                    new_user.Email = request.Email;
+                    new_user.Password = g.Encrypt(request.Password);
+                    new_user.Organization = db.Organizations.Include(x => x.Address).Single(x => x.Name == "Twine");
+                    new_user.Address = new_user.Organization.Address.Clone();
+                    new_user.Contact = new Contact()
+                    {
+                        FirstName = authResult.UserInfo.GivenName,
+                        LastName = authResult.UserInfo.FamilyName,
+                        FullName = authResult.UserInfo.GivenName + " " + authResult.UserInfo.FamilyName,
+                        Email = request.Email,
+                    };
+
+                    db.UsersRoles.Add(new UsersRole()
+                    {
+                         User = new_user,
+                         Role = db.Roles.Single(x => (Roles)x.Code == Roles.User),
+                    });
+
+                    db.UsersRoles.Add(new UsersRole()
+                    {
+                        User = new_user,
+                        Role = db.Roles.Single(x => (Roles)x.Code == Roles.MachineStudioUser),
+                    });
+
+                    new_user.LastLogin = DateTime.UtcNow;
+                    db.Users.Add(new_user);
+                }
+                else
+                {
+                    user.LastLogin = DateTime.UtcNow;
+                    user.Password = g.Encrypt(request.Password);
+                }
+
+                db.SaveChanges();
+            }
+
+            return new LoginResponse()
+            {
+                DataSource = new Core.DataSource()
+                {
+                    Address = MachineServiceConfig.DB_ADDRESS,
+                    Catalog = MachineServiceConfig.DB_CATALOG,
+                    Type = Core.DataSourceType.Azure,
+                    IntegratedSecurity = false,
+                    UserName = request.Email,
+                    Password = request.Password,
+                },
+
+                Token = _tokens_manager.CreateNew()
+            };
+        }
+
+    }
+}