public static string CreateFolder(string baseDirectory)
        {
            string theNewFolderName = "";
            string currentPath;

            bool   useAttachmentsRelativePath  = false;
            string sUseAttachmentsRelativePath = AppSettings.Get <string>("UseAttachmentsRelativePath");

            if (!string.IsNullOrWhiteSpace(sUseAttachmentsRelativePath) && bool.TryParse(sUseAttachmentsRelativePath, out bool bUseAttachmentsRelativePath))
            {
                useAttachmentsRelativePath = bUseAttachmentsRelativePath;
            }

            do
            {
                DateTime date = DateTime.Now;
                theNewFolderName = date.ToString("yy") + date.Month.ToString("d2") +
                                   date.Day.ToString("d2") + "_" + MD5HashGenerator.GenerateKey(date);

                if (useAttachmentsRelativePath)
                {
                    currentPath = "~/".MapHostAbsolutePath() + baseDirectory + theNewFolderName;
                }
                else
                {
                    currentPath = baseDirectory + theNewFolderName;
                }
            } while (Directory.Exists(currentPath));
            Directory.CreateDirectory(currentPath);
            return(theNewFolderName);
        }
예제 #2
0
        public async Task <string> AuthorizePlayerAsync(Guid gameId, string password, User user)
        {
            var game = await _gameStorage.GetByIdAsync(gameId);

            if (game is null)
            {
                return("GAME_NOT_FOUND");
            }

            if (game.IsPrivate())
            {
                if (string.IsNullOrEmpty(password))
                {
                    return("PASSWORD_REQUIRED");
                }

                var passwordHash = MD5HashGenerator.GenerateHash(password);
                if (!game.Password.Equals(passwordHash))
                {
                    return("INCORRECT_PASSWORD");
                }
            }

            game.AuthorizeUser(user.Id);
            await _gameStorage.EditAsync(game);

            return("OK");
        }
예제 #3
0
파일: TokenLogic.cs 프로젝트: JFigue27/MDC
        public Token GetNew(string ForeignType, long ForeignKey)
        {
            var token = new Token
            {
                ForeignKey  = ForeignKey,
                ForeignType = ForeignType,
                Value       = MD5HashGenerator.GenerateKey(DateTime.Now),
                ExpiresAt   = DateTimeOffset.Now.AddMinutes(40)
            };

            return(Add(token));
        }
예제 #4
0
        public static string ComputeHash(this object sourceObject, ObjectHasherAlgorithmTypeEnum algorithm = ObjectHasherAlgorithmTypeEnum.MD5)
        {
            IObjectHasher objectHasher = null;

            switch (algorithm)
            {
            case ObjectHasherAlgorithmTypeEnum.MD5:
                objectHasher = new MD5HashGenerator();
                break;
            }

            return(objectHasher.ComputeHash(sourceObject));
        }
예제 #5
0
        /// <summary>
        /// Serves as a hash function for a particular type.
        /// </summary>
        /// <returns>
        /// A hash code for the current <see cref="T:System.Object"/>.
        /// </returns>
        public override int GetHashCode()
        {
            string hashString = MD5HashGenerator.GenerateKey(this);

            try
            {
                return(Convert.ToInt32(hashString, CultureInfo.InvariantCulture));
            }
            catch (FormatException fe)
            {
                this.logger.Debug("Couldn't transform the hash string: " + hashString + " to an Integer. Cause: " + fe.Message);
                return(base.GetHashCode());
            }
        }
예제 #6
0
        public static string CreateFolder(string baseDirectory)
        {
            string theNewFolderName = "";
            string currentPath;

            do
            {
                DateTime date = DateTime.Now;
                theNewFolderName = date.ToString("yy") + date.Month.ToString("d2") +
                                   date.Day.ToString("d2") + "_" + MD5HashGenerator.GenerateKey(date);
                currentPath = baseDirectory + theNewFolderName;
            } while (Directory.Exists(currentPath));
            Directory.CreateDirectory(currentPath);
            return(theNewFolderName);
        }
예제 #7
0
        public async Task <Game> CreateAsync(User user, string name, string password, GameOptions options)
        {
            if (!string.IsNullOrEmpty(password))
            {
                password = MD5HashGenerator.GenerateHash(password);
            }

            var game = new Game(name, password, options);

            game.AuthorizeUser(user.Id);
            await _gameStorage.AddAsync(game);

            var player = Player.CreateAsAdmin(game.Id, user);
            await _playerStorage.AddAsync(player);

            return(game);
        }
        public void GetMD5Hash_Test()
        {
            ReferencesData data1;
            ReferencesData data2;

            using (EventLogReader reader = EventLogReader.CreateReader(_sampleDatabaseFileLGF))
            {
                data1 = ReferencesData.CreateFromReader(reader);
            }
            using (EventLogReader reader = EventLogReader.CreateReader(_sampleDatabaseFileLGF))
            {
                data2 = ReferencesData.CreateFromReader(reader);
            }

            string hashMD51 = MD5HashGenerator.GetMd5Hash(data1);
            string hashMD52 = MD5HashGenerator.GetMd5Hash(data2);

            Assert.Equal(hashMD51, hashMD52);
        }
예제 #9
0
파일: RFQ.aspx.cs 프로젝트: Capsonic/APQM
    public bool getPostedAttachmentsToBuyer()
    {
        HttpPostedFile     file           = Request.Files["myfile"];
        HttpFileCollection fileCollection = Request.Files;

        if (file != null)
        {
            string         fileName   = file.FileName;
            HttpPostedFile postedFile = file;

            string baseAttachmentsPath = ConfigurationManager.AppSettings["RFQAttachmentsInbox"];

            string currentPathAttachments;
            string folderName = Request["RFQATTACHMENTSFOLDERINBOX"];
            if (folderName != null && folderName.Trim() != "")
            {
                currentPathAttachments = baseAttachmentsPath + folderName + @"\";
            }
            else
            {
                do
                {
                    DateTime date = DateTime.Now;
                    folderName = date.Year.ToString() + date.Month.ToString() +
                                 date.Day.ToString() + "_" + MD5HashGenerator.GenerateKey(date);
                    currentPathAttachments = baseAttachmentsPath + folderName;
                } while (Directory.Exists(currentPathAttachments));
                Directory.CreateDirectory(currentPathAttachments);
                currentPathAttachments += @"\";
            }

            if (postedFile.ContentLength > 0)
            {
                postedFile.SaveAs(currentPathAttachments + Path.GetFileName(postedFile.FileName));
            }
            Response.Clear();
            Response.Write("[{\"FolderName\":\"" + folderName + "\"}," + JsonConvert.SerializeObject(getAttachmentsFromFolder(folderName)) + "]");
            Response.End();
            return(true);
        }
        return(false);
    }
예제 #10
0
        public object attachmentsPost()
        {
            CommonResponse response = new CommonResponse();

            try
            {
                string attachmentKind = HttpContext.Current.Request["attachmentKind"];
                if (attachmentKind == null || attachmentKind == "")
                {
                    response.ErrorThrown         = true;
                    response.ResponseDescription = "Attachment Kind was not specified.";
                    return(response);
                }

                var postedFile = HttpContext.Current.Request.Files["file"];
                if (postedFile != null)
                {
                    string fileName = postedFile.FileName;

                    string baseAttachmentsPath = ConfigurationManager.AppSettings[attachmentKind];

                    bool   useAttachmentsRelativePath  = false;
                    string sUseAttachmentsRelativePath = ConfigurationManager.AppSettings["UseAttachmentsRelativePath"];
                    if (!string.IsNullOrWhiteSpace(sUseAttachmentsRelativePath) && bool.TryParse(sUseAttachmentsRelativePath, out bool bUseAttachmentsRelativePath))
                    {
                        useAttachmentsRelativePath = bUseAttachmentsRelativePath;
                    }

                    string currentPathAttachments;
                    string folderName = HttpContext.Current.Request["targetFolder"];
                    if (folderName != null && folderName.Trim() != "")
                    {
                        if (useAttachmentsRelativePath)
                        {
                            currentPathAttachments = HostingEnvironment.MapPath("~/" + baseAttachmentsPath + folderName + @"/");
                        }
                        else
                        {
                            currentPathAttachments = baseAttachmentsPath + folderName + @"\";
                        }

                        if (!Directory.Exists(currentPathAttachments))
                        {
                            Directory.CreateDirectory(currentPathAttachments);
                        }
                    }
                    else
                    {
                        string folderPrefix = HttpContext.Current.Request["folderPrefix"];
                        if (string.IsNullOrWhiteSpace(folderPrefix) || folderPrefix == "undefined" || folderPrefix == "null")
                        {
                            folderPrefix = "";
                        }
                        do
                        {
                            DateTime date = DateTime.Now;
                            folderName = folderPrefix + date.ToString("yy") + date.Month.ToString("d2") +
                                         date.Day.ToString("d2") + "_" + MD5HashGenerator.GenerateKey(date);

                            if (useAttachmentsRelativePath)
                            {
                                currentPathAttachments = HostingEnvironment.MapPath("~/" + baseAttachmentsPath + folderName);
                            }
                            else
                            {
                                currentPathAttachments = baseAttachmentsPath + folderName;
                            }
                        } while (Directory.Exists(currentPathAttachments));
                        Directory.CreateDirectory(currentPathAttachments);
                        if (useAttachmentsRelativePath)
                        {
                            currentPathAttachments += @"/";
                        }
                        else
                        {
                            currentPathAttachments += @"\";
                        }
                    }

                    if (postedFile.ContentLength > 0)
                    {
                        postedFile.SaveAs(currentPathAttachments + Path.GetFileName(postedFile.FileName));
                    }

                    List <Attachment> attachmentsResult = AttachmentsIO.getAttachmentsFromFolder(folderName, attachmentKind);

                    response.ErrorThrown         = false;
                    response.ResponseDescription = folderName;
                    response.Result = attachmentsResult;
                }
            }
            catch (Exception e)
            {
                response.ErrorThrown         = true;
                response.ResponseDescription = "ERROR: " + e.Message;
                response.Result = e;
            }

            return(response);
        }
예제 #11
0
    public string sendRFQ()
    {
        List <RFQ>      resultRFQs = new List <RFQ>();
        GatewayResponse response   = new GatewayResponse();
        String          s;
        NewRFQScreen    newRFQScreen;

        try
        {
            s            = new StreamReader(Request.InputStream).ReadToEnd();
            newRFQScreen = JsonConvert.DeserializeObject <NewRFQScreen>(s);
        }
        catch (Exception ex)
        {
            response.ErrorThrown         = true;
            response.ResponseDescription = "ERROR: When trying to parse JSON in server. " + ex.Message;
            return(JsonConvert.SerializeObject(response));
        }

        RFQNumberCRUD rfqNumberCRUD  = new RFQNumberCRUD();
        bomDetailCRUD bomDetail_CRUD = new bomDetailCRUD();
        UserCRUD      user_CRUD      = new UserCRUD();

        string baseBOMAttachmentsPath = ConfigurationManager.AppSettings["BOMLineAttachments"];
        string baseRFQAttachmentsPath = ConfigurationManager.AppSettings["RFQAttachmentsSent"];

        string strAuthUser = HttpContext.Current.User.Identity.Name;
        User   user        = user_CRUD.readById(strAuthUser);

        List <SIFDetail> EAUsList = newRFQScreen.SIFVolumesList;

        if (EAUsList.Count == 0)
        {
            response.ErrorThrown         = true;
            response.ResponseDescription = "ERROR: Cannot create RFQ without EAU specified.";
            return(JsonConvert.SerializeObject(response));
        }

        List <RFQEAV> newEAUList = new List <RFQEAV>();

        foreach (SIFDetail eau in EAUsList)
        {
            RFQEAV eauParsed = new RFQEAV();
            eauParsed.Volume = eau.ProjectedAnnualVolume;
            eauParsed.Year   = eau.ProgramYear;
            RFQEAV alreadyExists = newEAUList.Find(eauInternal => eauInternal.Volume == eauParsed.Volume);
            if (alreadyExists == null)
            {
                newEAUList.Add(eauParsed);
            }
            else
            {
                alreadyExists.Year = alreadyExists.Year.Trim() + ", " + eauParsed.Year.Trim();
            }
        }

        List <BOMDetail> bomDetailList = newRFQScreen.BomDetailList;


        ConnectionManager CM = new ConnectionManager();

        Data_Base_MNG.SQL DM = CM.getDataManager();

        if (newRFQScreen.SupplierList.Count > 0)
        {
            foreach (Supplier supplier in newRFQScreen.SupplierList)
            {
                foreach (BOMDetail component in bomDetailList)
                {
                    RFQNumberEntity rfqNumber = new RFQNumberEntity();

                    rfqNumber.BOMDetailKey = component.Id;
                    rfqNumber.SifHeaderKey = newRFQScreen.SIFHeaderID;
                    rfqNumber.RFQNumber    = rfqNumberCRUD.generateNewRFQNumber(rfqNumber.SifHeaderKey);

                    if (rfqNumber.RFQNumber == -1)
                    {
                        response.ErrorThrown         = true;
                        response.ResponseDescription = "ERROR: There was an error generating a new RFQ number.";
                        return(JsonConvert.SerializeObject(response));
                    }

                    CM = new ConnectionManager();
                    DM = CM.getDataManager();

                    /*Begin Transaction*/
                    DM.Open_Connection("Send New RFQ");

                    RFQ             rfq = new RFQ();
                    RFQNumberEntity rfqNumberGenereated = rfqNumberCRUD.create_return_object(rfqNumber, ref DM);
                    if (rfqNumberCRUD.ErrorOccur)
                    {
                        response.ErrorThrown         = true;
                        response.ResponseDescription = "ERROR:" + rfqNumberCRUD.ErrorMessage;
                        return(JsonConvert.SerializeObject(response));
                    }
                    else
                    {
                        //rfq.SentAttachmentsFolder = newRFQScreen.FolderAttachments;

                        newRFQScreen.FolderAttachments = newRFQScreen.FolderAttachments.Trim();
                        if (newRFQScreen.FolderAttachments != "")
                        {
                            if (System.IO.Directory.Exists((baseRFQAttachmentsPath + newRFQScreen.FolderAttachments)))
                            {
                                DirectoryInfo directory = new DirectoryInfo((baseRFQAttachmentsPath + newRFQScreen.FolderAttachments));
                                if (directory.GetFiles().Length > 0)
                                {
                                    string folderName = "";
                                    do
                                    {
                                        DateTime date = DateTime.Now;
                                        folderName = date.Year.ToString() + date.Month.ToString() +
                                                     date.Day.ToString() + "_" + MD5HashGenerator.GenerateKey(date);
                                    } while (Directory.Exists((baseRFQAttachmentsPath + folderName)));
                                    Directory.CreateDirectory((baseRFQAttachmentsPath + folderName));
                                    rfq.SentAttachmentsFolder = folderName;


                                    foreach (FileInfo file in directory.GetFiles())
                                    {
                                        try
                                        {
                                            File.Copy(file.FullName, (baseRFQAttachmentsPath + rfq.SentAttachmentsFolder + @"\" + file.Name), true);
                                        }
                                        catch (Exception ex)
                                        {
                                            response.ErrorThrown         = true;
                                            response.ResponseDescription = "ERROR:" + ex.Message;
                                            return(JsonConvert.SerializeObject(response));
                                        }
                                    }
                                }
                            }
                        }

                        foreach (Attachment bomAttachment in component.AttachmentsList)
                        {
                            if (rfq.SentAttachmentsFolder.Trim() == "")
                            {
                                string folderName = "";
                                do
                                {
                                    DateTime date = DateTime.Now;
                                    folderName = date.Year.ToString() + date.Month.ToString() +
                                                 date.Day.ToString() + "_" + MD5HashGenerator.GenerateKey(date);
                                } while (Directory.Exists((baseRFQAttachmentsPath + folderName)));
                                Directory.CreateDirectory((baseRFQAttachmentsPath + folderName));
                                rfq.SentAttachmentsFolder = folderName;
                            }
                            string currentPathAttachmentSource = baseBOMAttachmentsPath + bomAttachment.Directory + @"\" + bomAttachment.FileName;
                            string currentPathAttachmentTarget = baseRFQAttachmentsPath + rfq.SentAttachmentsFolder + @"\" + bomAttachment.FileName;
                            try
                            {
                                File.Copy(currentPathAttachmentSource, currentPathAttachmentTarget, true);
                            }
                            catch (Exception e)
                            {
                                response.ErrorThrown         = true;
                                response.ResponseDescription = "ERROR:" + e.Message;
                                return(JsonConvert.SerializeObject(response));
                            }
                        }


                        RfqCRUD rfqCRUD = new RfqCRUD();

                        rfq.SupplierId       = supplier.Id;
                        rfq.SupplierName     = supplier.SupplierName;
                        rfq.SentToVendor     = DateTime.Now;
                        rfq.LastEmail        = supplier.ContactEmail;
                        rfq.Status           = "PENDING";
                        rfq.BomDetailId      = component.Id;
                        rfq.Um               = component.Um;
                        rfq.RfqNumberKey     = rfqNumberGenereated.Id;
                        rfq.RfqGenerated     = rfqNumberGenereated.RfqGenerated;
                        rfq.DueDate          = newRFQScreen.DueDate;
                        rfq.MarketSectorID   = newRFQScreen.MarketSectorID;
                        rfq.DrawingLevel     = newRFQScreen.DrawingLevel;
                        rfq.TargetPrice      = newRFQScreen.TargetPrice;
                        rfq.CommentsToVendor = newRFQScreen.CommentsToVendor;


                        rfq.CreatedBy = strAuthUser;

                        string idGenerated = rfqCRUD.createAndReturnIdGenerated(rfq, component, ref DM);

                        if (!rfqCRUD.ErrorOccur)
                        {
                            rfq.Id = long.Parse(idGenerated);

                            foreach (RFQEAV eau in newEAUList)
                            {
                                RFQEAVCRUD rfqEAV_CRUD      = new RFQEAVCRUD();
                                RFQEAV     rfqEAV_toPersist = new RFQEAV();
                                rfqEAV_toPersist.RfqHeaderKey = long.Parse(idGenerated);
                                rfqEAV_toPersist.Volume       = eau.Volume * component.Qty;
                                rfqEAV_toPersist.Year         = eau.Year;
                                rfqEAV_toPersist.Status       = "CREATED";
                                rfqEAV_CRUD.createAndReturnIdGenerated(rfqEAV_toPersist, ref DM);
                                if (rfqEAV_CRUD.ErrorOccur)
                                {
                                    response.ErrorThrown         = true;
                                    response.ResponseDescription = "ERROR:" + rfqEAV_CRUD.ErrorMessage;
                                    return(JsonConvert.SerializeObject(response));
                                }
                            }

                            TokenCRUD token_CRUD = new TokenCRUD();
                            Token     token      = new Token();
                            token.Subject     = "RFQ";
                            token.SubjectKey  = long.Parse(idGenerated);
                            token.TokenNumber = MD5HashGenerator.GenerateKey(DateTime.Now);
                            if (token_CRUD.create(token, ref DM))
                            {
                                Email       NewMail = new Email();
                                MailMessage Message = new MailMessage();
                                try
                                {
                                    Message.From = new MailAddress("*****@*****.**", "*****@*****.**");
                                    Message.To.Add(new MailAddress(supplier.ContactEmail.ToString()));
                                    Message.Subject      = "Request For Quote";
                                    Message.IsBodyHtml   = true;
                                    Message.BodyEncoding = System.Text.Encoding.UTF8;

                                    var url             = ResolveUrl("~/Vendor/Email_RFQ_Request.htm");
                                    var strEmailContent = HTMLContent(url);
                                    strEmailContent = strEmailContent.Replace("{BuyerName}", user.Name);
                                    strEmailContent = strEmailContent.Replace("{BuyerPhone}", user.Phone1);
                                    strEmailContent = strEmailContent.Replace("{BuyerEmail}", user.Email);
                                    strEmailContent = strEmailContent.Replace("{RFQ Number}", rfqNumber.RfqGenerated);
                                    strEmailContent = strEmailContent.Replace("{Part Number}", component.PartNumber);
                                    strEmailContent = strEmailContent.Replace("{RFQLink}", "http://" + Request.Url.Authority + Request.ApplicationPath + "/Vendor/RFQHandler.ashx?token=" + token.TokenNumber);

                                    Message.Body = strEmailContent;


                                    NewMail.SendMail(Message);
                                }
                                catch (Exception ex)
                                {
                                    DM.RollBack();
                                    response.ErrorThrown         = true;
                                    response.ResponseDescription = "ERROR: Could not send email to: " + supplier.ContactEmail.ToString() + "; " + ex.Message;
                                    return(JsonConvert.SerializeObject(response));
                                }
                            }
                            else
                            {
                                response.ErrorThrown         = true;
                                response.ResponseDescription = "ERROR: " + token_CRUD.ErrorMessage;
                                return(JsonConvert.SerializeObject(response));
                            }
                        }
                        else
                        {
                            response.ErrorThrown         = true;
                            response.ResponseDescription = "ERROR: " + rfqCRUD.ErrorMessage;
                            return(JsonConvert.SerializeObject(response));
                        }
                    }

                    DM.CommitTransaction();
                    DM.Close_Open_Connection();

                    if (DM.ErrorOccur)
                    {
                        response.ErrorThrown         = true;
                        response.ResponseDescription = "ERROR: " + DM.Error_Mjs;
                        return(JsonConvert.SerializeObject(response));
                    }
                    resultRFQs.Add(rfq);
                }
            }
        }

        response.ErrorThrown         = false;
        response.ResponseDescription = "RFQs created successfully.";
        response.Result = resultRFQs;
        return(JsonConvert.SerializeObject(response));
    }
예제 #12
0
    public string resendRFQ()
    {
        GatewayResponse response = new GatewayResponse();
        String          s;
        RFQ             rfqToResend;

        try
        {
            s           = new StreamReader(Request.InputStream).ReadToEnd();
            rfqToResend = JsonConvert.DeserializeObject <RFQ>(s);
        }
        catch (Exception ex)
        {
            response.ErrorThrown         = true;
            response.ResponseDescription = "ERROR: When trying to parse JSON in server. " + ex.Message;
            return(JsonConvert.SerializeObject(response));
        }

        UserCRUD user_CRUD   = new UserCRUD();
        string   strAuthUser = HttpContext.Current.User.Identity.Name;
        User     user        = user_CRUD.readById(strAuthUser);

        SupplierCRUD supplier_CRUD = new SupplierCRUD();
        Supplier     supplier      = supplier_CRUD.readById(rfqToResend.SupplierId);

        if (supplier != null)
        {
            if (supplier.ContactEmail.Trim() != rfqToResend.LastEmail.Trim())
            {
                supplier.ContactEmail = rfqToResend.LastEmail.Trim();
                if (!supplier_CRUD.update(supplier))
                {
                    response.ErrorThrown         = true;
                    response.ResponseDescription = "ERROR:" + supplier_CRUD.ErrorMessage;
                    return(JsonConvert.SerializeObject(response));
                }
            }
        }

        TokenCRUD token_CRUD = new TokenCRUD();
        Token     token      = token_CRUD.readByRFQ(rfqToResend);

        ConnectionManager CM = new ConnectionManager();

        Data_Base_MNG.SQL DM = CM.getDataManager();

        /*Begin Transaction*/
        DM.Open_Connection("RFQ Re-send");

        rfqToResend.SentToVendor = DateTime.Now;
        if (!rfq_CRUD.update(rfqToResend, ref DM))
        {
            response.ErrorThrown         = true;
            response.ResponseDescription = "ERROR:" + rfq_CRUD.ErrorMessage;
            return(JsonConvert.SerializeObject(response));
        }

        if (token == null)
        {
            token             = new Token();
            token.Subject     = "RFQ";
            token.SubjectKey  = rfqToResend.Id;
            token.TokenNumber = MD5HashGenerator.GenerateKey(DateTime.Now);
            token_CRUD.create(token, ref DM);
            if (token_CRUD.ErrorOccur)
            {
                response.ErrorThrown         = true;
                response.ResponseDescription = "ERROR:" + token_CRUD.ErrorMessage;
                return(JsonConvert.SerializeObject(response));
            }
        }


        Email       NewMail = new Email();
        MailMessage Message = new MailMessage();

        try
        {
            Message.From = new MailAddress("*****@*****.**", "*****@*****.**");
            Message.To.Add(new MailAddress(supplier.ContactEmail.ToString()));
            Message.Subject      = "Request For Quote";
            Message.IsBodyHtml   = true;
            Message.BodyEncoding = System.Text.Encoding.UTF8;

            var url             = ResolveUrl("~/Vendor/Email_RFQ_Request.htm");
            var strEmailContent = HTMLContent(url);
            strEmailContent = strEmailContent.Replace("{BuyerName}", user.Name);
            strEmailContent = strEmailContent.Replace("{BuyerPhone}", user.Phone1);
            strEmailContent = strEmailContent.Replace("{BuyerEmail}", user.Email);
            strEmailContent = strEmailContent.Replace("{RFQ Number}", rfqToResend.RfqGenerated);
            strEmailContent = strEmailContent.Replace("{Part Number}", rfqToResend.PartNumber);
            strEmailContent = strEmailContent.Replace("{RFQLink}", "http://" + Request.Url.Authority + Request.ApplicationPath + "/Vendor/RFQHandler.ashx?token=" + token.TokenNumber);

            Message.Body = strEmailContent;


            NewMail.SendMail(Message);
        }
        catch (Exception ex)
        {
            DM.RollBack();
            response.ErrorThrown         = true;
            response.ResponseDescription = "ERROR: Could not send email to: " + supplier.ContactEmail.ToString();
            return(JsonConvert.SerializeObject(response));
        }

        DM.CommitTransaction();
        DM.Close_Open_Connection();

        if (DM.ErrorOccur)
        {
            response.ErrorThrown         = true;
            response.ResponseDescription = "ERROR:" + DM.Error_Mjs;
            return(JsonConvert.SerializeObject(response));
        }

        response.ErrorThrown         = false;
        response.ResponseDescription = "RFQ " + rfqToResend.RfqGenerated + " re-sent successfully.";
        response.Result = rfqToResend;
        return(JsonConvert.SerializeObject(response));
    }
예제 #13
0
 public string GetReferencesHash()
 {
     return(MD5HashGenerator.GetMd5Hash(this));
 }
예제 #14
0
        public object Post(PostAvatar request)
        {
            var response = new CommonResponse();

            if (Request.Files.Length == 0)
            {
                throw new HttpError(HttpStatusCode.BadRequest, "NoFile");
            }

            var postedFile = Request.Files[0];

            string fileName = postedFile.FileName;

            string baseAttachmentsPath = ConfigurationManager.AppSettings["Avatar"];

            bool   useAttachmentsRelativePath  = false;
            string sUseAttachmentsRelativePath = ConfigurationManager.AppSettings["UseAttachmentsRelativePath"];

            if (!string.IsNullOrWhiteSpace(sUseAttachmentsRelativePath) && bool.TryParse(sUseAttachmentsRelativePath, out bool bUseAttachmentsRelativePath))
            {
                useAttachmentsRelativePath = bUseAttachmentsRelativePath;
            }

            string currentPathAttachments;
            string folderName = request.TargetFolder;

            if (!string.IsNullOrWhiteSpace(folderName))
            {
                if (useAttachmentsRelativePath)
                {
                    currentPathAttachments = "~/" + baseAttachmentsPath + folderName + @"/".MapHostAbsolutePath();
                }
                else
                {
                    currentPathAttachments = baseAttachmentsPath + folderName + @"\";
                }

                if (!Directory.Exists(currentPathAttachments))
                {
                    Directory.CreateDirectory(currentPathAttachments);
                }
                else
                {
                    AttachmentsIO.ClearDirectory(currentPathAttachments);
                }
            }
            else
            {
                do
                {
                    DateTime date = DateTime.Now;
                    folderName = date.ToString("yy") + date.Month.ToString("d2") +
                                 date.Day.ToString("d2") + "_" + MD5HashGenerator.GenerateKey(date);

                    if (useAttachmentsRelativePath)
                    {
                        currentPathAttachments = "~/" + baseAttachmentsPath + folderName.MapHostAbsolutePath();
                    }
                    else
                    {
                        currentPathAttachments = baseAttachmentsPath + folderName;
                    }
                } while (Directory.Exists(currentPathAttachments));
                Directory.CreateDirectory(currentPathAttachments);
                if (useAttachmentsRelativePath)
                {
                    currentPathAttachments += @"/";
                }
                else
                {
                    currentPathAttachments += @"\";
                }
            }

            if (postedFile.ContentLength > 0)
            {
                postedFile.SaveTo(currentPathAttachments + Path.GetFileName(postedFile.FileName));
            }

            var attachmentsResult = AttachmentsIO.getAvatarsFromFolder(folderName, "Avatar");

            response.ErrorThrown         = false;
            response.ResponseDescription = folderName;
            response.Result = attachmentsResult;
            return(response);
        }
예제 #15
0
        public object Post(PostAttachment request)
        {
            var response = new CommonResponse();

            string attachmentKind = request.AttachmentKind;

            if (attachmentKind == null || attachmentKind == "")
            {
                response.ErrorThrown         = true;
                response.ResponseDescription = "Attachment Kind was not specified.";
                return(response);
            }

            if (Request.Files.Length == 0)
            {
                throw new HttpError(HttpStatusCode.BadRequest, "NoFile");
            }

            var postedFile = Request.Files[0];

            string fileName = postedFile.FileName;

            string baseAttachmentsPath = AppSettings.Get <string>(attachmentKind);

            bool   useAttachmentsRelativePath  = false;
            string sUseAttachmentsRelativePath = AppSettings.Get <string>("UseAttachmentsRelativePath");

            if (!string.IsNullOrWhiteSpace(sUseAttachmentsRelativePath) && bool.TryParse(sUseAttachmentsRelativePath, out bool bUseAttachmentsRelativePath))
            {
                useAttachmentsRelativePath = bUseAttachmentsRelativePath;
            }

            string currentPathAttachments;
            string folderName = request.TargetFolder;

            if (!string.IsNullOrWhiteSpace(folderName))
            {
                if (useAttachmentsRelativePath)
                {
                    currentPathAttachments = "~/" + baseAttachmentsPath + folderName + @"/".MapHostAbsolutePath();
                }
                else
                {
                    currentPathAttachments = baseAttachmentsPath + folderName + @"\";
                }

                if (!Directory.Exists(currentPathAttachments))
                {
                    Directory.CreateDirectory(currentPathAttachments);
                }
            }
            else
            {
                string folderPrefix = request.FolderPrefix;
                if (string.IsNullOrWhiteSpace(folderPrefix) || folderPrefix == "undefined" || folderPrefix == "null")
                {
                    folderPrefix = "";
                }
                do
                {
                    DateTime date = DateTime.Now;
                    folderName = folderPrefix + date.ToString("yy") + date.Month.ToString("d2") +
                                 date.Day.ToString("d2") + "_" + MD5HashGenerator.GenerateKey(date);

                    if (useAttachmentsRelativePath)
                    {
                        currentPathAttachments = "~/" + baseAttachmentsPath + folderName.MapHostAbsolutePath();
                    }
                    else
                    {
                        currentPathAttachments = baseAttachmentsPath + folderName;
                    }
                } while (Directory.Exists(currentPathAttachments));
                Directory.CreateDirectory(currentPathAttachments);
                if (useAttachmentsRelativePath)
                {
                    currentPathAttachments += @"/";
                }
                else
                {
                    currentPathAttachments += @"\";
                }
            }

            if (postedFile.ContentLength > 0)
            {
                postedFile.SaveTo(currentPathAttachments + Path.GetFileName(postedFile.FileName));
            }

            var attachmentsResult = AttachmentsIO.getAttachmentsFromFolder(folderName, attachmentKind);

            response.ErrorThrown         = false;
            response.ResponseDescription = folderName;
            response.Result = attachmentsResult;
            return(response);
        }
예제 #16
0
        public object avatar()
        {
            CommonResponse response = new CommonResponse();

            try
            {
                if (HttpContext.Current.Request.Files.AllKeys.Any())
                {
                    var postedFile = HttpContext.Current.Request.Files["file"];
                    if (postedFile != null)
                    {
                        string fileName = postedFile.FileName;

                        string baseAttachmentsPath = ConfigurationManager.AppSettings["Avatar"];

                        string currentPathAttachments;
                        string folderName = HttpContext.Current.Request["targetFolder"];
                        if (folderName != null && folderName.Trim() != "")
                        {
                            currentPathAttachments = baseAttachmentsPath + folderName + @"\";
                            if (!Directory.Exists(currentPathAttachments))
                            {
                                Directory.CreateDirectory(currentPathAttachments);
                            }
                            else
                            {
                                AttachmentsIO.ClearDirectory(currentPathAttachments);
                            }
                        }
                        else
                        {
                            do
                            {
                                DateTime date = DateTime.Now;
                                folderName = date.ToString("yy") + date.Month.ToString("d2") +
                                             date.Day.ToString("d2") + "_" + MD5HashGenerator.GenerateKey(date);
                                currentPathAttachments = baseAttachmentsPath + folderName;
                            } while (Directory.Exists(currentPathAttachments));
                            Directory.CreateDirectory(currentPathAttachments);
                            currentPathAttachments += @"\";
                        }

                        if (postedFile.ContentLength > 0)
                        {
                            postedFile.SaveAs(currentPathAttachments + Path.GetFileName(postedFile.FileName));
                        }

                        List <Avatar> attachmentsResult = AttachmentsIO.getAvatarsFromFolder(folderName, "Avatar");

                        response.ErrorThrown         = false;
                        response.ResponseDescription = folderName;
                        response.Result = attachmentsResult;
                    }
                }
            }
            catch (Exception e)
            {
                response.ErrorThrown         = true;
                response.ResponseDescription = "ERROR: " + e.Message;
                response.Result = e;
            }

            return(response);
        }
예제 #17
0
    protected void btnSendSurvey_Click(object sender, EventArgs e)
    {
        if (supplier.ContactEmail.Trim() != txtEmail.Text.Trim())
        {
            SupplierCRUD supplierCRUD = new SupplierCRUD();
            supplier.ContactEmail = txtEmail.Text.Trim();
            if (!supplierCRUD.update(supplier))
            {
                Navigator.goToPage("~/Error.aspx", "ERROR:" + supplierCRUD.ErrorMessage);
                return;
            }
        }

        SupplierSurveyCRUD surveyCRUD = new SupplierSurveyCRUD();
        SupplierSurvey     survey     = new SupplierSurvey();

        survey.SupplierMasterKey = supplier.Id;
        survey.SentToVendor      = DateTime.Now;
        supplier.SupplierSurvey  = survey;



        ConnectionManager CM = new ConnectionManager();

        Data_Base_MNG.SQL DM = CM.getDataManager();

        /*Begin Transaction*/
        DM.Open_Connection("Survey Save");


        string idGenerated = surveyCRUD.createAndReturnIdGenerated(survey, ref DM);

        if (!surveyCRUD.ErrorOccur)
        {
            TokenCRUD token_CRUD = new TokenCRUD();
            Token     token      = new Token();
            token.Subject     = "SURVEY";
            token.SubjectKey  = long.Parse(idGenerated);
            token.TokenNumber = MD5HashGenerator.GenerateKey(DateTime.Now);
            if (token_CRUD.create(token, ref DM))
            {
                Email       NewMail = new Email();
                MailMessage Message = new MailMessage();

                Message.From = new MailAddress("*****@*****.**", "*****@*****.**");
                Message.To.Add(new MailAddress(supplier.ContactEmail.ToString()));
                Message.Subject      = "Survey";
                Message.IsBodyHtml   = true;
                Message.BodyEncoding = System.Text.Encoding.UTF8;
                //Message.Body = "Aqui va el link con el token= " + " <a href:\"http://localhost:29724/APQM/Vendor/RFQ.aspx?token=" + token.TokenNumber + "\">Link</a>";
                //Message.Body = "Aqui va el link con el token= " + " <a href:\"http://www.google.com\">Google</a>";

                string strEmailContent = "Dear Potential Supplier," + Environment.NewLine
                                         + "Please click the following link to fill out our supplier survey form.  Please fill out as completely as possible.  Once we have received your completed survey, a representative will contact you to discuss the next steps."
                                         + Environment.NewLine + Environment.NewLine
                                         + "http://" + Request.Url.Authority + Request.ApplicationPath + "/Vendor/Survey.aspx?token=" + token.TokenNumber
                                         + Environment.NewLine + Environment.NewLine
                                         + "Thank you for your time. We look forward to hearing from you."
                                         + Environment.NewLine + Environment.NewLine
                                         + "Sincerely," + Environment.NewLine + Environment.NewLine + "The Capsonic Advanced Purchasing Team";


                AlternateView htmlView = AlternateView.CreateAlternateViewFromString(strEmailContent);
                Message.AlternateViews.Add(htmlView);

                try
                {
                    NewMail.SendMail(Message);
                }
                catch
                {
                    DM.RollBack();
                    Navigator.goToPage("~/Error.aspx", "ERROR:Could not send email to: " + supplier.ContactEmail.ToString());
                    return;
                }
            }
            else
            {
                Navigator.goToPage("~/Error.aspx", "ERROR:" + token_CRUD.ErrorMessage);
                return;
            }
        }
        else
        {
            Navigator.goToPage("~/Error.aspx", "ERROR:" + surveyCRUD.ErrorMessage);
            return;
        }

        DM.CommitTransaction();
        DM.Close_Open_Connection();

        if (DM.ErrorOccur)
        {
            Navigator.goToPage("~/Error.aspx", "ERROR:" + DM.Error_Mjs);
            return;
        }

        supplier = null;
        Ok_Click(this, e);
    }
예제 #18
0
        public object Post(PostAttachment request)
        {
            var AttachmentKind = request.AttachmentKind;

            if (!IsValidJSValue(AttachmentKind))
            {
                throw new KnownError("Invalid [Attachment Kind].");
            }

            if (Request.Files.Length == 0)
            {
                throw new HttpError(HttpStatusCode.BadRequest, "NoFile");
            }

            var    postedFile = Request.Files[0];
            string FileName   = postedFile.FileName;

            string baseAttachmentsPath = AppSettings.Get <string>(AttachmentKind);

            if (string.IsNullOrWhiteSpace(baseAttachmentsPath))
            {
                throw new KnownError("Invalid Attachment Kind.");
            }

            bool   useAttachmentsRelativePath  = false;
            string sUseAttachmentsRelativePath = AppSettings.Get <string>("UseAttachmentsRelativePath");

            if (!string.IsNullOrWhiteSpace(sUseAttachmentsRelativePath) && bool.TryParse(sUseAttachmentsRelativePath, out bool bUseAttachmentsRelativePath))
            {
                useAttachmentsRelativePath = bUseAttachmentsRelativePath;
            }

            string currentPathAttachments;
            string folderName = request.TargetFolder;

            if (IsValidJSValue(folderName))
            {
                if (useAttachmentsRelativePath)
                {
                    currentPathAttachments = "~/" + baseAttachmentsPath + folderName + @"/".MapHostAbsolutePath();
                }
                else
                {
                    currentPathAttachments = baseAttachmentsPath + folderName + @"\";
                }

                if (!Directory.Exists(currentPathAttachments))
                {
                    Directory.CreateDirectory(currentPathAttachments);
                }
            }
            else
            {
                string folderPrefix = request.FolderPrefix;
                if (!IsValidJSValue(folderPrefix))
                {
                    folderPrefix = "";
                }

                do
                {
                    DateTime date = DateTime.Now;
                    folderName = folderPrefix + date.ToString("yy") + date.Month.ToString("d2") +
                                 date.Day.ToString("d2") + "_" + MD5HashGenerator.GenerateKey(date);

                    if (useAttachmentsRelativePath)
                    {
                        currentPathAttachments = "~/" + baseAttachmentsPath + folderName.MapHostAbsolutePath();
                    }
                    else
                    {
                        currentPathAttachments = baseAttachmentsPath + folderName;
                    }
                } while (Directory.Exists(currentPathAttachments));
                Directory.CreateDirectory(currentPathAttachments);
                if (useAttachmentsRelativePath)
                {
                    currentPathAttachments += @"/";
                }
                else
                {
                    currentPathAttachments += @"\";
                }
            }

            if (postedFile.ContentLength > 0)
            {
                Log.Info($"Attachment Posted: [{currentPathAttachments + Path.GetFileName(postedFile.FileName)}] by User: [{GetSession().UserName}]");
                postedFile.SaveTo(currentPathAttachments + Path.GetFileName(postedFile.FileName));
            }

            return(new // FileId
            {
                FileName,
                AttachmentKind,
                Directory = folderName
            });
        }